Best Memory Layers for AI Agents in 2026

What a Memory Layer Does

An agent that forgets your name, your stack and last week’s decision every time a session ends is not useful for long. A context window does not fix this: it is expensive to refill, it overflows, and it cannot tell you which of two conflicting facts is current. A memory layer is the component that extracts durable facts from conversations, stores them, retrieves the right few at the right time, and updates or forgets them as the world changes.

The short version of the ranking: Mem0 is the easiest drop-in for per-user memory, Zep with Graphiti is the best fit when facts change and history matters, Letta is the pick when you want the agent itself to manage memory, LangMem is the free library for LangGraph teams, and the local tools claude-mem, agentmemory and Engram are the practical choice for coding agents. Every price and score below is dated, and every benchmark number is vendor-reported unless stated otherwise.

Video: “How AI Agent Memory Actually Works in 2026 (Mem0, Letta, Zep)” by Pico AI Lab, a third-party walkthrough of the three most-compared memory layers. A second explainer, “Agent Memory EXPLAINED - Complete Architecture” from Hugging Face, is on YouTube. We list both as background; the facts in this article come from the vendors’ own pages.

Quick Picks

Two honest caveats before the detail. First, the independent benchmark picture is thin: nearly every score published for these tools comes from the vendor selling the tool, with different models, judges and retrieval budgets. Second, the cheapest memory is often the simplest one. Claude’s own memory tool is just a directory of files, and Letta published a result where a plain file with search tools beat a specialized memory product on LoCoMo. Start simple and add a layer when you can name the failure it fixes.

Master Comparison Table

Prices come from each vendor’s live pricing page, fetched Nov 11, 2026. Licenses come from the GitHub repositories. “Not described” means the page we fetched did not mention the feature, not that it is absent.

Vector, Graph, Hybrid or Files

Four architectures show up across these products, and the differences explain most of the tradeoffs.

• Vector plus keyword (hybrid retrieval). Mem0 runs semantic, BM25 keyword and entity matching in parallel and fuses them. agentmemory fuses BM25, vectors and graph traversal with Reciprocal Rank Fusion. This is the workhorse design: cheap, fast, and good at fuzzy recall. If you need the raw store underneath, our vector database comparison covers the options.
• Temporal knowledge graph. Graphiti stores entities as nodes and facts as edges with validity windows. When a fact changes, the old edge is invalidated rather than deleted, so you can ask what was true last March. Cognee and MemOS also build graph structure from ingested data.
• Self-editing memory blocks. Letta descends from MemGPT. The agent has labeled blocks such as human and persona and edits them with tool calls, so memory management lives inside the agent loop rather than beside it.
• Plain files. Claude’s memory tool exposes a /memories directory with view, create, str_replace, insert, delete and rename commands. Coding-agent tools add SQLite, Chroma or a vault on top. Files are transparent, diffable and easy to audit, but retrieval quality depends on how well the agent organizes them.

The practical implication is that “graph versus vector” is less important than whether your facts are mostly additive (preferences, summaries) or mostly mutable (status, ownership, plans). Additive memories suit hybrid retrieval. Mutable ones suit a graph with validity windows or an agent that rewrites its own notes.

Mem0

What it is. Mem0 is a memory layer you add to an existing agent. The README describes memory scoped to User, Session and Agent state, with single-pass, ADD-only extraction: memories accumulate and are not overwritten. Entities are extracted, embedded and linked across memories, and retrieval fuses semantic, BM25 and entity matching, with temporal reasoning to rank dated memories. Defaults are OpenAI gpt-5-mini and text-embedding-3-small.

Pricing (as of Nov 11, 2026). The live pricing page lists two plans. Free is usage-based beyond limits: during the first 30 days, 10,000 adds and 1,000 retrievals per month with model calls covered by Mem0; with your own LLM key, 50,000 adds and 10,000 retrievals per month, community support only, and you set a monthly cap on overage. Custom is enterprise, price “set in your agreement,” and adds graph memory (entity linking), user profiles, Dream memory consolidation, advanced analytics, SSO, audit logs, SLA and on-prem deployment. The page’s meta description still mentions Pro plans, but no Pro plan appears on the page, so check before budgeting.

Self-host and SDKs. Apache-2.0. Three deployment modes: the library for prototyping, a Docker Compose self-hosted server on localhost:3000 with auth on by default, and the managed platform at app.mem0.ai. SDKs are Python and npm (both named mem0ai), a CLI, agent skills for coding assistants, and LangGraph and CrewAI integrations. The README we fetched does not describe MCP support.

Strengths. Smallest integration surface of the group, a large community (about 68.8k GitHub stars as of Nov 12, 2026), and the most aggressively published benchmark numbers. Weaknesses. Graph memory is listed under the Custom plan, so the free tier is not the graph-capable product. Mem0 itself says its headline scores reflect the managed platform and that open-source users should expect “directionally similar gains but not identical numbers.” Best for: adding per-user memory to a support bot or assistant in an afternoon.

# pip install mem0ai
from mem0 import Memory

m = Memory()   # defaults: OpenAI gpt-5-mini + text-embedding-3-small
m.add("I switched to vegetarian last month", user_id="alice")
hits = m.search("what should I cook for Alice?", user_id="alice")
print(hits)

Zep and Graphiti

What it is. Graphiti is an open-source Python framework for temporal context graphs and is the graph layer inside Zep. It stores entities, facts as edges with validity windows, and episodes (the raw source data that provenance traces back to). Old facts are invalidated rather than deleted. Ontology can be prescribed with Pydantic models or learned. Retrieval combines semantic search, BM25 and graph traversal. Zep is the managed product built on it, adding a hosted graph database, users, ingestion, dashboards, SDKs and SLAs.

Pricing (as of Nov 11, 2026). Free: 10,000 credits per month, no rollover, 2 projects, lower priority episode processing. Flex: $125 per month with 50,000 credits, then $25 per 10,000, 600 requests per minute, 5 projects, community support, cloud only. Flex Plus: $375 per month with 200,000 credits, then $75 per 40,000, 1,000 requests per minute, observations, custom extraction instructions, webhooks and analytics. Enterprise is custom, with SOC 2 Type II, HIPAA BAA, audit logs and a DPA. Credits are metered on ingestion: 1 credit per episode up to 350 bytes plus 1 per additional 350 bytes; retrieval, storage, users and graph storage cost 0 credits. The page shows an annual option with a 17% saving without listing annual prices.

Self-host. Graphiti itself is Apache-2.0 and self-hosted: you supply the graph database (Neo4j 5.26, FalkorDB 1.1.2, Amazon Neptune with OpenSearch Serverless, or Kuzu 0.11.2, which is deprecated because its upstream is unmaintained), an LLM and an embedder. For the full Zep product, only Enterprise offers self-hosting through BYOC inside your VPC; the other tiers are cloud-only. Graphiti ships a reference MCP server, and its README warns the reference MCP and REST servers have no authentication, authorization or prompt-injection protection, so do not expose them to untrusted networks.

Strengths. The only entry here built around time: you can query current or historical state, and every fact traces to a source episode. About 32.8k stars for Graphiti as of Nov 12, 2026. Weaknesses. More moving parts, a graph database to run, and ingestion costs LLM calls (default concurrency capped at 10 by SEMAPHORE_LIMIT to avoid 429s). The pricing page does not mention Graphiti and the self-host path for the managed product is enterprise-only. Best for: customer or account agents where facts change and you must explain what the agent believed and when.

# Graphiti: you bring the graph database, LLM and embedder
# Supported graph stores per the README: Neo4j 5.26, FalkorDB 1.1.2,
# Amazon Neptune (+ OpenSearch Serverless), Kuzu 0.11.2 (deprecated)
# Default LLM/embedder is OpenAI; concurrency capped by SEMAPHORE_LIMIT (default 10)

Letta (MemGPT)

What it is. Letta is the successor to MemGPT and is a platform for stateful agents rather than a memory add-on. In the quickstart, agents carry labeled memory blocks such as human and persona, and the agent edits them itself. The GitHub repo says active source now lives in the letta-code repository (agent harness, terminal UI, App Server), with the retired V1 API server on an archive branch, and the docs note the V1 SDK is being deprecated in favor of the Letta Agent SDK. The Agent SDK also mentions MemFS, a git-tracked memory system, as a newer option.

Pricing (as of Nov 11, 2026). Free is $0 with up to 3 stateful agents, 5 MiB storage per memory repository and bring-your-own keys. Pro is $20 per month with $20 in credits, up to 20 agents and 50 MiB per repository. Teams Pro is $20 per seat per month. Enterprise is custom with RBAC, SAML/OIDC SSO and dedicated support. Credits cover LLM inference and CPU time; server-side tools cost $0.00015 per second of CPU time, remote MCP tools have no credit cost, and BYOK usage bills to your own provider. Letta’s own guide says casual coding is typically around $100 per month or more and power users often reach $200 or more, which is the number to plan around if you run coding agents on credits.

Self-host and MCP. Apache-2.0 (about 25.4k stars as of Nov 12, 2026). letta server runs the App Server for local or self-hosted agents, and the Agent SDK connects to hosted or self-hosted deployments. The docs list MCP server and tool endpoints, though the pages we fetched did not describe them in depth. Strengths. The agent owns its memory, which suits long-running autonomous work, and Letta argues for filesystem-style memory with evidence (see benchmarks). Weaknesses. You adopt a runtime, not a library, and the API generation change (V1 deprecated) means older tutorials may not match. Best for: teams building a stateful agent from scratch who want memory management to be part of the agent’s own reasoning. If you are still choosing the surrounding stack, see our best AI agent frameworks guide.

npm install -g @letta-ai/letta-code
letta          # interactive terminal UI
letta server   # App Server for local or self-hosted agents

LangMem

What it is. LangMem is LangChain’s memory library, MIT licensed (about 1.8k stars as of Nov 12, 2026). It has a functional core API that works with any storage system, memory-management tools the agent calls in the hot path, and a background memory manager that extracts, consolidates and updates knowledge. It integrates natively with LangGraph’s long-term memory store, which the README says is available by default in all LangGraph Platform deployments. The examples use InMemoryStore, which loses data on restart; for production the README recommends a database-backed store such as AsyncPostgresStore.

Pricing. There is no standalone hosted offering or pricing page; you pay for your LLM calls and storage. Strengths. No vendor lock-in, easy to reason about, and prompt-refinement features beyond pure memory. Weaknesses. It is tied conceptually to LangGraph, the page does not name specific memory types, and we found no MCP support or published benchmarks in the sources we fetched. Best for: LangGraph teams that want memory without another vendor. Pair it with observability from our LLM observability and eval tools roundup so you can see what the memory manager writes.

# pip install -U langmem
from langgraph.prebuilt import create_react_agent
from langgraph.store.memory import InMemoryStore
from langmem import create_manage_memory_tool, create_search_memory_tool

store = InMemoryStore(index={"dims": 1536, "embed": "openai:text-embedding-3-small"})
agent = create_react_agent(
    "anthropic:claude-3-5-sonnet-latest",
    tools=[create_manage_memory_tool(namespace=("preferences",)),
           create_search_memory_tool(namespace=("preferences",))],
    store=store,   # swap for AsyncPostgresStore in production
)

Supermemory

What it is. Supermemory combines a memory engine that extracts facts and handles updates and expiry, auto-maintained user profiles, hybrid search that blends RAG and memory in one query, connectors (Google Drive, GitHub and others) and file processing for PDFs, images, video and code.

Pricing (as of Nov 11, 2026). Free $0 with $5 monthly credits, 1M tokens of plain-text memory, 5M tokens SuperRAG and 1M searches. Pro $19 per month with $20 credits. Max $100 per month with $130 credits. Scale $399 per month with $600 credits, advanced PDF extraction, S3 and web-crawler connectors, SOC 2, HIPAA BAA and a self-hosted option. Enterprise is custom with air-gapped self-hosting or a dedicated managed instance. Rates are the same on every plan and the limits assume all credits go to one meter. Qualifying startups and academic teams get Scale free for three months.

MCP, SDKs, self-host. The hosted MCP server at mcp.supermemory.ai/mcp exposes three tools: memory (save or forget), recall (search) and context (inject the user profile), and the README lists Claude Desktop, Cursor, Windsurf, VS Code, Claude Code, OpenCode, OpenClaw and Hermes as clients. Official packages exist for JavaScript and Python, with wrappers for Vercel AI SDK, LangChain, LangGraph, OpenAI Agents SDK, Mastra, Agno and n8n. The repo is MIT and describes a local server on localhost:6767 using local embeddings by default, with data under ~/.supermemory; the pricing page separately lists a self-hosted option under Scale, so confirm terms with the vendor if self-hosting is a hard requirement.

Strengths. The cheapest paid tier in the group ($19), strong MCP story, and a roughly 31.6k-star MIT repo as of Nov 12, 2026. Weaknesses. Benchmark claims are self-reported with no independent audit, so read its research pages carefully. Best for: one memory shared across Claude Code, Cursor and your own app. Our MCP integration platforms comparison covers the wider MCP tooling around it.

# Hosted MCP server (tools: memory, recall, context)
https://mcp.supermemory.ai/mcp

# Or run the local server on http://localhost:6767
npx supermemory local

Cognee

What it is. Cognee turns text into entities, relationships and searchable chunks, and turns code into a graph of symbols and dependencies. At query time it selects graph, vector or code context. The README describes a Postgres setup combining relational metadata, PGVector and graph state, but labels that graph store a demo feature with a production version offered as a licensed product.

Pricing (as of Nov 11, 2026). Free: $0, 1M tokens included, 1 workspace, unlimited users and API calls. Standard: $1.00 per 1M tokens processed plus $5 per additional workspace, adding source integrations (Slack, Notion, Linear, Google Drive) and code indexing. Enterprise is contact-sales, delivered as a BYOC engagement, with bi-temporal memory and conflict resolution, provenance on every answer and per-user personalization. The page says you can run the open-source engine locally for free, and cloud-hosted runs use gpt-oss-120b.

SDKs and MCP. Apache-2.0 (about 33.3k stars as of Nov 12, 2026). Python 3.10 to 3.14, a TypeScript SDK, Rust (Cognee-RS), a REST API, an MCP server for Cursor, Cline and other clients (port 8001 in Docker Compose), and Claude Code, Codex and OpenClaw plugins. Without an LLM key it uses a local GLiNER model for extraction, which the page calls a demo extractor, and recall then returns matching source text rather than a generated answer. Strengths. Ingestion-first design for documents, chats and code, plus the clearest usage-based price. Weaknesses. Some enterprise features, such as bi-temporal memory, are gated, and its published BEAM scores come with unusually candid caveats about method. Best for: turning a messy pile of documents and repos into queryable agent memory.

uv pip install "cognee[gliner]"
cognee-cli remember "Marie Curie was born in Warsaw." -d local_quickstart
cognee-cli recall "Where was Marie Curie born?" -d local_quickstart

MemOS

What it is. MemOS from MemTensor describes itself as a Memory Operating System that unifies store, retrieve and manage for long-term memory. It exposes a unified memory API for add, retrieve, edit and delete, structured as a graph, with multi-modal memory (text, images, tool traces, personas), multi-cube knowledge bases that can be isolated, shared or composed across users, projects and agents, an asynchronous MemScheduler, and feedback-driven correction. The local plugin describes L1 traces, L2 policies, L3 world models and crystallized skills.

Pricing, self-host, SDKs. Apache-2.0 (about 12.4k stars as of Nov 12, 2026). Deployment options are a Docker Compose self-hosted service with Neo4j and Qdrant, a local SQLite plugin with hybrid FTS5 and vector retrieval, and a hosted Cloud API with keys starting mpg-. The pages we fetched publish no pricing for the cloud. No dedicated language SDK is named: examples call the REST API with Python requests, and plugins ship as npm packages for hosts including OpenClaw, Hermes Agent and DeepSeek Harness. The repo carries an mcp topic tag but the README text does not describe MCP support, so we could not confirm it.

Strengths. Rich graph and multi-cube model, flexible local-to-cloud deployment, and permissive license. Weaknesses. Pricing is opaque, the SDK story is REST-first, and the headline scores (LoCoMo 88.83, LongMemEval 89.20) are vendor-reported through the vendor’s own OmniMemEval without baselines or methodology on the page. Best for: teams who want a graph-structured, multi-tenant memory they can self-host and who are comfortable with a younger, REST-centric API.

OpenAI and Anthropic Built-in Memory

Two different things share the word memory here: product memory inside a chat app, and developer memory you wire into your own agent.

Claude: app memory and the API memory tool

In claude.ai, memory is on by default for Free, Pro, Max and Ultra plans on web, desktop and mobile; Team and Enterprise owners decide whether it is available, and it does not start on in HIPAA-enabled organizations. Claude saves memory as individual topics while you chat, each project has its own memory, and you can pause, reset, edit or import and export memory (the import and export feature is labeled experimental). Incognito chats are not saved. Health, politics and religion topics are not saved by default, and government IDs, criminal history, financial account numbers and immigration status are never saved.

For developers, the Claude API memory tool is client-side. You add {"type": "memory_20250818", "name": "memory"} to the tools list, Claude requests file operations under /memories (view, create, str_replace, insert, delete, rename), and your application executes them against storage you choose. The docs list it as stable and eligible for zero data retention on the Claude API, Bedrock, Google Cloud and Microsoft Foundry, with SDK helpers in Python, TypeScript, C# and Java and a ready-made local-filesystem implementation for Python and TypeScript. It pairs with context editing and compaction for long-running agents, and the docs put security on you: reject paths outside /memories, cap file sizes and expire stale files. Our best AI coding agents roundup shows where this pattern appears in coding tools.

OpenAI: ChatGPT memory and the Agents SDK

ChatGPT has saved memories (things you asked it to remember) and a separate reference to past chat history, with Temporary Chats that neither use nor create memory. OpenAI’s help center blocked our automated fetch (HTTP 403), so we do not state current plan availability or project-memory details here; check the live memory FAQ before relying on them. On the API side, we found no first-party hosted long-term memory service. The OpenAI Agents SDK documents sessions, which maintain conversation history across runs, and vendors such as Mem0, Supermemory and Cognee publish integrations that add cross-session memory on top. Treat that as a search-based finding rather than an OpenAI statement.

Coding-Agent Memory Tools

Coding agents lose the most when a session ends: the decision about why a function is shaped a certain way, the flaky test, the deployment quirk. Three open tools target this directly, and each has its own guide on Agentpedia.

claude-mem

claude-mem runs a second agent that takes notes during your sessions, then starts the next session with a compact index of relevant past observations and fetches full detail only when needed. Storage is local in ~/.claude-mem: SQLite for observations, sessions and summaries, with Chroma adding semantic search. Cloud sync is opt-in. MCP tools are search, timeline and get_observations, and install is npx claude-mem install. The README states Apache-2.0 and lists Claude Code, Codex, Cursor and OpenCode among supported agents; the repo had roughly 116k stars as of Nov 12, 2026. Full details are in our claude-mem guide.

agentmemory

agentmemory is a persistent memory server for coding agents. Retrieval fuses BM25 (always on), vector similarity (when an embedding provider is configured) and graph traversal with Reciprocal Rank Fusion. Its default keyless mode needs no API key. It exposes a REST API on port 3111, a viewer on port 3113 and an MCP server with 54 tools when connected to a running server (7 local tools otherwise), supports around 27 agents, and installs with npx -y @agentmemory/agentmemory@latest on Node.js 20 or newer. Apache-2.0, about 30.3k stars as of Nov 12, 2026. Its vendor-reported LongMemEval-S retrieval figures are in the benchmark table below. See our agentmemory guide.

Engram

Engram is a local memory daemon from EL AI Intelligence with an encrypted SQLCipher vault, one JSON API, an MCP server for Claude Code, Cursor and Windsurf, and deletes that propagate to search and sync. The local daemon is free; only encrypted sync is paid, at $10 per month (Personal), $29 (Team) and $99 (Organization), flat with no per-seat charges, per the numbers in our Engram guide, which we verified in September 2026 and have not re-fetched for this roundup. Choose it when privacy and provable deletion outrank features.

How they differ: claude-mem optimizes token use through progressive disclosure, agentmemory optimizes retrieval breadth across many agents, and Engram optimizes encryption and deletion. All three are local first, so none charge per memory operation. Wiring any of them into an editor is an MCP exercise; see best MCP servers for Claude Code for the surrounding setup.

Benchmarks and What They Prove

No neutral, widely accepted leaderboard exists for these tools as of Nov 11, 2026. Every row below was published by the vendor, using its own models, judge and retrieval budget, so the numbers are not comparable across rows. LoCoMo measures question answering over long two-person conversations. LongMemEval measures multi-session recall, temporal reasoning and knowledge updates over longer histories. BEAM tests recall at 1M and 10M token scales. None of them measures whether an agent behaves better in your product.

Three lessons stand out. First, vendors disagree about each other: Zep says Mem0 ran Zep with both participants assigned the user role, timestamps appended to message text instead of the created_at field, and searches run sequentially, and publishes its corrected 75.14% figure. Second, a plain baseline is strong: Zep reports that full-context scored about 73% on LoCoMo against Mem0’s best of about 68%, and Letta reported 74.0% with a file plus search tools. Third, even candid vendors caveat their own results: Cognee notes its two BEAM settings use different conversations and selection procedures, and agentmemory states that its figures measure retrieval only. Letta also stresses its filesystem agent was not grep-only: semantic search was the required first step and the weaker GPT-4o mini needed tool rules.

What to do instead: build a 50 to 100 question test from your own transcripts, include knowledge-update cases ("the user moved last month"), fix the model and judge, and compare two candidates plus a full-context baseline. Log tokens per query and p95 latency next to accuracy, because Mem0, Supermemory and Zep all pitch efficiency as much as accuracy.

How to Choose

If you run your own agent infrastructure, memory is only one component. Hosting options are covered in best AI agent hosting platforms, and retrieval storage in the vector database guide.

Setup Snippets

Two snippets show the extremes: a managed-style library call, and a bring-your-own-storage tool. The Mem0 snippet follows the README defaults; the Claude snippet follows the SDK example in the memory-tool docs. Neither was executed for this article, so treat them as starting points and run them against current SDK versions.

# pip install mem0ai
from mem0 import Memory

m = Memory()   # defaults: OpenAI gpt-5-mini + text-embedding-3-small
m.add("I switched to vegetarian last month", user_id="alice")
hits = m.search("what should I cook for Alice?", user_id="alice")
print(hits)

# Claude API memory tool: client-side, you own the storage
import anthropic
from anthropic.tools import BetaLocalFilesystemMemoryTool

client = anthropic.Anthropic()
memory = BetaLocalFilesystemMemoryTool(base_path="./memory")

runner = client.beta.messages.tool_runner(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user",
               "content": "Remember that customer Acme Corp prefers email follow-ups."}],
    tools=[memory],
)
print(runner.until_done().content)

Checklist before production: scope every read and write by user or tenant; set a retention and expiry policy; decide whether deletes must propagate (Engram and Graphiti’s invalidation model differ); validate paths in file-backed memory; keep reference MCP servers off public networks; and monitor what the extractor writes, because bad extractions become durable bad facts.

How We Evaluated

This ranking has no paid placement and no affiliate links. For each tool we fetched the vendor’s live pricing page, its GitHub README or docs, and for benchmarks the vendor’s own pages, then cross-checked disputed claims against the counterparty’s response. Where a page did not mention a feature, such as MCP for Mem0, we say it was not described rather than assuming absence. We did not run the tools ourselves for this roundup, so the evaluation is document-based; the snippets come from vendor docs and were not executed. Stars and prices are volatile and carry dates. Existing Agentpedia guides supply the detail for coding-agent tools.

FAQ

Sources

All pages fetched Nov 11 to 12, 2026 unless noted.

Pricing pages

• Mem0 pricing
• Zep pricing
• Letta pricing
• Supermemory pricing
• Cognee pricing

Repositories and docs

• mem0ai/mem0
• getzep/graphiti
• letta-ai/letta and Letta docs
• langchain-ai/langmem
• supermemoryai/supermemory
• topoteretes/cognee
• MemTensor/MemOS
• thedotmack/claude-mem
• rohitg00/agentmemory
• Claude API memory tool
• Claude chat search and memory (help center)
• OpenAI memory FAQ (automated fetch returned 403; not relied on for detail)
• OpenAI Agents SDK sessions (found via search, not fetched directly)

Benchmarks and disputes

• Zep: A Temporal Knowledge Graph Architecture for Agent Memory (arXiv)
• Zep: Is Mem0 really SOTA in agent memory?
• Letta: Benchmarking AI agent memory

Video and Agentpedia guides

• How AI Agent Memory Actually Works in 2026 (Mem0, Letta, Zep)
• agentmemory guide
• claude-mem guide
• Engram guide
• Best vector databases for AI agents