If you are choosing a memory layer for a production agent, get the category right first: these three systems are not like-for-like peers. AgentMemory is a local memory server for coding agents. Mem0 is a managed memory platform plus an OSS library you run yourself. Zep is an enterprise context layer built on the open-source Graphiti framework. The Graphiti repo states the distinction bluntly: “Neither is an agent memory product: Graphiti is a framework for building graphs, and Zep unifies, governs, and serves an enterprise’s context.” (Graphiti repository)
So this is a category comparison, not a head-to-head.
Mem0: An Extraction-and-Retrieval Memory Pipeline
The write path
Mem0 “turns messages into stored facts with metadata, embeddings, and optional entity relationships.” The documented write path has four named steps (Mem0: How it works):
- Context lookup — Mem0 checks related existing memories so it can avoid storing the same fact again.
- Fact extraction — an LLM extracts preferences, decisions, plans, and other details your agent can reuse.
- Deduplication and embedding — redundant facts are removed, then each memory is embedded for semantic search.
- Entity extraction — people, places, organizations, and concepts are pulled out and stored for entity matching at search time; on Platform these entities also become the nodes of Graph Memory.
The storage split
Three stores (Mem0: How it works): a SQL database holding facts and metadata as the source of truth; a vector database holding embeddings for semantic similarity search; and an entity store holding entities extracted from memory text, which boosts memories sharing entities with the query — and on Platform also backs Graph Memory.
Memories, not transcripts
“By default, Mem0 stores extracted memories, not a verbatim transcript.” The docs’ own example: "I prefer aisle seats" becomes User prefers aisle seats. When you need raw content exactly as provided, use infer=False. You are persisting conclusions, not conversation logs — which matters for privacy review and token budget.
Retrieval signals and the fusion caveat
Four signals are documented (Mem0: How it works):
| Signal | What it does |
|---|---|
| Semantic | Vector similarity over embeddings |
| Keyword | Term matching for exact words and phrases |
| Entity | Boosts memories linked to entities in the query |
| Temporal | Scores candidates on time metadata extracted at write time against the query’s temporal intent |
The caveat is explicit: “Platform retrieval fuses these signals in the managed service, where the entity signal is powered by built-in Graph Memory. OSS retrieval depends on your configured vector store and optional reranker, and boosts on entity overlap alone: it has no graph memory.” The OSS library and the Platform are not feature-equivalent.
Two operational notes from the same page. The scoping rule: “Always scope searches with filters such as user_id, agent_id, or run_id. This keeps memories from different users, agents, or sessions from mixing.” Second, the additive caveat: “The automatic extraction path is additive. If a user says, ‘I moved from Austin to Seattle,’ Mem0 can store the new fact without silently rewriting the old one. Use explicit update or delete operations when your application needs to correct or remove a memory.”
On Platform the feature list adds webhooks, multimodal support, custom categories, audit logs, and workspace governance (Mem0 Platform overview); self-hosting is acknowledged, pointing to the Platform vs OSS guide (not reviewed here).
AgentMemory: A Local Memory Server for Coding Agents
AgentMemory’s scope is narrower and that is the point. It is built for the coding-agent loop: capture what happened during a session, keep what matters, hand it back next time.
Four memory types
Four documented types (AgentMemory docs):
| You want to keep | Use | Example |
|---|---|---|
| A decision or fact | Memories | Why the payments API requires idempotency keys |
| A rule learned from a mistake | Lessons | Run the migration check before changing the schema |
| What happened during a session | Observations | The tool call and result that explained a failing test |
| A compact record of finished work | Crystals | A session digest retained after raw events are pruned |
Crystals are how a session stays useful after its raw events are pruned.
Runtime and integration surface
Runtime requirements are concrete: Node.js 20+, started with npx -y @agentmemory/agentmemory, with “the REST API… on port 3111 and the viewer… on port 3113”, a Docker image (ghumarerohit/agentmemory:0.9.33), and a team option — “Share one server with a team — Point every agent at one HTTPS server with a shared secret.” Capture happens through “Plugins, hooks, and MCP for 20 coding agents and any MCP client” — Claude Code, Cursor, Codex and Gemini CLI among them. (AgentMemory docs)
The zero-provider baseline
The clearest differentiator here: “Saving, session capture, and keyword recall work without an LLM or embedding provider. Add embeddings for semantic search. Add an LLM provider for summaries and consolidation. Data stays on your machine by default, and no external database is needed. Data leaves the machine only when you turn on a remote model provider or sharing.” (AgentMemory docs)
Zep and Graphiti: Temporal Context Graphs
The data model
Graphiti’s model has three columns (Graphiti repository): facts/relationships as edges — triplets (Entity → Relationship → Entity) with temporal validity windows; episodes as provenance — the raw data as ingested, the ground truth stream every derived fact traces back to; and custom types — developer-defined entity and edge types via Pydantic models.
The repo’s definition of a context graph: “A context graph is a temporal graph of entities, relationships, and facts — like ‘Kendra loves Adidas shoes (as of March 2026).’ Unlike traditional knowledge graphs, each fact in a context graph has a validity window: when it became true, and when (if ever) it was superseded.”
Temporal semantics and retrieval
Zep’s architecture diverges most sharply here: “Facts have validity windows. When information changes, old facts are invalidated — not deleted. Query what’s true now, or what was true at any point in time.” Provenance is structural — “Every entity and relationship traces back to the episodes (raw data) that produced it.” Ontology can be prescribed via Pydantic models or learned from data. Construction is incremental: “New data integrates immediately without batch recomputation.” Retrieval is hybrid: “semantic embeddings, keyword (BM25), and graph traversal for low-latency, high-precision queries without reliance on LLM summarization.” (Graphiti repository)
Zep vs Graphiti, and the prerequisites
The repo is explicit that these are two different things. Zep is “the unified context layer for enterprises,” running Konig, “built for millions of context graphs with low-latency retrieval; no third-party graph database required.” Graphiti is “an open-source framework for building temporal context graphs” where you bring your own database (Neo4j 5.26 / FalkorDB 1.1.2 / Amazon Neptune + Amazon OpenSearch Serverless for full-text search). Graphiti “defaults to OpenAI for LLM inference and embedding” and “works best with LLM services that support Structured Output (such as OpenAI, Anthropic, and Gemini). Using other services may result in incorrect output schemas and ingestion failures.” (Graphiti repository)
Zep the product
Zep’s homepage surfaces Context Lake (“unifies business data into governed context graphs for agents”) and a governance layer: attribute-based access control, retention policies (“Data expires on the schedule you set. Legal hold blocks deletion when compliance requires it.”), and audit/API logs. Agents connect “through MCP or the Zep SDKs, each with its own access controls,” with LangGraph, Google ADK, Microsoft Agent Framework, and Mastra named. (Zep)
How Each One Handles Time and Contradiction
- Mem0 is additive by default: new facts arrive, old ones are not silently rewritten, and correcting one is an explicit
updateordeletecall. Time enters retrieval as write-time metadata scored against the query’s temporal intent. (Mem0: How it works) - AgentMemory handles time by pruning: raw session events can be discarded while Crystals — “a session digest retained after raw events are pruned” — survive. (AgentMemory docs)
- Zep/Graphiti invalidates rather than deletes: “When information changes, old facts are invalidated — not deleted,” with automatic bi-temporal invalidation and temporal history preserved. (Graphiti repository)
For “what did we believe when the decision was made,” only the third is designed for that question in its documentation.
What the Papers Claim (and What They Don’t Compare)
Both papers are author-reported, benchmark-relative results from vendor-affiliated teams — not production SLAs.
Zep’s abstract reports Deep Memory Retrieval (DMR) results of 94.8% vs 93.4% — and names the comparator: “outperforms the current state-of-the-art system, MemGPT.” That is MemGPT, not Mem0. On LongMemEval it claims “accuracy improvements of up to 18.5% while simultaneously reducing response latency by 90% compared to baseline implementations.” (arXiv:2501.13956)
Mem0’s abstract reports on the LOCOMO benchmark: “26% relative improvements in the LLM-as-a-Judge metric over OpenAI, while Mem0 with graph memory achieves around 2% higher overall score than the base configuration,” plus “a 91% lower p95 latency and saves more than 90% token cost” versus the full-context method. (arXiv:2504.19413)
there is no shared benchmark across these two abstracts. Zep reports DMR and LongMemEval; Mem0 reports LOCOMO. Neither fetched abstract mentions the other product. No head-to-head number between Mem0 and Zep exists in these sources, and none of these figures is an uptime or latency guarantee.
Production Checklist: Deployment, Governance, Integration
Deployment. Mem0 offers the managed Platform (“no vector store, reranker, or infrastructure to run”) or self-hosted OSS (Mem0 Platform overview). AgentMemory runs locally, in Docker, or as an optional team HTTPS server with a shared secret (AgentMemory docs). Zep offers Managed/Cloud (“No infrastructure to run”), BYOK (“You control the keys that encrypt data at rest”), and BYOC — “Deploy Zep inside your VPC. Your network, your perimeter, your compliance boundary” — with Graphiti as the fully self-run alternative (Zep).
Pricing: Only What’s Published
Mem0 publishes two plans (Mem0 pricing). Free lists: unlimited end users; “First 30 days: 10,000 adds and 1,000 retrievals a month, model calls on us”; “With your own LLM key: 50,000 adds and 10,000 retrievals a month”; “Usage-based billing past your limits, with a monthly cap you set”; community support. Custom shows “Custom” with limits “set to your volume” and names graph memory (entity linking), user profiles, Dream (memory consolidation), advanced analytics, private Slack support, SSO/audit logs/SLA, on-prem deployment and custom integrations. No numeric price appears on that page, so none is filled in here.
Zep links to an enterprise plans page that was not part of this review, so tiers and amounts are not stated in sources: getzep.com/pricing.
AgentMemory publishes no pricing page, plan names, or prices in the docs reviewed. Not stated in sources.
Side by Side: The Documentation View
| Dimension | Mem0 | AgentMemory | Zep |
|---|---|---|---|
| What it is | Memory layer between app and model; managed Platform + OSS library | “Local memory server for coding agents” | Enterprise context layer; Graphiti is an open-source temporal context graph framework |
| Deployment | Managed Platform; self-hosted OSS acknowledged | Local; Node.js 20+; REST :3111, viewer :3113; Docker; optional team HTTPS server with shared secret | Managed/Cloud, BYOK, BYOC in your VPC; Graphiti self-run with BYO database |
| Data model | SQL facts + vector embeddings + entity store; extracted memories, not transcripts; infer=False for raw |
Memories, Lessons, Observations, Crystals | Entities, facts (edges) with validity windows, episodes (provenance), Pydantic custom types |
| Temporal handling | Additive writes; explicit update/delete; temporal retrieval signal |
Crystals retained after raw events are pruned | Bi-temporal; facts invalidated, not deleted |
| Retrieval | Platform fuses semantic/keyword/entity/temporal; OSS has no graph memory | Keyword recall with no providers; embeddings optional | Hybrid semantic + BM25 + graph traversal |
| Graph support | Platform-only Graph Memory (entity linking), Custom-plan feature; OSS none | not stated in sources | Core; Konig on Zep; Neo4j/FalkorDB/Neptune on Graphiti |
| Integration | add/search/update/delete; user_id/agent_id/run_id filters |
Plugins, hooks, MCP for 20 coding agents + any MCP client | MCP or Zep SDKs; LangGraph, Google ADK, Microsoft Agent Framework, Mastra |
| LLM/embedding needs | LLM extraction in pipeline; model calls on Mem0 for 30 days, then your key | None for save/capture/keyword recall; embeddings and LLM optional | OpenAI key by default on Graphiti; structured-output providers recommended |
| Governance | Audit logs, workspace governance; SSO/SLA/on-prem on Custom | Local data by default; shared-secret team server | ABAC, retention + legal hold, audit/API logs, SOC 2 Type II, HIPAA BAA |
| Published pricing | Free quotas as quoted; Custom = “Custom” | not stated in sources | not stated in sources |
| Author-reported benchmarks | LOCOMO; +26% LLM-as-a-Judge vs OpenAI; ~+2% with graph; −91% p95; >90% token savings | not stated in sources | DMR 94.8% vs MemGPT 93.4%; LongMemEval up to +18.5%, −90% latency |
FAQ
Is AgentMemory a drop-in alternative to Mem0 or Zep? No. It is a different category — a local memory server for coding agents (AgentMemory docs) — whereas Mem0 is a managed memory layer for apps (Platform overview) and Zep is an enterprise context layer (Zep). Comparing them as substitutes is a category error.
Can I use the two arXiv papers to compare Mem0 and Zep directly? No. There is no shared benchmark: Zep reports DMR and LongMemEval, Mem0 reports LOCOMO, and neither fetched abstract names the other product. Zep’s DMR figure is against MemGPT. Both sets of numbers are author-reported and benchmark-relative. (arXiv:2501.13956, arXiv:2504.19413)
What happens in Mem0 when a fact changes — is the old memory rewritten?
Not automatically. “The automatic extraction path is additive,” so a new location fact is stored without silently rewriting the old one; you call explicit update or delete to correct or remove a memory. Zep’s documented model instead invalidates old facts while preserving temporal history. (Mem0: How it works, Graphiti repository)
Can AgentMemory run with zero LLM/embedding spend? For its baseline, yes: “Saving, session capture, and keyword recall work without an LLM or embedding provider.” Embeddings add semantic search; an LLM provider adds summaries and consolidation; data stays on your machine by default. (AgentMemory docs)
Which compliance features are actually documented? Mem0 names audit logs and workspace governance on Platform, with SSO, audit logs, SLA, and on-prem as Custom-plan items (Mem0 pricing). Zep names SOC 2 Type II, HIPAA BAA, attribute-based access control, retention policies, and legal hold (Zep). AgentMemory documents local-by-default data and a shared-secret team server (AgentMemory docs).
The Memory Question Matrix: Matching Workload to Architecture
| The question your agent must answer | Retention model that answers it | What each system documents | Verified against |
|---|---|---|---|
| “What does this user prefer right now?” | overwrite-or-correct explicitly | Mem0: “The automatic extraction path is additive… Use explicit update or delete operations” | Mem0 How it works |
| “What did we believe at the time the decision was made?” | invalidation with history | Graphiti: “Facts have validity windows. When information changes, old facts are invalidated — not deleted.” | Graphiti repo |
| “What did the last session actually do?” | session capture with pruning | AgentMemory: Memories / Lessons / Observations / Crystals, “a session digest retained after raw events are pruned” | AgentMemory docs |
| “Which coding agent learned this lesson?” | local-only default | AgentMemory: “Data stays on your machine by default, and no external database is needed.” | AgentMemory docs |
This matrix is our synthesis of the four quoted documents — it is an editorial mapping, not a vendor claim. The deciding axis is question shape: current-state, historical-state, or session-local.
The Bottom Line
No winner here — only conditional fits, anchored to what the documentation says.
- If your workload is coding-agent workflows on developer machines, where the loop is capture, prune, recall across sessions, and you want data to stay local by default with no external database, AgentMemory’s documented scope is the closest match. Its four memory types — especially Crystals as a digest that survives pruning — are purpose-built for that loop.
- If you want app-level memory with managed infrastructure and a simple
add/searchloop, Mem0 Platform is the fit described in its own docs; self-host Mem0 OSS if you would rather run the vector store yourself, knowing that OSS retrieval “has no graph memory” and that extraction is additive until you issueupdateordelete. - If you need governed enterprise context over company knowledge with temporal truth — answering what was true when, with provenance and access control — Zep is the documented fit, or Graphiti if you want to build and run the temporal-graph service yourself with a bring-your-own database, LLM, and embedder.
One honest overlap: Zep also lists coding agents among the agents it connects, so the boundary is softer than the categories suggest (Zep). The practical test is the question you keep asking your memory layer — “what does this user know right now,” or “what did we believe at the time?” The first is an extraction-and-retrieval problem; the second is a temporal-context problem. Pick the architecture that answers your actual question, then verify it against your own workload.
How This Guide Was Built
This is a documentation-based review — we did not install, run, or benchmark any of these tools.
It was assembled from eight pages read in full: Mem0’s How it works guide, Mem0’s Platform overview, Mem0’s pricing page, AgentMemory’s docs, Zep’s homepage, the Graphiti repository, and the two arXiv abstracts (2501.13956, 2504.19413).
Three links are pointers only, not reviewed, and no claim rests on them: Zep’s pricing page, Mem0’s Platform vs OSS guide, the S&P Global report page. Zep’s trust center is cited only for the existence of the compliance page.
All quoted text is verbatim. Vendor pages change: treat every figure and plan detail as a snapshot of what was published when this was written, and re-check before a procurement decision. The Mem0 pricing URL was reconstructed from links printed on that page.
← Back to all posts


