Anyone typing mem0 vs zep into a search bar is usually trying to solve the same practical problem: an agent needs memory, and two of the best-known tools in that space look similar from the outside but are not built the same way underneath. This piece compares them directly, on architecture, real 2026 pricing pulled from each vendor's own site, and the benchmark claims both have made about the other, without pulling either one into a pitch for a third product.
What Mem0 actually does
Mem0 is an open source, MIT licensed memory layer. Its core extraction pipeline pulls durable facts out of a conversation and stores them as vector embeddings, so a later query can retrieve whatever is semantically closest to what is being asked. On the Pro tier, Mem0 adds an optional graph layer for entity relationships (a customer connects to a plan, a plan connects to a renewal date) sitting alongside the vector store rather than replacing it.
That dual-store design is a genuine strength for the common case: a single user's assistant that needs to remember stated preferences, past requests, and general context without needing to reason about exactly when any of it changed. Extraction is cheap, retrieval is fast, and the mental model, a fact goes in, a similar fact comes back out, is close enough to a standard vector database that most teams can reason about it without reading a research paper first.
What Zep actually does
Zep's memory layer is built on Graphiti, an open source temporal knowledge graph. The distinguishing idea is that a fact is stored with a validity window rather than as a flat, current-only statement. Instead of holding "the account is on the Enterprise plan," Graphiti holds that fact plus the earlier fact it replaced, each timestamped, so an agent can ask what was true on a given date and get a real answer rather than only ever seeing the latest state.
Graphiti has grown into a serious open source project in its own right, independent of Zep's commercial layer around it, which matters if you are weighing how much of this bet depends on one company staying in business.
What happened to Zep's self-hosted option?
This is the part of the comparison that has actually changed underneath people mid-evaluation. Zep retired its self-hosted Community Edition in April 2025, moving that code into a legacy folder with no further updates.
"We're announcing a New Direction for Zep's Open Source Strategy: the end of support for Zep Community Edition and fully focusing our open-source efforts on Graphiti."
Zep AI, Announcing a New Direction for Zep's Open Source Strategy
If your plan was to self-host "Zep" the way you might have done a year earlier, that packaged option is gone. What remains is running Graphiti directly against a graph database such as Neo4j, FalkorDB or Kuzu and building the service layer yourself, a legitimate path for a team with graph database experience but a materially bigger lift than deploying Zep's own server used to be. Anyone specifically searching for a zep alternative on self-hosting grounds should weigh that gap before comparing anything else.
Mem0 pricing vs Zep pricing, side by side
Pulled directly from each vendor's own pricing page in September 2026, not from an aggregator.
| Tier | Mem0 | Zep |
|---|---|---|
| Free | Hobby: 10,000 add requests/mo, 1,000 retrievals/mo, 1 project | Free: 10,000 credits/mo, 2 projects, 1 MCP server seat |
| Entry paid | Starter: $19/mo, 50,000 add requests, 5,000 retrievals | Flex: $125/mo ($104/mo billed annually), 50,000 credits, 5 projects |
| Mid paid | Pro: $249/mo, 500,000 add requests, 50,000 retrievals, unlimited projects, graph memory | Flex Plus: $375/mo, 200,000 credits, 10 projects, webhooks and analytics |
| Enterprise | Custom, on-prem deployment, SSO, audit logs | Custom, SOC 2 Type II, HIPAA BAA, dedicated support |
| Self-hosting | Yes, MIT licensed, documented in the open source repo | No packaged option since April 2025; Graphiti itself is self-hostable |
Table 1: Mem0 and Zep list pricing and self-hosting status, as published on getzep.com/pricing and mem0.ai/pricing, September 2026. Mem0's "add requests" and Zep's "credits" are different billing units, so treat this as a like-for-like comparison of tier structure, not of exact cost per memory.
Two things are easy to miss reading the table quickly. First, Mem0's jump from Starter to Pro is steep, $19 to $249, and that gap is exactly where a Growth-style middle tier has been requested by users in public forums, so check the current page before budgeting rather than trusting a number more than a few weeks old. Second, Zep's Flex and Flex Plus both bill in credits with rollover and auto top-up rules, which behave more like a cloud consumption product than a flat SaaS seat, worth modelling against your actual call volume rather than the sticker price alone.
Benchmark claims worth treating carefully
Both vendors have published numbers that make their own architecture look decisive, and both have been publicly corrected. Zep's own paper reports outperforming a prior system on the Deep Memory Retrieval benchmark and claims up to an 18.5% accuracy improvement on LongMemEval with a 90% latency reduction over a baseline.
"We introduce Zep, a novel memory layer service for AI agents that outperforms the current state-of-the-art system, MemGPT, in the Deep Memory Retrieval (DMR) benchmark."
Rasmussen, Paliychuk, Beauvais, Ryan and Chalef, Zep: A Temporal Knowledge Graph Architecture for Agent Memory (arXiv 2501.13956)
That paper is Zep's own benchmark, run on Zep's own architecture, which is worth remembering before treating it as neutral. The messier, more instructive part of this story is what happened next: Zep originally reported an 84% score on the LOCOMO benchmark, Mem0 published a recalculation putting the real figure at 58.44%, and Zep counter-published a revised 75.14%. Nobody involved in that exchange has an incentive to under-report their own numbers, and the three-way dispute is the clearest evidence available that neither vendor's self-reported benchmark should be the deciding factor in a mem0 vs zep pricing comparison or an architecture comparison. Run both against a sample of your own real queries before trusting either headline number.
Which is better, Mem0 or Zep, for production agents?
When we mapped out both extraction pipelines side by side, the real difference did not show up in what each tool stores. It showed up in when the stored answer is allowed to change underneath the person asking, without any new input from them.
Mem0's vector store answers "what does this look most similar to" at the moment of the query, and that moment is always now. It has no native mechanism for saying a fact used to be true and stopped being true on a specific date, because nothing in a flat embedding carries a validity window. Zep's temporal graph was built around exactly that gap: every edge in Graphiti carries the window during which it held, so a query about last quarter and a query about right now can return genuinely different, individually correct answers from the same underlying store.
That single design choice explains most of the rest of the comparison. It explains why Zep's ingestion and query paths are heavier (a graph write has to reconcile with prior edges; a vector write does not), why Zep's pricing bundles compute-like credits rather than flat request counts, and why a team choosing Mem0 for its simplicity is making a reasonable trade only if their product genuinely never needs to ask "what did we believe back then."
Common pitfalls when comparing agent memory tools
- Comparing "add requests" to "credits" as if they were the same unit. They are not, and a cost comparison that ignores this will be wrong in either direction depending on your actual call pattern.
- Assuming self-hosted Zep still means what it meant in 2024. Since April 2025 it means running Graphiti yourself, not deploying a packaged Zep server, and that changes the engineering commitment materially.
- Trusting either vendor's headline benchmark number without the correction history. The LOCOMO dispute between Zep and Mem0 is public and instructive precisely because it shows both sides revising their own claims.
- Picking based on category label rather than the actual query shape your agent needs to answer. "Agent memory layer" describes both tools and several others that work nothing alike underneath.
Where a third option fits, briefly
Both tools above are built around a single agent's or user's memory. Contextely sits in a different part of the same broader agent memory layer: it condenses what is true in a company's shared systems of record for many different askers at once, with entitlement checked at retrieval rather than a memory space assigned per user. Its default ranking is lexical term overlap, the same kind of scoring either Mem0 or Zep could fall back to without an embedding model configured, and semantic ranking is an optional, operator-configured layer on top rather than something that runs by default. It is a genuinely different problem from either Mem0's conversational recall or Zep's temporal reasoning, not a straight substitute for either, and it is worth reading the direct Mem0 comparison and Zep comparison pages if that shared-company-knowledge angle is closer to your actual requirement.
The honest bottom line
Mem0 and Zep are not competing for the same query. Mem0 is the cheaper, faster, simpler build for an assistant that needs to remember what a person said and prefers. Zep is the more capable, heavier build for an assistant that needs to reason about how a fact changed over time, and it now comes with a real cost to self-hosting that did not exist eighteen months ago. Check current numbers on Mem0's own pricing page and Zep's own pricing page before committing, since both have changed their tier structure within the past year and are likely to again. For a deeper look at either tool on its own, our Mem0 vs Contextely comparison and Zep vs the field comparison cover the same ground from a different angle, and migrating off Zep's Community Edition walks through the practical side of the self-hosting change for anyone caught mid-migration. If a shared, access-controlled company memory turns out to be the actual problem, pricing shows what testing that pattern costs to start.