Short version: All three still exist, still open a repo, still call themselves agent memory. But the self-host answer split apart. Mem0 and Letta are Apache-2.0 and run entirely on your own infrastructure. Zep no longer does — its Community Edition is deprecated and the getzep/zep repo now carries only examples, so the product is hosted-only. The open engine underneath Zep, Graphiti, is alive and Apache-2.0 — but running Graphiti is running the engine yourself, not running Zep. So the August 2026 decision starts with a question that had one answer in June and has two now: does this have to run on my boxes? If yes, Zep drops out of the shortlist. Then you pick on memory model. The architecture map hasn't changed — the June breakdown of where each one puts memory still holds — but the deployment map has.
The one thing that changed: Zep closed the self-host door#
If you evaluated these three earlier this summer, you filed all of them under "open-source memory frameworks you can host." That's no longer true for Zep.
- Graphiti — the temporal-knowledge-graph engine — is still Apache-2.0 and maintained (~29.6k stars). You can absolutely build on it.
getzep/zep— the repo that used to carry the self-hostable product — now states it holds examples and integrations, not Zep's product. The Community Edition moved to alegacy/path and is deprecated.
The practical translation: Zep the product is a managed service now. The temporal graph is still open; the batteries-included memory API around it is not something you deploy on-prem anymore. That's not a knock — hosted temporal graphs are a real product — but it changes who Zep is for. If a hard self-host requirement is why Zep was on your list, that requirement now points at "Graphiti plus the retrieval, extraction, and API plumbing you write yourself," which is a materially bigger project than adopting a memory layer.
Mem0 and Letta did not change here. Both are Apache-2.0 and both run fully on your own hardware — Mem0 as a library or self-hosted server, Letta as a Postgres-backed agent server you docker compose up.
The architectures, in one screen each#
The deployment story changed; the three bets did not. Fast recap — for the deep version, read the architecture breakdown.
Mem0 — memory bolted beside your agent
Mem0 sits next to your agent. You feed it turns; it runs an extraction pass to decide which facts are worth keeping, stores them, and retrieves the relevant ones with a mix of semantic search, BM25 keyword matching, entity linking, and temporal ranking. You keep your own loop and model calls; Mem0 hands back a list of remembered facts. Apache-2.0, Python and JS/TS SDKs, self-hosted server or managed cloud (Qdrant as the default vector store on the platform), with an optional graph-memory add-on. The bet: minimal surrender. You give up "what should I remember," nothing else.
Zep / Graphiti — memory as a bi-temporal graph
Graphiti models memory as a graph of entities and relationships that evolves. Every fact carries a validity window, so when something changes the old fact is invalidated, not deleted — the graph answers both "what's true now" and "what was true in March" from one store. Retrieval is hybrid: embeddings plus BM25 plus graph traversal, with no LLM summarization on the read path. It runs on Neo4j, FalkorDB, or Amazon Neptune. The bet: change over time is the signal. The cost is running a graph database — and, now, either paying for hosted Zep or wiring the product layer yourself.
Letta — memory as a stateful agent OS
Letta (formerly MemGPT) makes the largest bet: memory isn't a service you call, it's part of a stateful agent runtime. The agent holds an in-context memory block plus external recall and archival memory, and edits its own memory via tool calls — the LLM-as-OS idea from the MemGPT paper, productized. State lives server-side in PostgreSQL and persists across sessions; the Agent Development Environment (ADE) lets you watch the agent reason and rewrite its own memory. The bet: own the agent, not just its memory. Heaviest to adopt, most complete if the agent is the product.
About those benchmark numbers#
You'll see scores thrown around — Mem0 publishes LoCoMo 92.5 and LongMemEval 94.4; Zep's paper reports strong DMR and LongMemEval results with large latency cuts versus stuffing full context. Every one of those is vendor-reported, on the vendor's own harness. There is no neutral party running all three under one protocol, and the vendors publish conflicting head-to-head numbers about each other. Use them to understand what each tool optimizes for — Mem0 for recall-per-token, Zep for temporal reasoning — not to rank them. If you want to actually compare, read an agent-memory benchmark critically and see how LoCoMo and LongMemEval have been fought over before trusting a leaderboard.
The decision, August 2026#
Work it in this order:
- Do you have a hard self-host / data-residency requirement? If yes, your shortlist is Mem0 and Letta. Zep is only in play if you're willing to run its hosted service, or to build on Graphiti and own the plumbing.
- What's the shape of your memory problem?
- "My agent forgets facts and I just want it to stop" → Mem0. Lowest-friction, most-adopted, best recall-per-token, drops in beside what you already have.
- "I need to reason about how facts changed over time" — evolving CRM state, a user's shifting preferences, "what did they believe last quarter" → Zep/Graphiti. Accept the graph DB and, for the managed path, the hosted-only reality.
- "The agent, with persistent identity and self-managed memory, IS the product" → Letta. Most to adopt, most complete when the runtime should own state.
- What meters your bill? Roughly: Mem0 charges by memories stored and retrieval calls, Zep by ingest volume (graph credits), Letta by active stateful agents — and self-hosting Mem0 or Letta moves that cost to your own infra plus your LLM keys. (Check each vendor's current pricing page before you commit; the metering model matters more than any single sticker number.)
The headline for this month is narrow and worth saying plainly: the "just self-host the open one" escape hatch closed for Zep. If that was your plan, it's now a build, not an install — and Mem0 and Letta are the two that still let you keep memory on your own hardware without writing the product layer yourself.
