If you're building an AI agent that has to remember things across sessions, you'll quickly land on the same shortlist: Mem0, Zep, Letta, and — if verifiability matters — Parametric Memory. They solve the same problem in genuinely different ways. Here's an honest comparison, including where each one wins, so you can pick the right tool rather than the loudest one.
The one-line version
- Mem0 — a vector-first memory layer you bolt onto any agent. Fastest path to cross-session personalization; the largest ecosystem.
- Zep — a temporal knowledge graph (Graphiti). Best when facts change over time and you need to know when something was true.
- Letta (formerly MemGPT) — a full agent runtime where the model pages its own memory like an operating system. Best for long-running autonomous agents that self-edit context.
- Parametric Memory — a verifiable memory substrate. Every recalled fact carries a cryptographic proof, and the benchmark result ships as a sealed bundle you can check yourself. MCP-native, from $5/mo.
At a glance
| Mem0 | Zep | Letta | Parametric Memory | |
|---|---|---|---|---|
| Architecture | Vector memory layer | Temporal knowledge graph | Agent runtime (self-paging) | Verifiable substrate (Merkle + Markov + graph) |
| Cryptographic proof of memory | Not documented | Not documented | Not documented | Yes — RFC 6962 Merkle |
| Integration | SDK / API | SDK / API | Runtime | MCP-native (one config block) |
| Hosting | OSS core + cloud | Graphiti OSS + cloud | Fully open-source | Managed; dedicated tier from $29 |
| Paid pricing | Pro (graph) ~$249/mo | Flex ~$125/mo | Free / self-host | $5–$79/mo |
| Standard benchmark | LongMemEval 94.4% (self-report) | LongMemEval 63.8% (GPT-4o) | — | LongMemEval-S 83.0% — official GPT-4o judge, sealed bundle you can verify |
| Best for | Personalization, big ecosystem | Time-changing facts | Autonomous self-editing agents | Verifiable cross-session memory over MCP |
Prices, feature rows, and benchmark figures as reported in each vendor's published documentation / the LongMemEval literature, July 2026. "Not documented" means we could not find the capability in their public docs — check for yourself, and tell us if we have it wrong.
Where each one wins (honestly)
Choose Mem0 if you want the shortest path to "my chatbot remembers the user," a large integration ecosystem, and you're comfortable that recall is probabilistic. Its self-reported LongMemEval scores lead the pack.
Choose Zep if your domain has facts that change over time — account states, prices, statuses — and your agent needs to reason about when something was true. Its Graphiti temporal graph is purpose-built for that and is open-source.
Choose Letta if you're building a long-running autonomous agent that should manage its own memory — deciding what stays in context and what gets paged out — and you want a fully open-source runtime to self-host.
Choose Parametric Memory if you need memory you can trust and prove, with the least integration work:
- Verifiability you can check. Every fact is sealed in an RFC 6962 Merkle tree, so your agent can prove its memory wasn't altered — a hard requirement for regulated, audited, or high-stakes workflows. We are not aware of another commercial memory product that ships verifiable proofs; if you find one, we would like to see it.
- MCP-native, one config block. No SDK, no service to run. It drops into Claude Code, Cursor, Claude Desktop, or any MCP client.
- Graph + prediction included at every price. Knowledge-graph edges and a Markov prediction layer ship on every tier from $5/mo — where comparable graph features sit on $125–$249/mo plans elsewhere.
A note on benchmarks
The category is measured on LongMemEval. We've now published ours — and how we published it matters more than the number.
83.0% on LongMemEval-S, graded by the benchmark's own official GPT-4o judge. And 76.6% out of the box, with zero LLM calls at ingest — no extraction pipeline, no API key, nothing to configure. Turning on typed ingest is what buys the extra 6.4 points, and it costs about a tenth of a cent per conversation session.
Here's the part we care about. Every one of those runs ships as a sealed bundle — the run, the hypotheses, the official judge's transcript, and the code that produced them, under a single Merkle root hash. You can re-verify our numbers yourself rather than take our word for them.
That matters because most numbers in this category can't be checked. Vendors self-report, on different readers, on different releases of the dataset, with no artifacts attached — Mem0's own write-up on the state of memory benchmarks concedes that cross-vendor comparison is "nearly impossible." Our 83.0% is not the highest figure you'll see quoted. It is, as far as we know, the one you can check. Ask any vendor for the same artifact.
We're also publishing where we don't do well: preference-style recall — inferring unstated taste from chit-chat — is our weakest axis at 30%. And we ran a pilot on a web-agent trajectory benchmark, measured that our substrate is the wrong tool for indexing screen contents, and published the negative result rather than chase the number. A benchmark table with no losses in it isn't a benchmark table; it's an advertisement.
Bottom line
There's no single winner — there's a right tool for your constraint. If you want ecosystem, pick Mem0. If you want temporal facts, pick Zep. If you want an autonomous self-hosted runtime, pick Letta. If you want memory you can prove, delivered over MCP without running any infrastructure, that's us — from $5/mo.