Verdict
Mem0 is the pragmatic default for extraction-and-consolidation memory: cheaper entry ($19/month Starter vs Zep's $1,250/year Flex), a genuinely self-hostable Apache-2.0 core, and a simpler mental model. Choose Zep when correctness depends on how facts change over time — its temporal knowledge graph is a real architectural difference, not a feature flag — and you can absorb annual-contract pricing. Treat both vendors' benchmark claims as adversarial marketing: when Zep re-ran Mem0's LOCOMO evaluation the scores moved by double digits in Zep's favor, and when Mem0 scored Zep the same thing happened in reverse. And if your workload is plain semantic recall with metadata filters, skip the layer entirely — pgvector in your existing Postgres does that job without a new vendor.
The two products price and architect differently. Mem0's platform runs Hobby free (10,000 add / 1,000 retrieval requests per month), Starter $19/month, Pro $249/month, with the open-source core free to self-host under Apache 2.0 (mem0.ai/pricing, as captured by usagepricing.com and costbench). Zep sells annual credit-based plans: Flex at $1,250/year with 50,000 credits/month (then $25 per 10,000) and Flex Plus at $3,750/year with 200,000 credits/month, where 1 credit covers one episode up to 350 bytes and retrieval/storage cost zero credits (getzep.com/pricing via costbench.com and theaiagentindex.com) — and Zep's old Community Edition is discontinued, with only the Graphiti graph engine remaining Apache-2.0 open source. On capability, the published record is a genuine dispute: Mem0's arXiv paper (2504.19413) claims 66.9% on LOCOMO vs OpenAI memory's 52.9% (a 26% relative gain) with 91% lower p95 latency than full-context; Zep's arXiv paper (2501.13956) claims 94.8% on DMR vs MemGPT's 93.4%, and secondary roundups of Zep's benchmark claims (theaiagentindex.com, rywalker.com) put Zep at 63.8% vs Mem0's 49.0% on LongMemEval with GPT-4o. Mem0's paper scored Zep at 65.99% on LOCOMO; Zep publicly disputed that configuration in a rebuttal post ('Lies, Damn Lies, & Statistics,' blog.getzep.com) and Zep's own current materials quote 80.32% on LOCOMO for a properly configured run (rywalker.com's research notes on Zep's benchmark claims). A ~14-point swing depending on who runs the harness is the single most important fact in this comparison.
Decision Table
| Criterion | Edge | Explanation |
|---|---|---|
| Entry price and cost model | Mem0 (memory API with extraction + consolidation) Best edge | Mem0 starts free (10,000 memory-add and 1,000 retrieval requests/month on Hobby) and scales through $19/month Starter to $249/month Pro per mem0.ai/pricing captures at usagepricing.com. Zep's cheapest paid plan is Flex at $1,250/year billed annually — roughly $104/month — with 1,000 free credits/month on the free tier (getzep.com/pricing via costbench.com). For a side project or an early-stage product, Mem0's on-ramp is an order of magnitude cheaper; Zep's credit model (no charge for retrieval or storage, pay only for episode ingestion) can, however, become competitive for read-heavy workloads at volume. |
| Temporal reasoning and evolving state | Zep (temporal knowledge graph memory backend) Best edge | Zep's Graphiti engine builds a temporal knowledge graph that preserves when facts became true and when they stopped being true — the architecture described in its arXiv paper (2501.13956) that underpins its 94.8% DMR result vs MemGPT's 93.4%. When your agent must answer 'what plan was the customer on before they downgraded,' a latest-embedding-neighborhood store gives the wrong answer confidently. Mem0 consolidates and updates facts but does not natively model fact validity intervals; architecture comparisons at digitalapplied.com and vectorize.io consistently score Zep ahead where historical ordering matters. |
| Open-source self-hosting | Mem0 (memory API with extraction + consolidation) Best edge | Mem0's core is Apache-2.0 and free to self-host with no platform caps (mem0.ai, github repo) — a real production escape hatch, including community recipes for running it on your own Postgres + pgvector. Zep's own FAQ (help.getzep.com/faq) states Community Edition is deprecated and no longer supported; what remains open source is the Graphiti graph engine (Apache 2.0), not the full Zep memory platform. If self-hosting is a hard requirement — data residency, cost control, vendor risk — Mem0 wins this outright. |
| Benchmark credibility | Tie | Both vendors publish numbers that collapse under the other's re-run. Mem0's LOCOMO evaluation (arXiv 2504.19413) scored Zep at 65.99% — below Mem0's own 66.9%; Zep's rebuttal (blog.getzep.com, 'Lies, Damn Lies, & Statistics') accused Mem0 of misconfiguring its setup, and Zep's own materials now quote 80.32% on LOCOMO for a correct configuration (per rywalker.com's research notes). Meanwhile independent LongMemEval roundups show Zep 63.8% vs Mem0 49.0% with GPT-4o, even as Mem0's research page claims 94%+ on its own newer LongMemEval runs. The honest reading: reruns of the same memory benchmark diverge by roughly 14 absolute points depending on who configures the harness, so neither vendor's leaderboard placement should decide your architecture. Benchmark your own recall task on your own transcripts. |
| Retrieval latency in the request path | Tie | Both are network services in your agent's hot path. Mem0's paper claims 91% lower p95 latency than full-context stuffing (~1.44s vs 17.12s in the summarized configuration, arXiv 2504.19413), and Zep markets low-latency graph retrieval — but neither vendor publishes an official, directly comparable p95 SLA, and once real network hops are counted a hosted memory call typically lands in the hundreds of milliseconds versus tens of milliseconds for memory colocated with the app. If retrieval latency blocks a synchronous reasoning chain, that missing published number is your risk on both sides — measure it from your own region before committing. |
| Simple semantic recall workloads | Tie | If the job is 'embed, nearest-neighbor, filter by user_id' — no extraction, no consolidation, no temporal logic — a third option beats both: pgvector inside the Postgres you already run. The rule build-vs-buy analyses converge on: managed memory layers earn their fee only when you need memory behavior (what to store, how to merge it, how it decays), not memory storage. At Mem0's $19–$249/month or Zep's $1,250/year floor, paying a vendor to do cosine similarity your database already does is pure waste. Our pgvector vs Qdrant comparison on this site covers that layer's own tradeoffs. |
| Enterprise support and production posture | Zep (temporal knowledge graph memory backend) Best edge | Zep's product is unapologetically aimed at funded production deployments: annual contracts, credit-metered ingestion with free reads, and a platform pitch built around session + long-term recall for regulated assistants (getzep.com). Mem0's Pro tier adds private Slack support and analytics at $249/month, but Zep's pricing floor effectively filters for teams that have already committed — which correlates with its more opinionated, batteries-included backend. Teams that want a vendor to own the memory subsystem end-to-end tend to land on Zep. |
Choose Mem0 (memory API with extraction + consolidation) if...
- Teams that want automated fact extraction and consolidation as a drop-in API with a free tier and a $19/month step-up.
- Self-hosters: Apache-2.0 core with no platform caps, deployable on your own Postgres + pgvector stack.
- Personalization workloads — user preferences and profile facts across sessions — where consolidation and dedup matter more than temporal ordering.
- Builders who want to start managed and keep a credible exit to self-hosted infrastructure later.
Choose Zep (temporal knowledge graph memory backend) if...
- Agents where answers depend on fact history and validity intervals — support desks, account state, compliance-sensitive assistants.
- Read-heavy production systems that benefit from Zep's zero-credit retrieval and storage: pay on ingestion, read freely.
- Funded teams that want an opinionated, vendor-owned memory backend with session plus long-term recall rather than assembling primitives.
- Knowledge-graph-curious teams: Graphiti (Apache 2.0) lets you adopt the temporal graph engine even outside Zep's cloud.
Decision Rules
- If you need self-hosting for data residency or cost control, choose Mem0 — its Apache-2.0 core is the only fully open self-host option left now that Zep Community Edition is discontinued (only Graphiti remains open source).
- If your agent's correctness depends on how facts change over time (subscriptions, case states, evolving preferences), choose Zep — the temporal knowledge graph is an architectural capability Mem0 does not replicate.
- If your budget is under ~$100/month, the decision is made for you: Mem0 Starter is $19/month; Zep's cheapest paid plan is $1,250/year billed annually.
- If your workload is read-heavy at scale, price Zep's credit model carefully before dismissing it — retrieval and storage cost zero credits, so ingestion volume, not read volume, drives the bill.
- Ignore both vendors' head-to-head benchmark claims: the same LOCOMO benchmark scores Zep at 65.99% on Mem0's harness and 80.32% in Zep's own materials. Run a 200-conversation recall eval on your own transcripts instead.
- If you only need semantic recall with metadata filters and no extraction/consolidation, use pgvector in your existing Postgres and skip the memory-layer vendor entirely.
Migration Notes
- Whichever you choose, keep raw conversation transcripts in your own store — both products derive memory from episodes, so owning the source data makes switching vendors (or moving to DIY) a re-ingestion job instead of data loss.
- Moving from Mem0 to Zep means re-modeling flat consolidated facts as temporal episodes; budget for the semantic mapping, not just the export.
- Leaving either for DIY pgvector: you inherit extraction, dedup, and decay logic — the parts that were the product. Our ReasoningBank and observational-memory posts cover what that pipeline actually involves before you commit to building it.