AI Agent Memory Frameworks Ranked (2026): mem0 vs Zep vs Letta

Every agent memory framework is good at remembering. The interesting question, and the one that decides whether your agent is trustworthy, is what happens to a fact after you correct it. Tell an assistant the price changed, the meeting moved, the client's name is spelled differently now, and a surprising number of memory systems will surface the old value again a week later. Not because they are broken, but because most of them store memories by similarity, and similarity cannot tell a contradiction from a duplicate. So this is a tier list of the agent memory frameworks people actually reach for in 2026, ranked on exactly one axis: does a correction retire the thing it replaced, or does it quietly live on.

We build a local-first assistant at recal, so this failure mode is something we hit and fixed rather than one we read about. None of the picks below is recal, which is a personal memory layer rather than a server-side agent framework, and where our approach sits comes at the very end. The tiers are on the merits of the one axis that matters here: correction.

Key takeaways

• If correctness over time is the priority, a temporal knowledge graph like Zep (Graphiti) is the strongest answer, because it treats "this used to be true" as a first-class state instead of a deletion.
• mem0 is the fastest way to bolt persistent memory onto any agent and has excellent retrieval, but its supersession is a heuristic add-versus-update call, so a restated old fact can slip back in.
• Letta (formerly MemGPT) gives the agent the power to edit its own memory, which is a capability, not a guarantee, since it depends on the agent choosing to correct itself.
• Raw vectors plus retrieval is the cheapest start and the one most likely to un-forget, because an embedding index has no notion of a fact being retired.
• The reliable fix, whichever tool you choose, is recording the retirement at write time, not hoping retrieval sorts it out later.

How we ranked them: the correction axis

Vector recall, latency, and framework support are all real, and the tools below mostly do them well. We are deliberately not ranking on those. The single axis here is supersession: when a new fact contradicts an old one, does the system record that the old one stopped being true, and can retrieval then avoid surfacing it as if it were current. A system earns a high tier when correction happens at write time and is enforced, and a low tier when correction is left to similarity math or to a model's judgment at read time. Everything else about each tool is summarized honestly, but the tier reflects correction only.

S tier: Zep (Graphiti)

Zep builds a temporal knowledge graph from an agent's conversations and records, powered by the open-source Graphiti engine, which crossed twenty thousand GitHub stars in 2026. The design choice that puts it here: every fact carries time, when it became true, when it stopped being true, and where it came from. When a new fact contradicts an existing one, Graphiti invalidates the old edge rather than deleting it, so the history is preserved but the stale value is no longer treated as current. That is precisely the behavior an agent needs to stop contradicting itself, and almost no other approach models it natively. Zep's own paper reports large latency reductions versus stuffing full history into context and meaningful accuracy gains on reasoning tasks. The honest catch is operational weight: you are running a graph service, and the quality of the graph depends on the extraction step that builds it. If a corrected fact is the thing that bites you, this is the most principled answer on the list.

A tier: Letta (MemGPT)

Letta packages the MemGPT idea as a full agent runtime with memory tiers inspired by computer architecture: a small core-memory block that lives in the context window like RAM, plus recall and archival layers behind it. The agent reads and writes its own memory blocks through tools, and Letta can project that memory as plain files tracked in a local workspace. Correction is genuinely possible here, because the agent can rewrite a block to reflect a new truth, and self-editing memory is a real strength for long-horizon tasks. It lands at A rather than S because correction is a capability the agent must exercise, not an invariant the system enforces. If the agent does not notice the contradiction, nothing retires the old block. The other honest catch is lock-in: Letta owns the agent loop, so adopting it is a bigger commitment than bolting on a memory layer, and moving off it later is measured in weeks.

B tier: mem0

mem0 is the most convenient memory layer of the group and, on pure retrieval, arguably the best. It is framework-agnostic: you wrap your LLM calls, it extracts facts, stores them, and injects the relevant ones into future prompts, with a narrow SDK surface and low lock-in. mem0 reports strong results on the standard long-memory benchmarks and does it at a fraction of the tokens of a full-context baseline, which is why so many teams start here. It sits at B on the correction axis specifically because supersession runs through a heuristic: when a new fact arrives, a model decides whether to add it or update an existing one. That works often and fails quietly, since a restated old value can be read as a fresh addition and re-enter the store. It is a great default for most agents; just know that "the correction stuck" is a probability here, not a guarantee, and design around that if facts of record matter.

B tier: LangMem and framework-native memory

LangMem and the memory primitives inside the larger agent frameworks give you stores, search, background memory formation, and update calls. They are well built and they hand you the pieces to implement correction properly, including updating or removing a memory rather than only appending. They land here because they are a toolkit rather than an opinion: the supersession policy is yours to write, and if you wire it as append-plus-search without an explicit retire step, you inherit the same un-forget behavior as raw vectors. Reach for these when you want control and are willing to own the correction logic yourself. The catch is exactly that ownership, because the default happy path rarely includes retirement.

C tier: raw vectors plus retrieval

A vector database with retrieval-augmented generation, whether pgvector, Redis, or a hosted index, is the baseline almost everyone starts from, and on the correction axis it is the weakest. You embed facts and retrieve by similarity. There is no native concept of a fact being retired, so a corrected value and its replacement both sit in the index, and cosine similarity cannot tell which one is a contradiction of the other. Either can surface, and the confident, well-embedded stale note often wins. This is the exact mechanism behind the un-forget bug, and we wrote up the full version of it in poisoning a RAG store. It stays useful as a substrate, and plenty of the tools above sit on top of one, but as your whole memory it will resurrect things you thought you fixed.

The tiers at a glance

Framework	What it is	How correction works	Tier	Main catch
Zep (Graphiti)	Temporal knowledge graph	Invalidates contradicted facts at write time, keeps history	S	Graph service to run and extract
Letta (MemGPT)	Agent runtime with tiered memory	Agent self-edits its own memory blocks	A	Correction is agent-dependent; high lock-in
mem0	Framework-agnostic memory layer	Heuristic add-versus-update at write time	B	Restated old facts can slip back in
LangMem and native memory	Memory toolkits	Update and remove primitives you compose	B	You own the supersession policy
Raw vectors plus RAG	Similarity index	None; append and retrieve by similarity	C	No notion of a retired fact

Frequently asked questions

What is the best open source agent memory framework in 2026?

It depends on the axis you care about. For correctness over time, Zep with the open-source Graphiti engine is the most principled, because it models when a fact stopped being true. For plug-in convenience and retrieval quality, mem0 is the fastest to adopt. For a full self-editing agent runtime, Letta is the most complete. There is no single winner; there is a winner per priority.

mem0 vs Zep vs Letta: which should I pick?

Pick mem0 to add persistent memory to an existing agent in an afternoon with minimal lock-in. Pick Zep when your agent reasons over facts that change and must not contradict itself, since its temporal graph is built for exactly that. Pick Letta when you want the memory system and the agent runtime as one opinionated stack and are ready to build around it.

Why do memory tools un-forget a fact after you correct it?

Because most of them store memories as embeddings and retrieve by similarity, and similarity cannot distinguish a contradiction from a duplicate. The corrected fact and the old one both live in the index. Unless something recorded that the old value was retired at the moment you corrected it, retrieval can surface either, and the older, more richly described note often ranks higher.

Does mem0 handle contradictions?

It has an update step where a model decides whether a new fact should replace an existing memory, so it handles many contradictions. It is a heuristic rather than a guarantee, so for facts of record like prices, dates, or identifiers, it is worth adding your own explicit retirement rather than trusting the add-versus-update call every time.

Where recal sits

recal is not on this list because it is not a server-side agent framework; it is a local-first personal memory layer for your own machine. But the correction axis is the entire reason we care about this space. We treat a correction as a first-class write at capture time, so retiring the old value happens in the same act as recording the new one, rather than being reconstructed by similarity at read time. That is the same lesson each tool above encodes in its own way, and the ones that encode it explicitly are the ones you can trust with a fact of record. If you want the long version of the failure mode and the fix, poisoning a RAG store is the deep dive, and the trust ladder is how we think about letting a memory-driven agent act on what it remembers.

---

Written by the recal team with AI assistance and human review. Tool behaviors described here reflect each project's public documentation and papers as of July 2026; frameworks move quickly, so verify the current design before you commit. We build a local-first assistant, and we called out our own bias where it exists.