By default, most AI chatbots and agents forget everything the moment a conversation ends. Ask one a question today and a related question tomorrow, and it has no idea the first conversation ever happened — every session starts from zero. 'Memory' tools exist to fix exactly that: they store what a user has told an agent over time and hand back the relevant pieces the next time it matters, so the agent actually feels like it remembers you.
Mem0 is the most widely adopted tool in this space — 61,000+ GitHub stars, the default memory provider for the AWS Agent SDK, and SOC 2 / HIPAA compliant out of the box. But it's a generalist, and generalist isn't always what you need. If you want deep control over self-hosting, or memory that specifically tracks how facts change over time rather than just storing them, the two real alternatives worth knowing are Zep and Letta — both of which Mem0 itself lists as its closest competitors.
Mem0 — the generalist default
Mem0 combines vector memory, graph memory and episodic memory into one product, which is why it's become the default choice for teams that just want an agent to remember things without picking apart different memory architectures first.
Price: Hobby tier is free for 10K add-requests/month; Starter is $19/month for 50K requests; Pro is $249/month for 500K requests, unlimited projects and graph memory; enterprise (on-prem, SSO, SLA) is custom.
Forces: the default memory provider for the AWS Agent SDK, which is strong third-party validation; by far the most adopted project in the category; combines three memory approaches instead of forcing you to choose one; SOC 2 Type 1 and HIPAA compliant.
Limites: being a generalist means it's less specialized than Zep on temporal reasoning or Letta on full self-hosted control; the Pro tier is worth checking carefully against your real traffic if you lean heavily on graph memory.
Zep — when facts change over time and you need speed
Zep's whole pitch is temporal: instead of just storing facts, it builds a knowledge graph that tracks how those facts evolve — useful for an agent that needs to know not just what's true, but what used to be true and when it changed. It also claims sub-200ms context retrieval at scale.
Price: free tier with 10,000 credits/month and 2 projects; Flex is $104/month (billed annually) for 50,000 credits and 5 projects; Flex Plus is $312/month (annual) for 200,000 credits and 10 projects; enterprise credits and SLAs are custom.
Forces: a temporal knowledge graph is a genuinely different capability, not just a rebrand of vector search; sub-200ms retrieval claims target real production latency needs; SOC 2 Type II and HIPAA BAA certified, aimed at regulated industries.
Limites: more specialized and less adopted (under 5,000 GitHub stars) than generalist options like Mem0; the added complexity can be more than you need for a simple memory use case; the free tier's 10K credits can run out fast in serious testing.
Pick Zep if your agent needs to reason about facts that change over time and you're in a regulated industry that needs the compliance certifications.
Letta — when you want full self-hosted control
Letta takes the opposite approach from both Mem0 and Zep: it's an open-source framework (Apache 2.0, 24k+ GitHub stars) you build on and can fully self-host, rooted in actual academic research (MemGPT, UC Berkeley) rather than being a pure hosted product. Its coding-agent variant, Letta Code, ranked #1 on the independent Terminal-Bench benchmark.
Price: free tier for 3 stateful agents (bring your own API keys); Personal Pro is $20/month for 20 agents with a remote sandbox; Developer API is $20/month plus $0.10 per active agent/month plus LLM usage costs; Teams Pro is $20/seat/month; enterprise is custom.
Forces: real academic roots instead of pure marketing, which shows in the depth of the memory model; fully open source with genuine self-hosting, not just an on-prem SKU; a benchmark-verified #1 ranking for its coding-agent use case.
Limites: 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; per-active-agent pricing needs careful modeling if you're running many agents at scale.
Pick Letta if you want to self-host your agent memory completely, or you're building on the academic MemGPT lineage specifically.
How they compare
| Tool | Best for | Starting price | Self-hosted? |
|---|---|---|---|
| Mem0 | General-purpose memory, fastest to adopt | Free, then $19/mo | Enterprise only |
| Zep | Temporal reasoning, regulated industries | Free, then $104/mo | No |
| Letta | Full self-hosted control, academic lineage | Free, then $20/mo | Yes |
If you just want an agent to stop forgetting your users between sessions, Mem0's free tier is the fastest path to that. Reach for Zep specifically when the 'when did this fact change' question matters to your product, and reach for Letta when self-hosting isn't optional — for compliance reasons, cost at scale, or because you just don't want a third party holding your users' memory.