Compare · Letta alternatives
Top Letta (MemGPT) Alternatives for AI Agent Memory
The best Letta and MemGPT alternatives for AI agent memory are Engram (Weaviate), Zep, LangMem and Cognee — compared on architecture, memory ops, paging vs vector vs graph trade-offs and fit.
MemGPT tiers
Baseline
What is Letta (and how does it relate to MemGPT)?
Letta is the production platform for stateful LLM agents with virtual context — the commercial stack from the MemGPT research project.
MemGPT is the research paper name — “MemGPT: Towards LLMs as Operating Systems” (Packer et al., 2023, arXiv:2310.08560). Letta is what most developers deploy today. Same lineage: the context window acts like RAM; archival memory acts like disk; the agent pages between tiers via memory tools.
Mechanism
How Letta virtual context memory works
Tiers
Core (hot) vs archival (cold)
Paging
Agent moves segments in/out
Recall
Retrieval pulls archived text
Persist
Archival survives sessions
Agent control
Memory ops as tools
Contrast: Engram = extraction API to Weaviate vector store; Zep = temporal knowledge graph; raw long context = bigger RAM but linear cost and attention dilution. → Memory hierarchy
Debate
Letta vs long context window: do you still need paging?
Million-token windows exist, but cost scales linearly, attention dilution persists and latency rises — paging is virtual memory for unbounded history at sustainable cost.
Gemini models exceed 1M tokens; Claude 3.7 Sonnet supports 200K. Long context is bigger RAM; Letta paging is virtual memory — still needed when conversation history is unbounded and you cannot afford to resend every token each turn. Memory retrieval typically uses 90% fewer tokens than full-context replay.
When to switch
Why look for Letta alternatives?
- Weaviate-native vector + memory → Engram (no paging layer to build)
- Managed personalization API without agent-framework coupling → Engram
- Temporal graph + fact versioning → Zep
- LangGraph-only stack → LangMem
- Document KG ingest → Cognee
- Simple per-user prefs only — not full conversation paging
- Team lacks appetite for OS-style memory abstractions
- Retrieval gap on your evaluation set
Paging is not always required — match architecture to your bottleneck.
Side by side
Letta alternatives compared (2026)
Last updated: July 2026. Architecture, ops and fit at a glance.
| Tool | Architecture | Memory ops | Paging? | Best for |
|---|---|---|---|---|
| Engram (Weaviate) | Vector-native layer | Async extract → transform → commit | No | Weaviate-native stacks |
| Zep | Temporal KG (Graphiti) | Full + temporal invalidation | No | Changing facts, CRM timelines |
| LangMem | LangGraph store | Extract + store + retrieve | No | LangGraph teams |
| Cognee | Evolving KG | Graph write + query | No | Document-heavy KB agents |
Profiles
Alternative tool profiles
Engram (Weaviate)
Strengths: unified Weaviate stack, per-interaction updates, no paging layer to engineer.
Weaknesses vs Letta: no MemGPT-style agent-controlled tier paging, less suited to unbounded raw chat history.
Best for: Weaviate-native apps needing memory without building virtual context.
Zep
Strengths: time-changing facts, relationship queries, conflict resolution.
Weaknesses vs Letta: fact graphs vs conversation paging — different problem.
Best for: evolving entity timelines, not raw chat volume.
LangMem
Strengths: native LangGraph checkpointer, simpler than full Letta for LangChain teams.
Weaknesses vs Letta: no virtual-context OS model, ecosystem lock-in.
Best for: LangGraph persistence without Letta adoption.
Cognee
Strengths: structured knowledge from corpora.
Weaknesses vs Letta: not conversation-paging architecture.
Best for: knowledge-heavy agents.
Disambiguation
Letta vs MemGPT: are they the same?
MemGPT is the idea; Letta is the product most developers use to implement it.
The MemGPT paper introduced virtual context paging for LLMs as operating systems. Letta continues that lineage with agent server, API and tooling for stateful agents in production. When searchers ask for “MemGPT alternatives,” they usually mean Letta alternatives.
Head to head
Letta vs Engram: which is better?
Engram wins for simpler API and faster personalization POC on Weaviate; Letta wins when the agent must page unbounded conversation history.
- Weaviate-native app, per-user facts → Engram
- 100k+ token multi-session chat → Letta (MemGPT paging)
- Agent-controlled memory tiers → Letta
- Framework-agnostic managed memory → Engram
Decision
Letta vs Engram vs Mem0 vs Zep: quick decision
| Scenario | Pick | Why |
|---|---|---|
| Unbounded multi-session chat | Letta | MemGPT paging built-in |
| Weaviate AI-native app | Engram | Unified vector + memory |
| Per-user prefs only | Engram | Simpler than paging |
| CRM facts that change over time | Zep | Temporal graph + invalidation |
| LangGraph agent | LangMem | Native checkpointer |
| Research assistant citing MemGPT | Letta | Paper lineage + tooling |
Stay
When to stick with Letta
- Virtual context / paging is core architecture
- Agent must control its own memory tiers
- Very long conversational history is the bottleneck
- MemGPT research model fits your product
- Building stateful agents, not just memory API calls
Migrate
How to migrate from Letta
- Export archival + core memory segments
- Map tiers → target schema (vectors for Engram/Mem0, graph for Zep)
- Re-summarize or re-embed archival chunks
- Retrieval POC on long-session recall
- Dual-write cutover — note loss of agent-controlled paging unless reimplemented
FAQ
Frequently asked questions
What is the best alternative to Letta?
Depends on need: Engram (Weaviate) for vector-native stacks, Mem0 for managed personalization API, Zep for temporal facts, LangMem for LangGraph. Letta itself is best when agent-controlled paging for unbounded chat is required. See comparison table above.
Is Letta the same as MemGPT?
Same lineage — MemGPT is the research paper (Packer et al., 2023); Letta is the production platform most developers deploy. See virtual context and MemGPT.
Mem0 vs Letta — which should I choose?
Letta when unbounded multi-session conversation via paging is the bottleneck. Engram or Mem0 when you need simpler per-user fact memory without agent-framework coupling. Mem0 LOCOMO J 66.9 (Chhikara et al., 2025). See Mem0 alternatives.
Letta vs Zep — what's the difference?
Letta pages conversation history across memory tiers. Zep stores temporal knowledge-graph facts with validity windows. Different problems — paging vs evolving entity relationships. See Zep alternatives.
Can Engram replace Letta paging?
Partially — Engram handles dynamic per-user memory on Weaviate but lacks MemGPT-style agent-controlled tier paging. Choose Letta when unbounded raw chat history is the core constraint. See Engram explained and long context vs memory.
Letta vs long context window — still need paging?
Often yes for unbounded history at sustainable cost — long context is bigger RAM; Letta paging is virtual memory. Mem0 uses ~1,800 vs ~26,000 tokens per LOCOMO query (Chhikara et al., 2025). See memory vs context window.
What is virtual context memory?
MemGPT's model: context window = RAM, archival store = disk, agent pages segments in and out via tools. Letta implements this in production. See virtual context architecture.
Is Letta open source?
Letta offers open-source core components plus managed/hosted options. Engram, Mem0, Zep and others also offer OSS + managed tiers. See open-source vs managed.
Is Letta good for coding agents?
Letta fits deep multi-session coding conversations via paging. Engram or LangMem may suffice when you need semantic codebase facts without full paging. See coding agents use case.
Is the MemGPT paper still relevant?
Yes — it established virtual context paging for LLMs (Packer et al., 2023, DMR 93.4%). Letta continues the lineage. Zep reports 94.8% on the same DMR task (Rasmussen et al., 2025).
Context memory vs Letta memory?
Context memory often means working memory in the prompt (short-term). Letta spans working (core) + archival (long-term) with agent-controlled paging. See short-term memory.
How do I migrate off Letta?
Export archival + core segments, map tiers to target schema, re-embed, run LOCOMO/LongMemEval POC, dual-write cutover. You lose agent-controlled paging unless reimplemented. See migration section above.