Comparatif Mémoire pour Agents : Mem0 vs Letta vs Graphiti vs Zep

Why this pack exists

Our earlier agent-memory-layer pack covered the three canonical libraries — Mem0, Zep, Cognee — and four design patterns. Useful, but every week someone on Twitter posts "which memory layer should I use for X" and gets ten contradictory answers. This pack is the honest tradeoff guide. Ten options, opinionated install order, decision matrix at the bottom. Read it once, pick, ship.

The field has fragmented since mid-2025. We now have library-shaped solutions (Mem0, Memori), service-shaped solutions (Zep, Statewave), graph-shaped solutions (Graphiti, Cognee), stateful-runtime solutions (Letta, Engram), and weird outliers (Memvid encodes memory as MP4 frames). They are not interchangeable. Picking the wrong one buries a year of work.

Install order — lightweight to heavy

The order is deliberate: start with Mem0 because the time-to-first-memory is under five minutes. If your agent goes autonomous (multi-step, multi-hour), graduate to Letta — it gives you the explicit two-tier memory split that MemGPT introduced. If your domain is fundamentally relational (who knows whom, what happened when), drop the vector store and start with Graphiti. Zep is the production landing pad for the first two. Cognee is the bet for research-heavy work. Everything below row 5 is a niche pick — read carefully before adopting.

The decision matrix

Ask yourself one question: when this user comes back next month, what does the agent need to remember?

• "Their preferences and last few sessions." → Mem0. Stop reading.
• "A multi-hour autonomous task in progress." → Letta. Working + archival memory is the whole point.
• "Who said what, when, to whom." → Graphiti or Zep (Zep ships Graphiti under the hood). Temporal graphs are not optional here.
• "A 6-month corpus of decisions tied to entities." → Cognee or Zep. Vector-only will miss the joins.
• "Whatever — I'll figure it out as I scale." → Mem0 today, plan a Zep migration when you hit 1k users.
• "I cannot run a server." → Memvid or Mem0 with SQLite backend. Hosted Zep cloud is also fine if budget allows.
• "My agent runs in three languages." → Statewave. The SDK parity is the moat.

The matrix is not exhaustive but it covers ~80% of real shipping agents. If you don't see your case here, it probably belongs in the Awesome Agent Memory list (#10) for evaluation rather than a snap decision.

Where each one breaks

• Mem0 breaks on multi-tenant audit. You can bolt on user namespaces but there's no first-class audit log. Fine until your first SOC2 question.
• Letta breaks on cost. The two-tier memory means every step does a recall round-trip; for high-frequency agents this doubles your token bill compared to stateless prompts. Worth it for autonomy, not for chat.
• Graphiti breaks on schema drift. If your entity types change weekly during product-market fit, you'll be rewriting graph schemas more than shipping features.
• Zep breaks on self-hosting complexity. Postgres + graph layer + workers; not a Docker run. Use the cloud unless you have a platform team.
• Cognee breaks on opinionation. It assumes you want a knowledge graph; if your domain is loose (general chat), you're paying graph cost for vector value.
• Memvid breaks on size. MP4-frame encoding is clever but the index gets unwieldy past a few GB. Edge-scale only.
• Memori / Engram / Statewave all break on community size. Smaller ecosystems mean fewer integrations, fewer Stack Overflow answers, more bugs you fix yourself.

Install via TokRepo

# Whole pack
tokrepo install pack/agent-memory-comparison

# Or the canonical trio
tokrepo install mem0 letta graphiti

The CLI drops Claude Code subagent configs into .claude/agents/, Cursor rules into .cursor/rules/, AGENTS.md entries for Codex CLI. The pip/npm installs are unchanged — TokRepo only wires the AI-tool config so your agent knows the memory layer is available.

What we left out

We did not include conversation-history hacks (LangChain ConversationBufferMemory and friends). Those aren't memory layers — they're prompt-stuffing wrappers. They work until they don't, and the failure mode is silent context-window overflow. If you find yourself reaching for those, install Mem0 instead. Five minutes, same shape, doesn't blow up at scale.

We also skipped vector-database-only setups (Pinecone alone, Weaviate alone). Those are RAG infrastructure, not memory. RAG retrieves from a static corpus; memory writes new facts and accumulates. Don't confuse the two.