Ask any AI agent a question, get an answer, then ask a follow-up an hour later — and by default, most agents have no idea what you talked about before. That's not a model limitation, it's an architecture gap: LLMs don't remember anything unless something outside the model stores it and feeds it back in. Zep and Letta both exist to close that gap, but they approach it from almost opposite directions — one as a hosted API you plug in, the other as an open-source framework you build and often self-host.
If you're choosing between them (or trying to figure out if you need either), here's what actually separates them once you get past the pitch decks.
The short version
Pick Zep if you want a managed, plug-in memory layer that tracks how facts about a user change over time and you're fine paying a subscription for it — especially if you're in a regulated industry (it's SOC 2 Type II and HIPAA BAA certified). Pick Letta if you want full control over where agent memory lives, you're comfortable self-hosting, and you value that it's built on real academic research (MemGPT, UC Berkeley) rather than being a pure commercial product. And if neither specialization matches what you need, Mem0 — the most widely adopted of the three, and the exclusive memory provider for the AWS Agent SDK — is worth a look as the generalist option.
Zep: a hosted, temporal knowledge graph
Zep's core idea is that memory isn't just "store what the user said" — it's tracking how facts change over time. If a user says "I work at Acme Corp" in January and "I just left Acme, I'm at a new company now" in June, Zep's temporal knowledge graph is built to capture that evolution instead of just storing two contradictory facts side by side. It claims sub-200ms context retrieval at scale, which matters if memory lookups sit in the hot path of every agent response.
Who it's for: enterprise teams building agents that need to reason about facts that change over time — customer profiles, ongoing support cases, evolving preferences — particularly in regulated sectors given its SOC 2 Type II and HIPAA BAA certification.
Pricing: Free tier (10,000 credits/month, 2 projects); Flex at $104/month (billed annually, 50,000 credits, 5 projects); Flex Plus at $312/month (annual, 200,000 credits, 10 projects); Enterprise on quote.
Honest limits: it's more specialized and less widely adopted (4,770 GitHub stars) than generalist alternatives like Mem0. The free tier's 10,000 credits burn through fast in any serious testing, and the temporal-graph approach can be more complexity than you need for simple memory needs.
Letta: open-source, self-hostable, built on MemGPT research
Letta takes the opposite approach: instead of a hosted black box, it's an open-source framework (Apache 2.0, 24,000+ GitHub stars) for building agents that keep their own state and memory — and you can self-host the entire thing if you want your data to never leave your infrastructure. It's built on MemGPT, real academic research out of UC Berkeley, not just a marketing narrative. Letta Code, its coding-agent product, has ranked #1 on the independent Terminal-Bench benchmark.
Who it's for: developers who want to build and host persistent-state AI agents themselves, and who value the extra control that comes with owning the infrastructure.
Pricing: Free (3 stateful agents, bring your own API keys); Personal Pro at $20/month (20 agents, remote sandbox); Developer API at $20/month + $0.10 per active agent/month plus LLM usage costs; Teams Pro at $20/seat/month; Enterprise on quote.
Honest limits: it's a framework to build on top of, not a plug-and-play API like Mem0 — expect more setup work in exchange for more control. And the per-active-agent pricing needs careful modeling once you're running dozens or hundreds of agents.
The real trade-off: hosted convenience vs. owned infrastructure
Strip away the feature lists and the decision mostly comes down to this: do you want someone else to run and maintain your agent's memory layer, or do you want to own it? Zep is the "integrate an API, get a temporal memory graph, pay a subscription" path — good if your team doesn't want to operate infrastructure and the temporal-reasoning feature matches your use case. Letta is the "open-source framework, self-host if you want, full control" path — good if data residency, cost-at-scale, or academic-grade architecture matter more to your team than convenience.
Both list each other as direct alternatives (along with Mem0), which tells you the market sees them as solving the same underlying problem from different philosophies rather than as niche products for different tasks.
| Criteria | Zep | Letta |
|---|---|---|
| Model | Hosted API, temporal knowledge graph | Open-source framework, self-hostable |
| Best for | Enterprise agents needing time-aware fact tracking | Developers wanting full control / self-hosting |
| Notable credential | SOC 2 Type II + HIPAA BAA certified | Built on MemGPT (UC Berkeley research), 24k+ GitHub stars |
| Entry pricing | Free (10K credits/mo) then $104/mo | Free (3 agents) then $20/mo |
| Main honest limit | Less adopted than generalist options, free tier tight | More setup work than a plug-and-play API |
Conclusion
There's no universally "better" pick here — Zep and Letta are solving agent memory for different teams with different priorities. If you want a managed service with a genuinely differentiated temporal-graph approach and you're fine paying for it, Zep is the more direct route. If you want to own your infrastructure, value open-source and academic grounding, and don't mind building on a framework rather than calling an API, Letta fits better. Either way, also glance at Mem0 before committing — as the category's most widely adopted option, it's a useful baseline to compare both against.