A Letta alternative for enterprise agent memory
Letta (formerly MemGPT) is an open-source framework for building stateful agents with self-editing memory.
Key takeaways
- Letta (letta.com) is a stateful-agent framework with self-editing memory; Zep is a dedicated agent-memory layer — the Context Lake.
- Zep is framework-agnostic, stores bi-temporal facts with provenance, and governs memory in the data layer (ABAC, retention, audit; SOC 2 Type II, HIPAA).
- Benchmark-proven: 94.7% LoCoMo and 90.2% LongMemEval (results). S&P Global Market Intelligence named Zep a likely de facto partner in the enterprise agent stack (coverage).
A framework vs. a memory layer
What Letta is. Letta grew out of the MemGPT research and is an open-source platform for building agents that manage their own memory — with memory “blocks” the agent can edit, and a framework for orchestrating stateful agents. Its center of gravity is the agent framework: how the agent reasons and updates its own context.
What Zep is. Zep is a unified context layer, not a framework. It ingests chat, business data, and documents; builds bi-temporal context graphs (via the open-source Graphiti, running on Konig, Zep's proprietary graph database service); and serves relevant, token-efficient context to any agent — built in any framework, or none. Memory is governed in the data layer (ABAC, retention, audit) and served at enterprise scale with sub-200ms p95 retrieval.
- Acme uses Okta as its identity provider.
- Every new tool must use Okta for SSO.
Category
Description
- Every new tool must use Okta for SSO.
- Acme is migrating to Microsoft Entra ID.
- Acme’s SSO must move to Entra ID before renewal.
- Acme renews on Oct 31.
- Acme’s rollout is blocked until SSO moves.
Letta vs. Zep, side by side
| Letta | Zep | |
|---|---|---|
| Primary role | Stateful-agent framework with self-editing memory | Unified context layer for enterprise data (Context Lake) |
| Framework lock-in | You build on Letta's agent model | Works with any framework, or none |
| Memory model | Agent-managed memory blocks | Bi-temporal context graph (facts + provenance + validity) |
| Temporal reasoning | No temporal graph — OS-style memory blocks the agent self-edits | “What's true now / what was true then,” automatic fact invalidation |
| Enterprise governance | Framework-level; not the focus | Data-layer ABAC, retention + legal hold, audit, BYOK/BYOC, SOC 2 Type II, HIPAA |
| Benchmarks | — | 94.7% LoCoMo (155ms), 90.2% LongMemEval (162ms) |
| Open source | Yes | Graphiti (the graph library) is open source |
When to choose Letta, and when to choose Zep
You want an opinionated framework for building agents that manage their own memory, and you're happy to adopt that agent model end-to-end.
- You're choosing an agent framework, not just a memory layer
- Self-editing memory blocks out of the box are the priority
- Research and smaller projects, open-source-first
Memory is the hard part and you don't want it coupled to a single agent framework.
- Temporal, provenance-tracked facts across many sources
- Governance and deployment control for regulated environments
- Proven retrieval performance at enterprise scale
- S&P Global Market Intelligence named Zep a likely de facto partner in the enterprise agent stack
Add governed agent memory in three lines of code
Frequently asked questions
Is Letta a memory layer or a framework?
Primarily a stateful-agent framework with self-editing memory. Zep is a unified context layer that any framework can call.
Can I use Zep with my existing agent framework?
Yes — Zep is framework-agnostic (LangGraph, custom, or none) and adds memory in three lines of code.
Which is better for enterprise?
For governed memory at scale across many agents and data sources, Zep is purpose-built for it; Letta is centered on the agent framework. Evaluate both against your governance and scale requirements.