You already know your agent needs to remember. The list of tools everyone hands you — Mem0, Zep, Letta — gets compared on recall benchmarks, and that's the wrong axis, because these systems don't disagree about how to remember. They disagree about which property is worth optimizing. And in 2026, with a new entrant, the property that's suddenly on the table is one no recall benchmark measures: can you prove what the agent knew?
Here's the fast answer, then the reasoning.
- Mem0 — bets on reach. Easiest to adopt, biggest community, managed cloud if you want it. Reach for it when your worst future question is "does my agent remember at all."
- Zep / Graphiti — bets on time. A bi-temporal knowledge graph that reasons about how a fact changed. Reach for it when your worst question is "what was true in March versus now."
- Statewave — bets on proof. Deterministic, signed, replayable memory bundles and hard per-subject deletion. Reach for it when your worst question is "prove what the agent knew, then erase it."
The line that actually divides them: when retrieval happens#
Mem0 and Zep both retrieve at query time. Your agent asks a question, the store searches now, and returns whatever ranks highest against the current state. Add one memory and ask again, and the answer can move. For a helpful assistant, that's a feature — it always uses the freshest knowledge.
Statewave retrieves at compile time. It ingests raw events, compiles them into typed memories once per subject change, and then assembles a token-bounded bundle that is byte-for-byte reproducible: same subject, same point in time, same output. Every bundle ships a state-assembly receipt — HMAC-signed, listing exactly which memories were used — that you can replay and audit later.
That single design choice is the whole decision. Live retrieval optimizes for the best answer now. Compiled retrieval optimizes for the same answer twice — which is precisely what an audit, a rollback, a dispute, and a deletion order all require.
Nobody picks a memory layer for the demo. They regret one during the incident review, six months later, when someone asks "what did it know?" and the honest answer is "it depends when you ask it again."
Mem0: the default, and why it's the default#
Mem0 is the one you reach for when you just need your agent to stop being amnesiac. Two calls — add() to store, search() to recall — a dual store (vector search plus a knowledge graph for entities), Python and TypeScript SDKs, Apache-2.0 core you self-host with Docker, and a managed platform (free tier through paid) when you don't want to run storage. Sixty-thousand-plus stars means the integrations, the Stack Overflow answers, and the "someone hit this before you" all exist. If nothing in your problem statement contains the word audit, deletion, or dispute, Mem0 is the correct boring choice and you can start in an afternoon.
What it doesn't give you: a first-class answer to "what exactly did the agent see on this call, and can you sign that claim." You'd build that yourself.
Zep / Graphiti: when change over time is the signal#
Zep's open-source engine, Graphiti, makes the most structured bet. Memory is a graph of entities and relationships with bi-temporal tracking: every fact carries a validity window, so when a customer moves from Berlin to Munich, the old fact isn't deleted — it's marked no-longer-valid alongside the new one. The graph answers "true now" and "true then" from one store. That's the right tool when the trajectory of a fact is your actual problem: churn signals, evolving preferences, a case file that accretes.
Two things to plan for. You're now operating a graph database (Neo4j, FalkorDB, or Kuzu) and thinking in nodes and edges — real architecture, not a bolt-on. And the self-hosting story is narrower than it looks: Zep the product is a managed cloud; what you self-host is the Graphiti engine underneath it, not the full application. If "runs entirely on our infrastructure" is a hard requirement, price that in.
Statewave: when you have to prove it#
Statewave is the newcomer, and it's the only one of the three that treats proof as the product. Deterministic bundles, signed receipts, and — the primitive founders under a deletion law keep discovering they need — DELETE /v1/subjects/{id}, a permanent per-subject erase rather than a soft flag. Governance lives in the layer: YAML policies that deny or redact tags like pii and secret, and heuristic auto-labeling to catch a leak at compile time. It's self-host-only on Postgres 14+ with pgvector, CPU-only to start, with an MCP connector so Claude or Cursor can use it as a memory tool directly.
The catch is maturity, and it's a real one. Roughly 300 stars against tens of thousands, v1.x, a small connector ecosystem, and you'll be filing early bug reports. Its architecture is ahead of the incumbents on the axis it cares about; it is not yet ahead of them on having been run in anger by a thousand teams. Those are different kinds of confidence, and only pick this if the property it's ahead on is the one you actually need.
So which one#
Don't rank them. Match each to the worst question your product will have to answer:
- "Can it remember at all?" → Mem0. Biggest community, least friction, managed escape hatch. The safe default.
- "What was true then versus now?" → Zep / Graphiti. A temporal graph earns its complexity only when change itself is the thing you reason about.
- "Can you prove what it knew — and erase it on demand?" → Statewave. The only one built for that question, at the cost of being the youngest tool in the room.
The tell is this: **the more of the proving a layer does for you, the newer and smaller it currently is.** Mem0 and Zep are mature because they optimized the properties everyone needed first — recall and reach. Statewave is small because it's optimizing the property teams are only now discovering they need, as agents move from demos into places where "trust me" is not an acceptable answer. Bet on the property, not the star count — but keep a mature fallback wired up while the new bet grows up.
