Mem0, Zep and Letta are the three names that come up first for agent memory, and they are three different kinds of product:
- Mem0 is a memory store. You add messages, its model extracts memories, and you search them before a model call (how it works).
- Zep is a temporal knowledge graph. You add messages and data, it builds a graph per user whose facts carry validity dates, and it returns a context block for your prompt (retrieving context).
- Letta is an agent runtime. It runs the agent itself, and the agent edits its own memory (agent SDK).
The first half of this page compares the three neutrally, from each vendor's own documentation as checked on the date above. The second half says where Threadless AI, which we make, fits and where it does not.
At a glance
| Mem0 | Zep | Letta | |
|---|---|---|---|
| Kind of product | Memory store | Temporal knowledge graph and context platform | Platform that runs stateful agents |
| Who runs the agent loop | You | You | Letta |
| Who builds the prompt | You, with search results | You, with Zep's context block | Letta |
| Scope | User, agent, app or run (entity-scoped memory) | A graph per user, plus shared graphs (user graphs) | Per agent, shared across its conversations (stateful agents) |
| Who writes memories | Mem0's LLM, when you add | Zep, extracting from episodes (graph creation) | The agent, editing its own files (MemFS) |
| Time | Opt-in recency bias at search time (changelog) | Bi-temporal facts: when true, when learned (paper) | Git history of edits |
| Graph | Hosted Custom plan only (pricing) | The core of the product | No; Markdown files |
| Context window | Yours to manage | Block sized by Zep; the rest is yours | Managed; older messages summarised near the limit (conversations) |
| Open source | Apache-2.0, without graph memory (platform vs OSS) | Graphiti, Apache-2.0; Community Edition no longer maintained | Apache-2.0 (GitHub) |
| Self-hosting | Open-source edition | Graphiti plus Neo4j, FalkorDB or Neptune (Graphiti) | Local runtime or self-hosted server (self-hosting) |
| Free tier | Free plan with monthly limits | 10,000 credits a month | Up to 3 agents |
| Paid entry | Custom, unpriced (pricing) | Flex $125 a month (pricing) | Pro $20 a month (pricing) |
Architecture
Mem0: a store you search
Your code calls add with messages and an id such as user_id; Mem0's model extracts memories and stores them. Before a model call you call search and place what comes back in the prompt. On the hosted service, graph memory links entities, but the pricing page lists it under the Custom plan, not Free (pricing); the open-source edition dropped its external graph stores with the v3 pipeline (platform vs OSS).
Zep: a temporal graph per user
Zep ingests episodes (messages, JSON or text) and extracts entities and facts into a user's graph. Each fact records when it held and when Zep learned it, which the Zep paper calls a bi-temporal model (paper). That makes questions like "what plan were they on in March?" answerable. The graph library, Graphiti, is open source; Zep stopped maintaining its self-hosted Community Edition in April 2025 (announcement).
Letta: the agent manages itself
Letta, founded by the creators of MemGPT (about), runs the agent. Memory is MemFS, a git repository of Markdown files the agent reads, writes and reorganises; root files load into the system prompt every turn, and background subagents consolidate lessons (MemFS). In March 2026 Letta named Letta Code its flagship and began retiring some server-side features (Letta's next phase).
The benchmark dispute
All three vendors have published LoCoMo numbers, and they disagree.
- Mem0's paper (2025) ran LoCoMo with GPT-4o-mini and an LLM judge. It reported Mem0 at 66.88% (68.44% with graph), Zep at 65.99%, and a full-context baseline at 72.90% (paper).
- Zep's rebuttal said Mem0 had misconfigured Zep: both speakers were given the user role, timestamps were put in message text instead of Zep's
created_atfield, and searches ran one after another, inflating latency. Rerun, Zep reported 75.14% (rebuttal). - Letta reported 74.0% on LoCoMo with a simple agent using plain file tools and GPT-4o mini, against Mem0's reported 68.5% (blog).
- Mem0 now reports 92.5 on LoCoMo and 94.4 on LongMemEval for its managed platform (research), and its repository notes these include "proprietary optimizations not available in the open-source SDK" (GitHub).
- Zep's paper reports LongMemEval 71.2% with gpt-4o, against 60.2% for full context (paper).
| Result | Who ran it | System measured |
|---|---|---|
| LoCoMo 66.88% | Mem0 | Mem0 |
| LoCoMo 65.99% | Mem0 | Zep |
| LoCoMo 75.14% | Zep | Zep |
| LoCoMo 74.0% | Letta | Letta file-tool agent |
| LoCoMo 92.5, LongMemEval 94.4 | Mem0 | Mem0 managed platform |
| LongMemEval 71.2% | Zep | Zep |
What to take from it: every number was produced by a vendor, Zep's own rerun moved its score by about nine points, and a full-context baseline beat Mem0 in Mem0's own paper. Run candidates on your own conversations.
When to choose each
- Mem0 when you want user-level memory across sessions with the least integration, an open-source edition, and control of your own prompt.
- Zep when facts change over time and you need to know what held when, or business data belongs in the same graph.
- Letta when you want the platform to run the agent and the agent to curate its own memory, with open source and many model providers.
When none of them fits
All three answer "what does the agent know?". Neither Mem0 nor Zep manages the conversation you send each turn, and Letta does so only by running your agent. If your agent already runs on OpenAI and its problem is one long conversation outgrowing the window, there is a fourth design.
Threadless AI returns the whole request. Before each model call your agent sends what is new to decorate and gets back the request, with the history managed, to submit to OpenAI with its own key; it calls report with the reply. The request holds the latest messages word for word and the facts from older messages. Before older messages stop being sent word for word, your model notes their key facts with a note tool, and those facts stay in view; when the conversation turns back to something older, the older messages that matter come back, with their dates. Token use stays bounded. The SDK falls back to the local tail of recent messages if Threadless AI cannot be reached. See what the model gets.
Where it is the wrong choice: memory shared across a user's conversations (Mem0 or Zep), point-in-time queries (Zep), a platform that runs the agent (Letta), providers other than OpenAI, self-hosting. We have no published benchmark scores yet; we are running LongMemEval and LoCoMo and will publish them with the method.
| Mem0 | Zep | Letta | Threadless AI | |
|---|---|---|---|---|
| Returns | Memories | A context block | The agent's reply | The whole OpenAI request |
| Scope | User, agent, app or run | User | Agent | One conversation |
| Who writes memories | Mem0 | Zep | The agent | Your agent's model notes key facts, with a note tool |
| Self-host | Yes | Graphiti only | Yes | No |
Questions people ask
What is the difference between Mem0, Zep and Letta?
Mem0 is a memory store you add to and search. Zep is a temporal knowledge graph that returns a context block. Letta is a platform that runs the agent, which edits its own memory.
Is Zep better than Mem0?
On facts that change over time, Zep's dated facts are the stronger design. Mem0 is simpler to start with and has an open-source edition. Their published benchmark comparisons contradict each other, so test both on your data.
Is Letta better than Mem0?
They are different products. Letta runs your agent and manages its context; Mem0 gives an agent you already run a memory to search. Choose by whether you want to keep your own agent loop.
Which of Mem0, Zep and Letta is open source?
Letta is Apache-2.0. Mem0's open-source edition is Apache-2.0 without graph memory. Zep's graph library, Graphiti, is Apache-2.0, but its self-hosted Community Edition is no longer maintained.
Can I self-host Zep in 2026?
Not as a maintained product. You can run Graphiti with Neo4j, FalkorDB or Amazon Neptune yourself.
What is LoCoMo?
A benchmark of very long conversations, about 300 turns each over up to 35 sessions, with questions that need facts from across them (paper). Vendors' LoCoMo scores differ by setup, model and judge.