Mem0 and Letta represent two fundamentally different philosophies for agent memory. Mem0 offers a managed memory layer with broad framework integrations and the largest community. Letta (formerly MemGPT) gives the agent itself control over memory ...
Mem0 and Letta represent two fundamentally different philosophies for agent memory. Mem0 offers a managed memory layer with broad framework integrations and the largest community. Letta (formerly MemGPT) gives the agent itself control over memory through self-editing tiers—a research-backed approach from UC Berkeley.
This comparison covers their architectures, benchmark performance, pricing, and ideal use cases to help you decide.
| Factor | Mem0 | Letta |
|---|---|---|
| Architecture | Vector + knowledge graph | Three-tier self-editing memory |
| LongMemEval* | 49% | Not published |
| Deployment | Cloud or self-hosted (Apache 2.0) | Self-hosted (Docker/Python) or Letta Cloud |
| Pricing | Free / $19 / $249 / Enterprise | Open source / Cloud pricing TBD |
| GitHub Stars | 52.8K | 22K |
| Funding | $24M Series A | $10M seed (YC, Jeff Dean invested) |
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:
Letta (formerly MemGPT) pioneered the concept of agents that manage their own memory through function calls. Born from UC Berkeley research, the agent decides what's worth remembering and can edit its own memory across three tiers: Core, Recall, and Archival.
With $10M in seed funding from investors including Jeff Dean, Letta has strong research credibility and 22K GitHub stars.
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.
Letta gives the agent control over memory management through function calls across three tiers:
The agent decides what moves between tiers. This creates autonomous memory management but means the system's behavior depends heavily on the model's judgment about what's worth keeping.
Mem0 manages memory for the agent; Letta lets the agent manage its own memory.
When a conversation contains important information, Mem0's extraction pipeline automatically identifies and stores facts. The developer controls what gets stored through configuration and prompts.
With Letta, the agent itself calls functions like core_memory_append or archival_memory_insert to decide what to remember. This gives the agent more autonomy but makes memory behavior less predictable—different models or prompts can produce very different memory patterns.
This philosophical difference matters most for production systems where you need consistent, auditable memory behavior.
| Benchmark | Mem0 | Letta |
|---|---|---|
| LongMemEval* | 49% | Not published |
Letta does not publish LongMemEval scores. Instead, they maintain their own Letta Leaderboard with different evaluation criteria. This makes direct comparison difficult.
Mem0's 49% on LongMemEval is below average for the current generation of memory solutions. 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 | Details |
|---|---|---|
| Open Source | Free | Self-hosted, full features |
| Letta Cloud | TBD | Managed hosting, pricing not yet public |
Mem0 has clearer pricing tiers. Letta's open-source version is fully featured but requires self-hosting. Letta Cloud pricing hasn't been publicly disclosed, making cost comparison difficult for managed deployments.
For self-hosting: Mem0 is straightforward (Apache 2.0, containerized). Letta requires Docker or Python setup with more moving parts due to the three-tier architecture.
Choose Mem0 if you:
Mem0 has the most integrations but hasn't significantly updated its retrieval engine despite lower benchmark scores.
Choose Letta if you:
Letta's self-editing approach is innovative but the lack of published LongMemEval scores makes it harder to evaluate retrieval quality objectively.
Mem0's ad-hoc extraction guesses what matters. Letta leaves that decision to the agent itself—a creative approach, but one that makes memory behavior unpredictable across models. Hypabase removes the guesswork entirely: AMR-based extraction with a formal grammar guarantees parseable, consistent output every time.
| Factor | Mem0 | Letta | Hypabase |
|---|---|---|---|
| Extraction | LLM-based, ad-hoc | Agent-controlled function calls | AMR (formal linguistic framework) |
| Representation | Triples | Three-tier (Core/Recall/Archival) | N-ary hyperedges |
| LongMemEval* | 49% | Not published | 87.4% |
| Personalization | — | — | 100% |
Hypabase uses Abstract Meaning Representation (AMR)—a formal framework from computational linguistics—to produce structured facts in PENMAN notation with karaka semantic roles (from Panini's Sanskrit grammar):
"The user deployed the app to production on AWS Monday"
Ad-hoc extraction (Mem0):
(user, deployed, app)
(deployment_789, target, production)
(deployment_789, platform, AWS)
(deployment_789, time, Monday)
Agent-controlled (Letta):
core_memory_append("User deployed app to prod on AWS, Monday")
AMR extraction (Hypabase):
(deploy :agent user :object app :locus production :instrument AWS :locus Monday)
The difference: Hypabase encodes who deployed what, where, how, and when in a single parseable hyperedge. Mem0 fragments it into four triples that must be reassembled at query time. Letta stores unstructured text that the model must re-interpret on every read.
| Benefit | How AMR + Hyperedges Deliver It |
|---|---|
| Parseable output | PENMAN notation has defined grammar; malformed extractions caught at parse time—not silently stored |
| Consistent extraction | 6 karaka roles cover all semantic relationships; no ad-hoc relation types that vary by model |
| Precise retrieval | Query :agent user + deploy to find deployments; add :instrument AWS to narrow further |
| No fragmentation | The full deployment fact—agent, object, target, platform, time—stays atomic |
Letta's three-tier model gives agents autonomy, but different models produce different memory patterns from the same conversation. Hypabase's AMR extraction is deterministic at the structural level—the output format is always parseable PENMAN, regardless of which LLM powers the extraction.
They solve different problems. Mem0 (49% LongMemEval) offers broad framework coverage with developer-controlled memory. Letta provides agent-controlled memory without published benchmark scores. For higher accuracy with structured extraction, consider Hypabase (87.4%).
There's no direct migration path—they use fundamentally different memory models. Mem0 stores extracted facts; Letta uses three-tier agent-managed memory. Migration requires re-ingesting conversation history through the new system.
Mem0 extracts and stores facts automatically. Letta lets the agent decide what to remember through function calls. Hypabase uses AMR-based extraction into structured hyperedges for the highest retrieval accuracy.
Mem0 is simpler to self-host (Apache 2.0, containerized). Letta requires Docker or Python setup with its three-tier architecture. 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.
Letta offers an innovative agent-controlled memory model from UC Berkeley research, but without published LongMemEval scores, it's difficult to compare retrieval quality objectively.
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. Letta does not publish LongMemEval scores. Hypabase (87.4%) from published benchmark harness.