Best AI Agent Memory Tools in 2026: 9 Options Compared

Summary

No single AI agent memory tool is best in 2026; the right choice depends on what your agent has to remember. Mem0 is a common starting point for personalization, Membase suits teams that want one memory shared across their app and AI tools, Zep (with its open-source engine Graphiti) is designed for facts that change over time, Letta suits long-running autonomous agents, and Cognee is built for document knowledge graphs. LangMem, Hindsight and Supermemory cover the LangGraph-library, open-source-engine and managed-API cases. This guide compares all nine by use case, license, price, deployment and MCP support, as checked on 2026-10-14.

Disclosure: we build Membase. Every tool, including ours, is described from its official documentation, pricing pages and repositories, and Membase's limitations are stated as plainly as everyone else's.

Which agent memory tool should you pick? A quick comparison

Several vendors meter usage in credits, tokens or requests, so the bill depends on your workload.

How do you choose an agent memory tool?

A vector database stores and finds text, but memory also needs extraction, updating, conflict resolution and forgetting. The tools differ mainly in how they handle those steps. Four questions narrow the field.

1. What does the agent need to remember?

• Personalization (preferences and profile facts per end user): Mem0 and Supermemory, or LangMem inside LangGraph.
• Shared memory across tools (one memory that ChatGPT, Claude, a coding agent and your own app all use): Membase is built for this; Mem0 and Supermemory also reach coding agents through MCP and plugins.
• Facts that change over time: Zep and Graphiti keep a bi-temporal graph that invalidates old facts without deleting them. Membase and Supermemory also supersede outdated facts while keeping history, without a graph query API.
• Autonomous, long-running agents: Letta treats memory as part of the agent runtime.
• Document knowledge graphs: Cognee turns files, repositories and workplace tools into a graph plus vector index.

2. Hosted or self-hosted? Graphiti and LangMem are self-host only. Mem0, Letta, Cognee and Hindsight offer both an open-source self-hosted path and a managed cloud. Zep and Membase are primarily hosted; Supermemory and Membase offer local modes with limits, described below.

3. Which license can you accept? If you need to fork or redistribute the engine, choose an Apache-2.0 or MIT project and check that the part you need is in the open repository; several vendors keep the engine or specific features proprietary.

4. How do you want to pay? Models differ: request quotas (Mem0), credits per byte ingested (Zep), per-token rates (Cognee, Hindsight, Supermemory) and per-agent or per-seat plans (Letta). Estimate write and read volume before comparing headline prices.

Mem0

Mem0 is a memory layer for AI agents, available as an Apache-2.0 Python and TypeScript SDK with an optional self-hosted server, and as a managed service, Mem0 Platform. An LLM extracts facts from conversations, and retrieval combines semantic, BM25 keyword and entity matching.

Best for: developers who want per-user long-term memory with very little setup, either as a managed API or self-hosted with their own vector store and LLM. Integrations include LangChain, LangGraph, CrewAI, LlamaIndex, the Vercel AI SDK and the OpenAI Agents SDK.

Trade-offs: since version 2.0.0 (April 2026), queryable graph memory is a Platform feature and is no longer part of the open-source SDK. Mem0's published benchmark scores come from the managed platform. On paid tiers, retrieval quotas are ten times smaller than add quotas, which matters for read-heavy agents.

MCP: the current official option is a hosted MCP server at mcp.mem0.ai, documented for Claude Code, Cursor, Codex and other clients. The earlier local, self-hosted OpenMemory MCP server has been removed from the Mem0 repository, although its marketing page is still online.

License and pricing: the SDKs, CLI and self-hosted server are Apache-2.0; the Platform is proprietary. Hobby is free (10,000 add and 1,000 retrieval requests per month), Starter is $19/month (50,000 adds, 5,000 retrievals), Pro is $249/month (500,000 adds, 50,000 retrievals, graph memory) and Enterprise is custom, including on-prem deployment. Self-hosting has no usage fees beyond your own infrastructure. mem0.ai

Membase

Membase, built by Unibase, is a hosted long-term memory layer for people and their AI agents, with an optional local engine. One memory, organized into containers called Memories, is filled from chats, files, Notion and agents, and is read through a web app, a Chrome extension, MCP, a REST API, Python and TypeScript SDKs and a CLI. The engine keeps an evidence-centered lifecycle: superseded facts are invalidated rather than deleted, and conversational retrieval is hybrid lexical plus vector. Our technical report describes the design.

Best for: teams or individuals who want one memory shared across consumer assistants (ChatGPT, Claude, Gemini, Grok, DeepSeek and Kimi through the Chrome extension) and their own agents and coding tools (Claude Code, Cursor, Codex, VS Code and Windsurf through MCP). Access is scoped per container, OAuth consent is revocable per client, and users can review, correct, delete and export what is remembered.

Trade-offs:

• License. Membase is not open source. The SDKs, CLI and MCP server source is public on GitHub under a proprietary Membase SDK License, and the core engine is closed and compiled.
• Multi-tenant apps. The documentation advises against using containers as per-user isolation boundaries; each end user needs their own Membase account with OAuth consent or a per-user key. Tools with per-user scoping under one API key, such as Mem0, are simpler for B2B apps.
• Offline and self-hosting. Local mode still calls an LLM and, by default, OpenAI embeddings, so it is not fully offline by default. There is no documented self-hosted server, VPC or air-gapped offering.
• Consistency. Learning runs on "Update now" or on a schedule, so new writes are not instantly searchable, and temporal validity is not exposed as a graph query API.
• Maturity. The current SDK packages are at version 0.3, and a desktop app is listed as coming soon.

MCP: a hosted streamable HTTP endpoint is listed in the official MCP Registry, with OAuth (read-only consent tokens) or developer keys at read, read and write, or full access levels. A local MCP server runs with membase --local mcp.

Pricing: a free plan is available, with an initial allowance of chat turns; you can continue by connecting your own model key or subscription. Paid plans exist in the app, but prices are not published at the time of writing. Local mode is free to run; you pay your model provider. membase.ai

Zep

Zep is a managed context and memory service that turns chat messages, business data and documents into per-user temporal knowledge graphs, which Zep calls Context Graphs. Each fact carries when it was true in the world and when it was recorded. When new information contradicts an old fact, the old edge is invalidated but kept, so an agent can ask what is true now or what was true on a past date.

Best for: production and enterprise agents where facts change, such as CRM, sales and support agents that mix chat history with structured business data. Enterprise adds audit logs, SOC 2 Type II, a HIPAA BAA and bring-your-own-cloud deployment.

Trade-offs: there is no supported self-hosted Zep server; Community Edition support ended in April 2025, and the self-host route is Graphiti. The first paid tier is $125/month, and credits scale with episode size, so ingesting large payloads at high volume is costly. Version 4 SDKs introduced breaking changes.

License and pricing: Zep Cloud is proprietary. Billing is in credits: one credit per 350 bytes of each episode, with retrieval and storage not charged. The Free tier includes 10,000 credits per month, Flex is $125/month (50,000 credits), Flex Plus is $375/month (200,000 credits) and Enterprise is custom. MCP: a hosted MCP server with OAuth sign-in, with per-plan seats. getzep.com

Graphiti

Graphiti is Zep's open-source Python framework for building temporal knowledge graphs as agent memory, and the engine behind Zep's commercial service. LLMs extract entities and relationships from incoming episodes and attach validity windows; old facts are invalidated rather than deleted. Retrieval fuses vector, BM25 and graph search.

Best for: teams that want a free, self-hosted memory layer with point-in-time queries, provenance back to source episodes and custom entity and edge types, on Neo4j, FalkorDB or Amazon Neptune.

Trade-offs: Graphiti is a library, not a turnkey service: user and thread management, dashboards and SLAs are yours to build. It is Python only. Each episode triggers several LLM calls, and its README warns that small or local models without reliable structured output may fail ingestion. Anonymous telemetry is on by default (opt-out).

License and pricing: Apache-2.0 across the repository, free to use; you pay for your graph database and LLM usage. MCP: an official MCP server in the repository, labeled experimental, runs locally over HTTP or stdio with FalkorDB or Neo4j. Graphiti on GitHub

Letta

Letta, formerly MemGPT, is a platform for stateful agents that keep their identity and long-term memory across sessions. Its main product is now Letta Code, an Apache-2.0 agent harness with a CLI, desktop app, web app and self-hostable App Server, backed by the paid Letta Cloud. Each agent's memory is a git-backed filesystem of Markdown files; the agent edits its own memory, every edit is a commit, and background "dreaming" subagents consolidate lessons from recent conversations.

Best for: developers who want one persistent agent that keeps learning across conversations and machines, such as coding assistants and team bots.

Trade-offs: Letta is a full agent runtime, not a drop-in memory API for an existing framework. The current Agent SDK is TypeScript only, and the Python client targets the older API, which Letta labels legacy. Agent memory has no semantic or vector index by default; agents search it with file tools unless you add an optional search module. Older articles describing the MemGPT-era Docker server are out of date.

License and pricing: the open-source code is Apache-2.0; Letta Cloud is proprietary. The Free plan is limited to three stateful agents, Pro is $20/month, the API plan is $20/month plus $0.10 per active agent per month and tool-execution time, Teams Pro is $20 per seat per month, and Enterprise is custom. Self-hosting is free apart from your LLM costs. MCP: a hosted MCP server lets other clients create and message Letta agents, and the Agent SDK can call external MCP servers. letta.com

Cognee

Cognee is an open-source Python memory engine that turns ingested data into a knowledge graph plus vector embeddings, with a managed service, Cognee Cloud. Since Cognee 1.0 (June 2026), the public API has four verbs: remember, recall, improve and forget.

Best for: graph-based memory over documents and company data, such as a shared knowledge base built from Slack, GitHub, Linear, Notion, Google Drive and code repositories. It can run locally without an LLM key using a local extraction model or Ollama, and supports custom ontologies and data models.

Trade-offs: the extraction step adds ingestion cost and latency. Running the graph on a single Postgres instance is a demo feature in the open-source version, with the production version licensed separately. Bi-temporal memory and conflict resolution are advertised only on the Enterprise tier, whose prices are not published.

License and pricing: Apache-2.0 for the open-source core and MCP server. Cognee Cloud's Free tier includes one workspace and 1M tokens; Standard is $1.00 per 1M tokens processed plus $5 per additional workspace per month. The pricing page does not define which tokens are counted. MCP: a self-hosted MCP server (stdio, HTTP or SSE) and a hosted endpoint with OAuth sign-in, plus Claude Code and Codex plugins. cognee.ai

LangMem

LangMem is LangChain's MIT-licensed Python library for long-term agent memory, built on LangGraph's store. It extracts facts from conversations, consolidates or updates them, and can rewrite an agent's own prompts from feedback (procedural memory). Memory can be written by the agent mid-conversation through tools, or in the background after a conversation ends.

Best for: teams already building on LangGraph or LangChain in Python that want memory as a library stored in their own Postgres, Redis or MongoDB database, with no separate vendor service.

Trade-offs: Python only. There is no MCP server and no graph or temporal model; memories are JSON items in namespaced stores with optional vector search. The latest PyPI release is 0.0.30 from October 2025, and recent repository activity is mostly maintenance. The only published LoCoMo numbers come from a competitor's 2025 paper, which reported multi-second search latency in hot-path mode, so test latency on your own setup.

License and pricing: MIT and free; you pay your LLM and embedding provider. Hosting on LangChain's commercial deployment platform is priced separately by LangChain. LangMem documentation

Hindsight

Hindsight, from Vectorize, is an MIT-licensed long-term memory engine with three main operations: retain, recall and reflect. Retain extracts typed facts, entities and temporal data into isolated memory banks on Postgres with pgvector. Recall runs semantic, keyword, graph and temporal strategies in parallel and fuses the results; reflect is a reasoning loop over the stored memory.

Best for: teams that want an open-source, self-hostable memory engine with no usage limits and broad integrations, from LangGraph and CrewAI to coding agents such as Claude Code and Cursor. Hindsight Cloud suits teams that want usage-only billing without seats or monthly fees.

Trade-offs: on Cloud, retain is the most expensive operation and every write requires LLM extraction, so write-heavy workloads cost more. The pages we read list no compliance certifications such as SOC 2. Self-hosting needs Postgres with pgvector and an LLM provider.

License and pricing: MIT for self-hosting; the Cloud service and Enterprise features are commercial. Cloud is prepaid pay-as-you-go: retain $10.00 per 1M input tokens, recall $0.75 per 1M tokens, reflect $0.05 per call, plus storage at $0.25 per 1M tokens per month after the first 30 days. New accounts get free starting credits. MCP: built into the API server when self-hosted, and available on Cloud with OAuth. hindsight.vectorize.io

Supermemory

Supermemory is a hosted memory and context API. You send text, files or URLs; it extracts facts into a temporal graph that combines vector, full-text and graph search, and maintains user profiles as always-on context. Search returns the latest version of a fact while history is kept.

Best for: developers who want a managed memory layer with very little setup, with per-user or per-tenant namespaces, including apps on the Vercel AI SDK, LangChain or Mastra and coding agents through plugins. SOC 2, a HIPAA BAA and supported self-hosting are available on the Scale plan.

Trade-offs: the GitHub repository is MIT, but the server engine is proprietary, built from a non-public codebase. The free local binary is limited by a lite license and does not include connectors or the MCP server. Billing is prepaid credits spent at per-token, per-query and per-operation rates, and usage stops when the balance runs out, which makes costs less predictable than a flat plan.

License and pricing: Free ($5 credits per month), Pro $19/month ($20 credits), Max $100/month ($130 credits), Scale $399/month ($600 credits) and custom Enterprise. MCP: a hosted MCP server with OAuth sign-in, available on the hosted platform only. supermemory.ai

A note on benchmark scores

LoCoMo and LongMemEval results are hard to compare across tools. Almost every number published for these tools is self-reported by the vendor, and setups differ in ways that change results: the reader model that writes the answer, the judge model that grades it, the retrieval budget, and whether the score measures recall of the right passage or accuracy of the final answer. Some scores come from a managed service, others from an engine configuration that differs from the product default.

LoCoMo also has known errors in its answer key. One external audit argues that a fully correct system would score only about 93.6%, which makes small differences near the top of the leaderboard hard to interpret.

For these reasons we do not rank the tools by benchmark score here. Our own figures, measured on the Membase engine rather than the hosted API, and their limitations are in the Membase technical report. The most useful test is a small evaluation on your own conversations and questions, with the reader and judge held constant.

When were these prices and licenses checked?

Prices, plan limits and licenses in this article were checked on 2026-10-14 against each vendor's pricing page, documentation, GitHub repository and package registry. Several products changed pricing, licensing or architecture in 2026. Check the official pricing page before you commit, and treat older third-party comparisons with caution.