Comparison7 min read16/04/2026
Mem0 vs Zep: Benchmarks & Temporal Memory (2026)
Mem0 vs Zep for AI agent memory: LongMemEval 49% vs 71.2%, temporal knowledge graphs, pricing, and self-hosting compared — plus which to choose in 2026.
Mem0 vs Zep for AI agent memory: LongMemEval 49% vs 71.2%, temporal knowledge graphs, pricing, and self-hosting compared — plus which to choose in 2026.
Mem0 and Zep are two of the most established options for adding long-term memory to AI agents. They represent different philosophies: Mem0 offers the broadest framework ecosystem and fastest path to production, while Zep prioritizes temporal reasoning and knowledge graph capabilities.
This comparison covers their architectures, benchmark performance, pricing, and ideal use cases to help you decide.
| Factor | Mem0 | Zep |
|---|---|---|
| Architecture | Vector + knowledge graph | Temporal knowledge graph (Graphiti) |
| LongMemEval* | 49% | 71.2% |
| Deployment | Cloud or self-hosted (Apache 2.0) | Cloud-first; self-host requires Graphiti + graph DB |
| Pricing | Free / $19 / $249 / Enterprise | Free / $25 / $475 / Enterprise |
| GitHub Stars | 52.8K | 4.4K (Zep) + 24.8K (Graphiti) |
| Funding | $24M Series A | Not disclosed |
Mem0 is a memory layer for AI applications that combines vector embeddings with knowledge graph capabilities. It extracts facts from conversations using LLM-based extraction and stores them for semantic retrieval.
With 52.8K GitHub stars and $24M in funding, Mem0 has the largest community in the agent memory space. The open-source version (Apache 2.0) includes graph memory support via pip install mem0ai[graph].
Key strengths:
Zep uses Graphiti, a temporal knowledge graph where time is a first-class dimension. Every fact has valid_from, valid_to, and invalid_at markers, allowing queries like "what was true in January?" or "when did this change?"
Zep positions itself around "context engineering" rather than just memory. Graphiti, the underlying engine, has 24.8K stars and supports multiple graph backends (Neo4j, FalkorDB, Kuzu, Neptune).
Key strengths:
Mem0 uses LLM-based extraction to identify facts from conversations. Facts are embedded in a vector database for semantic retrieval, with optional knowledge graph support for relationship queries.
The graph layer enables queries beyond pure similarity search, connecting entities through their relationships. This is now available in the open-source version, not just paid tiers.
Zep's Graphiti engine stores facts as nodes in a knowledge graph with explicit temporal metadata. Each edge carries validity windows tracking when facts became true and when they were superseded.
This temporal awareness is native to the architecture—not a filter applied after retrieval. The tradeoff is infrastructure complexity: self-hosting requires running Graphiti plus a graph database.
Mem0 treats time as metadata; Zep treats time as structure.
When a user changes jobs, Mem0 stores both the old and new employment facts. A query about "where does the user work?" returns both, and the answering model must resolve the conflict using timestamps.
Zep's temporal edges explicitly mark the old job as superseded. A query returns only the current employer by default, with the option to query historical state if needed.
This architectural difference explains much of the benchmark gap on knowledge-update questions.
| Benchmark | Mem0 | Zep |
|---|---|---|
| LongMemEval* | 49% | 71.2% |
Zep outperforms Mem0 by 22 percentage points on LongMemEval (self-reported). The gap is concentrated in knowledge-update and temporal reasoning questions, where Zep's temporal graph provides advantages.
Both score significantly below Hypabase (87.4%), which uses AMR-based extraction for higher retrieval accuracy.
| Tier | Price | Limits |
|---|---|---|
| Hobby | Free | 10K add / 1K retrieval per month |
| Starter | $19/month | 50K add / 5K retrieval |
| Pro | $249/month | 500K add / 50K retrieval + graph + analytics |
| Enterprise | Custom | Unlimited + SSO + on-prem |
| Tier | Price | Limits |
|---|---|---|
| Free | $0 | 1K episodes/month |
| Flex | $25/month | 20K credits, 600 req/min |
| Flex Plus | $475/month | 300K credits, 1K req/min, webhooks |
| Enterprise | Custom | SOC2, HIPAA, dedicated support |
Mem0 offers more generous free tier limits. Zep's credit-based model provides full features at all tiers, while Mem0 gates some features (advanced analytics) to Pro.
For self-hosting: Mem0 is simpler (Apache 2.0, containerized). Zep's Community Edition is deprecated; self-hosting now means running Graphiti with a graph database yourself.
Choose Mem0 if you:
Mem0 has the most integrations but hasn't significantly updated its retrieval engine despite lower benchmark scores.
Choose Zep if you:
Zep's temporal graph is useful for knowledge updates, though the architecture hasn't evolved much since launch.
Both Mem0 and Zep break sentences into triples—subject-predicate-object fragments that lose context the moment a fact involves more than two entities. When your user says "Alice prefers dark mode and uses Python for data science," triple-based systems scatter that into disconnected pieces. Hypabase keeps it whole.
| Factor | Mem0 | Zep | Hypabase |
|---|---|---|---|
| Extraction | LLM-based, ad-hoc | LLM-based into triples | AMR (formal linguistic framework) |
| Representation | Triples | Temporal triples | N-ary hyperedges |
| LongMemEval* | 49% | 71.2% | 87.4% |
| Personalization | — | — | 100% |
Hypabase uses Abstract Meaning Representation (AMR)—a formal framework from computational linguistics—to extract dense, multi-role facts into PENMAN notation with karaka semantic roles (from Panini's Sanskrit grammar):
"Alice prefers dark mode and uses Python for data science"
Ad-hoc extraction (Mem0, Zep):
(Alice, prefers, dark_mode)
(Alice, uses, Python)
(usage_456, purpose, data_science)
AMR extraction (Hypabase):
(prefer :agent Alice :object dark-mode :attribute ui-preference)
(use :agent Alice :object Python :locus data-science)
The difference: Hypabase captures preferences and their context as atomic hyperedges. Ask "what does Alice use for data science?" and the :locus data-science role returns Python directly—no triple-joining, no missed connections.
| Benefit | How AMR + Hyperedges Deliver It |
|---|---|
| Consistent extraction | 6 karaka roles cover all semantic relationships—no ad-hoc relation types |
| Parseable output | PENMAN notation has defined grammar; malformed extractions caught at parse time |
| Precise retrieval | Query by role: :agent Alice + prefer returns dark mode; :agent Alice + use returns Python for data science |
| No fragmentation | N-ary facts stored atomically—preferences never drift from their context |
Mem0's vector search conflates "Alice prefers" across unrelated facts. Zep's temporal triples track when preferences changed but still fragment what was preferred from why. Hypabase preserves the complete relational structure, which is why it achieves 100% on personalization tasks.
Neither excels at retrieval accuracy. Mem0 (49%) has broad framework coverage. Zep (71.2% self-reported) adds temporal reasoning. For higher accuracy with structured extraction, consider Hypabase (87.4%).
There's no direct migration path—they store different data structures. Migration requires re-ingesting your conversation history through the new system. If you're evaluating both, consider running a small pilot before committing.
Mem0 optimizes for framework ecosystem breadth. Zep optimizes for temporal accuracy and graph-based reasoning. Hypabase optimizes for extraction quality using AMR and structured hyperedge representation.
Mem0 is straightforward to self-host (Apache 2.0, containerized). Zep requires running Graphiti plus a graph database (Neo4j/FalkorDB/Kuzu). Hypabase runs entirely in a single SQLite file with no external database required—the simplest self-hosting option.
Mem0 has the broadest framework ecosystem but scores 49% on LongMemEval—adequate for simple use cases but limited for complex retrieval.
Zep adds temporal reasoning but self-reports 71.2% (independent evaluation shows 63.8%). Useful for knowledge updates, though requires more infrastructure.
Hypabase achieves 87.4% through AMR-based extraction into hyperedges—structured knowledge representation that preserves relationships ad-hoc extraction fragments. 100% on personalization tasks.
All three are straightforward to integrate:
LongMemEval scores: Mem0 (49%) from Vectorize independent evaluation. Zep (71.2%) self-reported; independent evaluation shows 63.8% (arxiv:2512.13564). Hypabase (87.4%) from published benchmark harness.
Related reading: How to read memory benchmark claims
More comparisons: Mem0 vs Letta · Zep vs Letta · All comparisons