Mem0 vs Zep vs Letta vs Supermemory (2026)
Mem0, Zep, Letta, and Supermemory compared from their own docs: memory model, open source, hosting, MCP, and best fit. Plus when you need decisions, not memory.
Agent memory has become its own product category, and four names come up in almost every comparison: Mem0, Zep, Letta, and Supermemory. Searches like "mem0 vs zep vs letta" show up in Google's suggestions, and most results are written by one of the vendors.
This comparison uses each product's own documentation and GitHub repository, checked on 5 November 2026. It is not a benchmark. It describes what each tool is built to do, so you can match it to your problem. One section at the end covers a problem none of them is built for.
The short answer
| Mem0 | Zep | Letta | Supermemory | |
|---|---|---|---|---|
| What it is | A memory layer for AI apps and agents | A context layer for enterprise data | A platform for stateful agents | A memory and context API |
| Memory model | Extracted memories, scoped by user, agent, app, and run | Temporal context graphs, built on Graphiti | Core memory plus archival memory, edited by the agent | A semantic graph organized by namespace |
| Open source | Apache-2.0 | Graphiti is Apache-2.0 | Apache-2.0 | MIT |
| Hosting | Managed platform or open source | Hosted context layer; Graphiti runs anywhere | Letta Cloud or self-hosted | Hosted API, or self-hosted as a single binary |
| Claude Code and MCP | Hosted MCP server with Claude Code setup | Graphiti has an experimental MCP server | Has its own coding agent | Claude Code plugin and MCP server |
| Best for | Adding recall to an app you already build | Changing facts across business data | Running agents that keep state | One API for memory, retrieval, and user profiles |
GitHub stars on 5 November 2026, as a rough measure of developer interest: Mem0 68,435, Graphiti 32,536, Supermemory 31,532, Letta 25,352.
Mem0: a memory layer you add to your app
Mem0 describes itself as a managed memory layer that persists context across sessions without you running infrastructure. It extracts memories from interactions, links entities across them, and recalls the relevant ones at query time. Memories are scoped by user, agent, app, and run, which keeps one customer's memories away from another's.
There are two ways to run it: the hosted Platform, or the open-source version under Apache-2.0. The hosted MCP server exposes tools such as add_memory, search_memories, update_memory, and delete_memory, and has documented setup for Claude Code.
Choose it when you are building an application or agent and want memory as a component, especially per-user memory in a product.
Watch for what happens when a stored fact changes. Recall is based on relevance, so check how your setup handles an old memory and its replacement.
Zep: temporal context graphs for enterprise data
Zep now positions itself as a unified context layer for enterprise data: it combines business data, documents, and conversations into shared, governed context for agents, organized in temporal context graphs. Its open-source foundation is Graphiti, a framework for temporal knowledge graphs.
"Temporal" is the point. A temporal graph tracks how facts change over time, so it can tell what was true before a change and what is true now, instead of holding two conflicting statements side by side.
Graphiti's MCP server supports FalkorDB and Neo4j as backends and needs an LLM provider key for extraction. Its own README calls it experimental.
Choose it when your agents work over business data where facts change often, such as accounts, ownership, or status, and you need history.
Watch for operational weight if you self-host Graphiti: a graph database, model providers, and extraction quality to monitor.
Letta: stateful agents that manage their own memory
Letta, formerly MemGPT, is not a memory add-on. It is a platform for building stateful agents that keep their state on the server and learn from use. Each agent has core memory, which stays in its immediate context, and archival memory for long-term storage, and the agent edits its own memory as it works.
It is open source under Apache-2.0 and runs on Letta Cloud or self-hosted. Letta also offers its own coding agent, available from a CLI, a web app, and GitHub Actions.
Choose it when you want the platform to run your agents and handle memory end to end, rather than adding memory to an agent you built elsewhere.
Watch for the size of the commitment. Adopting Letta means adopting its agent runtime, not just a memory store.
Supermemory: one API for memory, retrieval, and profiles
Supermemory calls itself context infrastructure for AI agents: memory, retrieval, and user profiles through one API. You send it text, files, chats, or data from connectors, and it indexes them into a semantic graph organized by namespace, which agents query.
It is MIT-licensed on GitHub, available as a hosted API, and can be self-hosted as a single binary, including fully offline. For Claude Code there is a plugin that captures and recalls memories through hooks. Hosted usage is billed in credits.
Choose it when you want one service for memory and retrieval across many content sources, or need a self-hosted option that runs offline.
Watch for what the capture hooks send and who can retrieve it, before you point it at company work.
Do you need any of them?
For a coding agent, maybe not. Claude Code already has built-in memory: CLAUDE.md files you write and auto memory it writes itself, loaded at the start of every session. A subagent with project-scope memory can even share what it learns with the team through git. Start there, and add a memory layer only for a gap you can name. For the details, see how Claude Code memory works and the best MCP memory server for Claude Code.
For an application you are building, such as a support bot that should remember each customer, a memory layer like Mem0 or Supermemory is the right category.
When you need decisions instead of memory
All four tools are built for recall: given a query, return the relevant things an agent learned or was told. Some, like Zep's temporal graphs, also track how facts change.
None is built to answer a different question: did the team agree to this, who owns it, and is it still the rule? A memory layer can store "exports never include internal notes" as easily as it stores a customer's timezone. It can't tell you that the product lead approved it, that the security team must sign off on changes, or that last week's exception for admins replaced it.
For preferences, history, and facts about users, that is fine. For decisions a team must build against, it is the gap.
Where Lockstep fits
Lockstep is shared team memory for Claude Code, built for decisions rather than recall. Decisions are captured from PRDs, Slack, and pull requests and become binding when their owner approves them. When one changes, the new version replaces the old one, and the old one stays visible as replaced. Claude Code is briefed on the current decisions that apply at the start of each session, and any MCP agent can query them.
It is not a general memory layer and doesn't replace Mem0, Zep, Letta, or Supermemory for recall. Many teams will want both. Session briefings work with Claude Code today. See how it works.
Sources checked 5 November 2026
- https://docs.mem0.ai/overview
- https://docs.mem0.ai/platform/mem0-mcp
- https://help.getzep.com/overview
- https://github.com/getzep/graphiti
- https://github.com/getzep/graphiti/blob/main/mcp_server/README.md
- https://docs.letta.com/overview
- https://supermemory.ai/docs/intro
- https://supermemory.ai/docs/integrations/claude-code
- GitHub repositories: mem0ai/mem0, getzep/zep, getzep/graphiti, letta-ai/letta, supermemoryai/supermemory
Related reading
For memory servers you connect to Claude Code, see the best MCP memory server for Claude Code. For add-on tools by the job they do, see the best memory tools for Claude Code. For how memory, the context window, and RAG differ, see agent memory vs context window vs RAG.
Frequently asked questions
- What is the difference between Mem0 and Zep?
- Mem0 is a memory layer you add to an application: it extracts memories from interactions and recalls relevant ones, scoped by user, agent, app, and run. Zep positions itself as a context layer for enterprise data, combining business data, documents, and conversations into temporal context graphs built on its open-source Graphiti framework.
- What is the difference between Letta and Mem0?
- Letta is a full agent platform: agents keep state on a server and edit their own core and archival memory. Mem0 is a memory component you add to an agent you build elsewhere. Choose Letta if you want the platform to run the agent; choose Mem0 if you only want memory.
- Which agent memory tools are open source?
- As of 5 November 2026, Mem0, Letta, Graphiti, and Zep's examples repository are Apache-2.0 on GitHub, and Supermemory is MIT. Each also offers a hosted service, and the hosted versions have features and pricing of their own.
- Which memory tool works with Claude Code?
- Mem0 has a hosted MCP server with documented Claude Code setup, and Supermemory has a Claude Code plugin and an MCP server. Graphiti, which Zep is built on, has an experimental MCP server. Claude Code also has its own built-in auto memory, which may be enough on its own.
- Can a memory layer store team decisions?
- It can store the text of a decision, but it won't know whether the decision was approved, who owns it, or whether a later one replaced it. Memory layers are built for recall. Decisions that a team must follow need an owner, a status, and a replacement history.
Keep reading