Open-Source Agent Memory: Mem0 vs Letta vs Zep

Open-source agent memory is the least standardised layer in the whole agent stack, and the three projects that dominate it — Mem0, Letta and Zep — do not even agree on what the layer is for. One treats memory as a background extraction pipeline. One treats it as a set of tiers the agent edits itself. One treats it as a temporal knowledge graph where facts expire rather than disappear. Picking between them is an architecture decision, not a feature comparison.

The comparison content that already exists mostly reprints each vendor’s own benchmark numbers side by side, as though a score produced by Mem0 on LoCoMo and a score produced by Zep on DMR were two entries in the same league table. They are not. Different benchmarks, different harnesses, different judge models, and in at least one case a 45.4-point gap between a vendor’s own figure and the one independent measurement of the same benchmark name.

This guide covers how each system actually stores and retrieves facts, what the published scores do and do not prove, how three incompatible pricing mechanics translate into real spend, what self-hosting each project genuinely involves, and the decision rule for when plain retrieval-augmented generation is still the better answer. Every figure below is attributed to whoever produced it.

Mem0, Letta (formerly MemGPT) and Zep’s Graphiti are the three most-starred, most-referenced standalone open-source agent-memory projects, and all three ship under Apache-2.0. That is where the similarity ends. If you want the underlying taxonomy first — vector stores versus graphs versus episodic recall — start with our agent memory architectures breakdown; this post is the vendor-level decision. For where these projects sit in the wider ecosystem, the open-source agent landscape map covers the neighbouring lanes.

The star ranking is a popularity signal, not a quality one, and it hides the most important structural fact on the chart: the fourth bar is Zep’s old self-contained server, and it is no longer actively developed. Zep narrowed its open-source strategy to the graph engine, which means the “Zep” you can self-host today is Graphiti — a component — while the full product around it stays commercial. That difference does not show up in a star count and it changes the deployment maths considerably.

Mem0’s architecture, described in its ECAI 2025 paper (arXiv:2504.19413) and unchanged in its current documentation, is a two-phase pipeline. The extraction phase runs an LLM over each new message pair, with the conversation summary and recent messages supplied as context, and pulls out candidate facts. The update phase then takes each candidate, retrieves the most similar existing memories by vector similarity, and asks an LLM to choose one of four operations.

That second phase is the interesting one. Most naive memory implementations only ever append; Mem0 explicitly models the case where a new fact should replace or erase an old one. The cost is that every write is an LLM call with a judgement in it, which is both a latency cost and a failure surface — a bad UPDATE silently rewrites something the agent will later rely on.

Mem0 publishes an efficiency claim alongside the accuracy ones: a mean of roughly 6,900 tokens per retrieval call against 25,000 or more for full-context baselines, which it presents as a three- to fourfold token-cost advantage at comparable accuracy. Treat that as a vendor-run measurement — it comes from Mem0’s own research page, on Mem0’s own harness — but the underlying mechanic is sound and easy to reason about: if the retrieval step returns a handful of distilled facts instead of a conversation transcript, the prompt gets smaller.

One commercial detail matters more than it looks. Graph memory, the entity-linking capability that most closely resembles what Zep does structurally, is gated behind Mem0’s top self-serve tier on the hosted service, alongside the “Dream” memory consolidation feature. If graph-shaped memory is why you are evaluating Mem0, that is a tier decision, not a configuration flag.

Letta inverts the responsibility. Instead of a pipeline that observes the conversation and writes memory on the application’s behalf, the agent is given memory it manages through tool calls — which is why vectorize.io’s comparison describes Letta as an agent runtime rather than a memory layer, and why it behaves less like a library you add and more like the frame everything else plugs into. If you are still choosing that frame, our open-source agent frameworks comparison covers the runtimes these memory layers sit inside.

Letta’s distinctive mechanism sits on top of those tiers. Sleep-time compute, introduced in an April 21, 2025 post and the accompanying paper (arXiv:2504.13171), runs a second asynchronous agent that edits the primary agent’s core memory while the primary agent is idle. That second agent abstracts patterns out of stored facts, resolves contradictions between them, and pre-computes associations. Because it is not in the latency path, it can run a larger and slower model than the conversational agent.

The design has an explicit origin story. In MemGPT, Letta’s predecessor design, memory management, conversation and other tasks were bundled into a single agent — which Letta’s own writing says could make that agent slower and less reliable. Splitting memory management out into a separate sleep-time agent was the fix. That is a useful pattern well beyond Letta: the work of maintaining an agent’s state does not have to happen on the user’s turn, and it usually should not.

Zep’s open core, Graphiti, builds a temporal knowledge graph. Every fact carries a validity window — valid_at and invalid_at — so when new information contradicts something already in the graph, the old fact is not removed. It is marked invalid from a point in time forward. The architecture is documented in the Graphiti README and detailed in Zep’s 2025 paper (arXiv:2501.13956).

This is the only one of the three designs where “what did we believe about this customer in March, and when did that change?” is a first-class query rather than an archaeology project. For regulated work, contested records, or anything where an agent’s decision may later need defending, that property is worth more than a benchmark point.

Graphiti’s stated differentiator against static GraphRAG implementations is continuous incremental updates instead of batch reprocessing, plus sub-second query latency against GraphRAG’s seconds to tens of seconds. Both halves of that comparison are Zep’s own framing, published in its own README; no independent GraphRAG-versus-Graphiti benchmark surfaced in research. Read it as a design claim about the architecture, not as a measured result.

This is the part of the comparison that most published content skips entirely. Mem0 publishes Mem0’s scores. Zep publishes Zep’s scores, in Zep’s own paper. Letta designed the leaderboard Letta appears on. None of that is unusual or dishonest — it is how a young category always works — but it means the numbers you find in a comparison table were produced by four different parties running three different benchmarks on their own harnesses, and arranging them in columns implies a comparability that does not exist.

LoCoMo is the closest thing to a shared battleground, largely because Mem0’s original paper ran a head-to-head of ten memory approaches on it — literature baselines, open-source tools, plain RAG, full-context, OpenAI’s memory feature and Zep among them. It is worth knowing what the benchmark actually contains before reading a score off it.

The table below is the comparison we could not find anywhere else: each published score next to who produced it, whether anyone outside the vendor has measured the same thing, and a verdict. It is deliberately unflattering to all three projects, because the honest answer for most rows is “nobody independent has checked this.”

Look closely at the two LoCoMo rows for Mem0 and you have the whole problem in miniature. The agentmemory comparison table reprints 68.5 for Mem0 and 83.2 for Letta, both on LoCoMo. Mem0’s own research page carries 92.5 overall on LoCoMo at the time of writing. Those are not the same measurement disagreeing — they are almost certainly different points in time, an earlier paper or algorithm version against a current one. We are showing both with their sources because the alternative is quietly picking the flattering figure, which is exactly the practice that made the numbers untrustworthy in the first place.

The LongMemEval row is the sharper one, and it is the reason this section exists. Mem0 reports 94.4. Vectorize.io, running its own evaluation and publishing it on March 15, 2026, reported 49.0 for Mem0 on the same benchmark name. We cannot adjudicate that gap from the outside — harness differences, benchmark variant, retrieval configuration and judge model could each account for a large part of it. What we can say is that a 45.4-point spread between a vendor’s figure and the one independent attempt to reproduce it means the vendor figure should not be load-bearing in your decision.

The practical implication is unglamorous: run the eval yourself, on your own conversations, before you commit. Memory quality is unusually sensitive to the shape of your data — how often facts change, how long sessions run, how much of the important context arrives as unstructured chat versus structured events. The same discipline applies to everything else in the agent loop, which is why we treat evaluation as part of the broader context-engineering playbook rather than a procurement step.

All the figures in this section are hosted list prices for each vendor’s managed service, read at the time of writing. The self-hosted Apache-2.0 versions are free of licence cost in all three cases — what you pay for there is infrastructure and engineering time, covered in the next section.

The sticker prices are close enough to look comparable and the units underneath them are not comparable at all. Mem0 sells requests. Letta sells model usage plus compute seconds. Zep sells credits priced by the byte size of what you write. Decoding the unit is the whole exercise.

Now do the arithmetic the pricing pages do not do for you. On Mem0, Starter works out at about $0.00038 per memory add and Pro at about $0.000498 — Pro is roughly 31% more expensive per unit, because it is ten times the volume for a little over thirteen times the price. Pro is not a volume discount. It is a feature gate, and what you are buying is graph memory, Dream consolidation and unlimited projects.

Zep runs the opposite way. Flex prices credits at $0.0025 each ($125 for 50,000), and overage lands at exactly the same rate ($25 per 10,000) — so there is no cliff if you run over, which is unusually merciful. Flex Plus drops to $0.001875 per credit ($375 for 200,000), a genuine 25% volume discount, and annual billing takes a further 16.8% off both tiers. The thing to model is not the credit price but the Episode size: a 1,050-byte message costs three credits, not one, so verbose payloads are quietly triple-billed against a terse equivalent.

Letta is the hardest to forecast because the meter runs on two different things at once. Tool execution at $0.00015 per CPU second means an hour of tool compute is $0.54 — trivial in isolation, but it is the model usage underneath that dominates. Letta’s own documentation is refreshingly blunt about where this lands: casual coding users typically reach around $100 a month or more, and power users running long sessions with many parallel agents often approach or exceed $200 a month. Budget against that guidance rather than the $20 headline.

All three projects are genuinely open source and genuinely self-hostable without a subscription: Mem0’s SDK, Letta’s server and Graphiti all carry Apache-2.0, and the paid tiers above buy each vendor’s hosted service rather than the software. That much is refreshingly clean compared with the source-available licensing you find elsewhere in the open-source agent foundation. The differences show up in what you have to run.

Compliance is where the self-host decision usually gets made for you. Zep gates SOC 2 Type II and a HIPAA BAA above its entry tier. Mem0 puts SSO, on-premise deployment and audit logs on Enterprise. For Letta, the documented route to owning your own compliance boundary is running the server yourself. In every case the open-source path is the one that keeps the data inside your perimeter — and in every case it hands you an operational bill that the pricing page does not show.

That bill is not theoretical. A memory layer is a stateful, latency-sensitive component sitting directly in your agent’s request path, holding data that is by definition about your users. Self-hosting it means owning backup and restore for a store whose contents you cannot regenerate, an upgrade path across a fast-moving project, and — for the graph route — a graph database with its own operational literature. Teams routinely underestimate the third one.

The most useful framing to come out of 2026 industry analysis is that a memory layer and retrieval-augmented generation are complementary rather than competing. RAG remains the right default for static, semantic reference knowledge — documentation, policies, world knowledge. A memory layer earns its token and latency cost specifically where facts mutate: pricing, policy, account status, stated preferences. Similarity-based retrieval has no notion that an old fact has been superseded, so it will happily return the stale version with full confidence.

That single distinction resolves most of the “do we need memory?” arguments we see. If your corpus is a documentation set that changes on a release cadence, you have a retrieval problem and a well-built RAG pipeline will beat a memory layer on cost and predictability. If your agent has to know that a customer changed their delivery address three weeks ago and then changed it back, retrieval alone will get that wrong in a way no amount of embedding quality fixes.

Our reading of where this category is heading: the architectural split will matter less over time than the verification gap does right now. Mem0 already sells a graph tier, Letta already has an archival store, and Zep’s graph has to solve extraction before it can build an edge — the three designs are converging on a similar feature surface from different starting points. What is not converging is the measurement. Until somebody outside the vendors runs all three on one harness and publishes the harness, the only trustworthy benchmark is the one you run on your own conversations.

The second thing worth projecting forward is where the cost lands. Every one of these systems pays for memory in LLM calls on the write path — extraction for Mem0, consolidation for Letta, entity and edge construction for Zep. As agents run longer and hold more state, that write-path spend grows with conversation volume rather than with query volume, which is the opposite of how most teams budget retrieval. Model that curve before you pick a tier, not after. If you want a second pair of eyes on the evaluation, our AI transformation engagements start with exactly this kind of comparative test on your own data.