Mem0 vs Zep vs Letta vs Cognee: Agent Memory Compared

If you are picking an AI agent memory system in 2026, four names come up again and again: Mem0, Zep (built on Graphiti), Letta (formerly MemGPT), and Cognee. They all promise to give your agent a memory, but they solve different problems and they are not interchangeable. This agent memory comparison cuts through the marketing so you can match a tool to your actual use case.

Quick verdict

Mem0 wins on simplicity and cost - it is the drop-in memory layer to reach for first. Zep wins on temporal reasoning thanks to its bi-temporal knowledge graph, which is what you want when facts change over time. Letta wins for long-running autonomous agents that should manage their own memory, if you accept heavy lock-in. Cognee wins when you need graph-native reasoning over documents plus conversations. There is no single best - the right pick depends on whether you need portability, temporal accuracy, agent autonomy, or relationship-rich knowledge.

What are the four AI agent memory contenders?

Each of these projects tackles memory from a different angle. Here is the plain-English version before we get into the numbers.

Mem0 (mem0ai/mem0, ~63k stars as of 2026) is a basic memory layer. It stores memories in a vector store with an optional graph, and an LLM extracts facts and consolidates them through ADD, UPDATE, and DELETE operations. It is framework-agnostic - it plugs into LangChain, CrewAI, LlamaIndex, and AutoGen - and ships Python, TypeScript, and REST clients. For a deeper look, see our post on what Mem0 actually is.

Zep is a managed product built on Graphiti (getzep/graphiti, ~30k stars as of 2026), an advanced temporal knowledge graph. It is bi-temporal, meaning it tracks both when a fact was true (valid time) and when it was recorded (transaction time). Instead of deleting superseded facts, it invalidates them, which enables point-in-time queries. Retrieval is sub-200ms with no LLM in the read path. We go deep on this design in temporal knowledge graphs for agent memory.

Letta (letta-ai/letta, ~24k stars as of 2026) was rebranded from MemGPT in September 2024. It is a memory OS and self-editing agent runtime. It combines core memory (in-prompt editable blocks), archival memory (vector), and recall memory (history). The agent edits its own memory with tools, memory blocks are shareable across agents, and sleep-time compute reorganizes memory when the agent is idle. It ships the ADE visual IDE.

Cognee (topoteretes/cognee, ~30k stars as of 2026) is a graph plus vector knowledge engine. It runs an ECL pipeline (Extract, Cognify, Load) on the dlt framework, ships many ingestion connectors, and exposes remember, recall, forget, and improve operations. It is built for relationship-rich reasoning over documents plus conversations.

How do Mem0, Zep, Letta, and Cognee compare on the key axes?

Here is the head-to-head across the axes that actually change your decision.

The single biggest differentiator here is the temporal model. Mem0’s “latest fact wins” is simple and cheap, but it has no real sense of history - if a user’s job title changes twice, Mem0 just keeps the newest value. Zep and Graphiti keep the whole timeline, so you can ask what was true last quarter. That difference is the whole ballgame for enterprise use cases where data changes constantly. For the broader field, see our ranked frameworks roundup.

What do the pricing and hosting models look like?

Cost and operational burden vary a lot, and this is where teams get surprised.

A few operational truths worth calling out. Mem0 makes an LLM call on every add, which drives cost and latency as you scale. Zep’s ingestion is multi-LLM-call expensive even though reads are fast, and the self-hosted Zep Community Edition server was deprecated in April 2025 - so your real self-host path is Graphiti directly. Cognee carries the heaviest infra, since you run both a graph database and a pipeline. None of these is free in the “no ops” sense.

The benchmark controversy: why you should distrust the numbers

This is the section that matters most, because it is where the marketing falls apart. If you take one thing from this Mem0 vs Zep comparison, take this.

Every vendor cites LOCOMO (LoCoMo), a multi-session dialogue benchmark, as their headline number. Mem0’s paper claimed state-of-the-art LOCOMO results, roughly in the high-60s percent. That sounds authoritative until you read the other side.

Zep published a rebuttal titled “Lies, Damn Lies, and Statistics” that made two arguments. First, that Mem0 misconfigured Zep’s integration - Zep’s real LOCOMO score was around 75% versus the ~66% Mem0 attributed to it. Second, and more damning, that LOCOMO is too easy: its conversations are only about 16k to 26k tokens, so a plain full-context baseline (just stuffing everything into the prompt) can beat the dedicated memory systems entirely. If a naive baseline wins, the benchmark is not measuring what the vendors claim.

On the harder benchmark LongMemEval - which uses longer contexts, temporal questions, and knowledge-update scenarios - third-party comparisons put Zep and Graphiti ahead of Mem0 (around 64% with GPT-4o for Zep versus around 49% for Mem0), a directional ~15-point gap on temporal retrieval. Treat that as directional and third-party, not gospel.

Here is the honest takeaway: treat all vendor memory benchmarks with heavy skepticism. They are self-authored, mutually contested, and often run under conditions that flatter the author. Never present a single LOCOMO number as authoritative. The only benchmark that counts is the one you run on your own data with your own queries.

Is agent memory the same as RAG?

No, and it is worth being precise because the tools above are sometimes confused with retrieval pipelines. RAG fetches relevant documents at query time; agent memory persists and evolves facts about users and events across sessions. The two are complementary, and we break down the distinction in agent memory vs RAG. Mem0 and Zep sit firmly in the memory camp, while Cognee blurs the line by doing graph-native retrieval over ingested documents.

Which AI agent memory tool should you choose?

Here is the decision framework, stripped to the essentials.

Choose Mem0 if you want a cheap, portable, drop-in memory layer for personalization and support bots, and “latest fact wins” is good enough. It is the lowest-friction option and the easiest to rip out later.

Choose Zep or Graphiti if you need temporal reasoning, point-in-time queries, or to fuse chat with changing business data in an enterprise setting. Use Zep Cloud for managed, or self-host Graphiti directly since the Community Edition server is deprecated.

Choose Letta if you are building a long-running autonomous agent that should manage its own evolving memory, and you accept the lock-in that comes with adopting a full agent runtime. Migrating away means a rebuild, so go in with eyes open.

Choose Cognee if you need graph-native reasoning over documents plus conversations and you have the appetite to run the heavier infrastructure.

One practical pattern we see constantly: many teams use their agent framework’s native memory first and add Mem0 for multi-tenant user scoping. You do not have to pick a heavyweight graph on day one. Start simple, measure retrieval quality on your data, and reach for a temporal graph when latest-fact-wins starts costing you accuracy.

Getting the memory architecture right

The four tools here are not competitors so much as answers to different questions. Mem0 answers “how do I add cheap portable memory fast.” Zep answers “how do I reason over facts that change.” Letta answers “how do I let the agent run its own memory.” Cognee answers “how do I reason over a graph of documents and chats.” Get the question right and the tool picks itself.

If you are weighing these options for a production system, we can help you benchmark them on your own data and design the right memory architecture. Take a look at our AI Agent Development work, or if you need to fuse agent memory with changing enterprise data, our Enterprise AI Integration practice. The goal is the same: pick the memory system that fits your use case, not the one with the loudest benchmark.