Why this comparison exists
Every week brings a new "memory for AI agents" project. Some are battle-tested, some are weekend experiments. The Model Context Protocol (MCP) made it easy to plug any of them into Claude, Cursor, Codex or any other MCP-aware client — which is great, but it also made it harder to tell them apart from the outside. They all advertise persistent memory. They are not the same thing.
This is an honest field guide. We will not claim there is one winner. Each tool has a real use case. The point is to help you skip the trial-and-error phase and pick the one that fits the agent you are actually building.
The five we keep seeing in the wild
These are the projects that consistently show up in MCP setups in early 2026:
- mem0 — an opinionated extraction layer that summarises conversations into "facts" and stores them in a vector DB. Easy to drop in. SaaS-first with an open-source core.
- Letta (formerly MemGPT) — a stateful agent framework with hierarchical memory blocks (core, archival, recall). More than a tool: it is an agent runtime. Comes with its own server and UI.
- Zep — a temporal knowledge graph backed by Graphiti. Treats memory as a living timeline of entities and relationships. Strong on "what changed when".
- mcp-memory (Anthropic reference) — the simple knowledge graph server from the official MCP examples. Nodes, edges, observations. Minimal and easy to read end-to-end.
- NEXO Brain — a cognitive architecture with sensory buffer, STM, LTM, decay, trust scores and a sleep cycle. Built around the Atkinson–Shiffrin model and Ebbinghaus forgetting curves.
How they really differ
Forget the marketing copy. The decisions that actually matter when you put one of these in production are storage shape, extraction philosophy, forgetting, and operational footprint.
Storage shape. mem0 and the simpler MCP servers are vector-first: you query by similarity and hope the right facts come back. Letta uses tiered text blocks plus archival vectors. Zep models everything as a temporal graph: entities, relationships, and time edges. NEXO Brain combines a relational store (decisions, learnings, followups, entities) with a semantic index, a knowledge graph and a trust layer on top. Vector search alone is fast to ship but breaks down once memories contradict each other, age, or need provenance.
Extraction philosophy. mem0 is aggressive: it summarises constantly and writes "facts" without much friction. mcp-memory is passive: you have to call create_entities yourself. Letta extracts into named blocks. Zep extracts entities and relationships using LLM passes. NEXO does extraction at session end (post‐mortem), distinguishes by category — learning, decision, preference, entity, followup — and routes each one differently.
Forgetting. This is the line that separates toys from production tools. mem0 does not really forget. mcp-memory does not forget at all. Letta has a notion of summarisation but no real decay. Zep handles staleness through its temporal graph — old facts are superseded, not deleted. NEXO Brain implements Ebbinghaus decay with two half-lives (7 days for STM, 60 for LTM), access reinforcement, and a deep‐sleep cycle that consolidates and prunes overnight. If your agent is going to live for months, you want decay built in — otherwise the noise floor rises until retrieval becomes unusable.
Operational footprint. mem0 and mcp-memory run as a single process. Letta wants its own server, web UI and database; nice if you adopt the whole stack, heavier if you just wanted a memory tool. Zep needs a graph database (Neo4j or Graphiti) running alongside. NEXO Brain ships as a single MCP server with a SQLite database, optional pgvector, and a few background jobs (sleep, decay, watchdog). No external services required to get started.
How to pick
Match the tool to the agent, not the other way around.
- Prototyping a chatbot that just needs to remember a user's name and a few preferences across sessions → mem0 or mcp-memory. Lowest friction, you can ship this afternoon.
- Building a long-running autonomous agent with its own runtime and you are happy to adopt a framework → Letta. You get the agent loop and the memory blocks together.
- Modelling people, companies and how they relate over time (CRM, support, legal) → Zep. Temporal graph is the right shape for your data.
- An AI that lives with you for months, accumulates corrections, learnings, decisions and project state, and has to stay coherent without you babysitting it → NEXO Brain. The decay model and trust layer are the things you will be glad you did not have to write yourself.
One thing none of them solves yet
Across all five, the same gap remains: memory ownership across multiple clients. If you use Claude Code in the morning and Cursor in the afternoon, you want both to see the same memory. mem0, Letta and Zep solve this by hosting memory in a SaaS or self-hosted backend. mcp-memory leaves it to you. NEXO Brain takes a different approach: a single local SQLite brain shared by every MCP-aware client on the same machine, with a sync layer for multi-device. There is no consensus on the right answer yet. Watch this space.
Bottom line
If you are choosing today, the question is not "which one is best" but "which one fails in a way I can live with". mem0 fails by storing too much. mcp-memory fails by storing too little. Letta fails by being a whole framework when you just wanted a tool. Zep fails on simple linear conversations. NEXO Brain fails when you want something you can install in 30 seconds and forget about — it expects you to give it a real role and then it earns its keep over weeks.
Pick the failure mode you can tolerate. Then build.