# Mem0 vs Zep for AI Agent Memory: A 2026 Comparison, With Both Vendors' Claims Checked

Published 18 September 2026 · Every price, tier, licence and benchmark condition below was read from the vendor's own page on 10 September 2026, and the pricing and claim-audit verdicts were re-checked against the same pages on 18 September 2026.

Pick [Mem0](https://mem0.ai/) when your agent needs to know what a person prefers and has done, and pick [Zep](https://www.getzep.com/) when your agent needs to know what is currently true about a thing that keeps changing. That is the whole decision, and it comes from one architectural difference: Mem0 stores a fact as a self-contained sentence in a flat store, Zep stores it as an edge between two entities with a window saying when it was true. Everything else in this comparison follows from that choice, including the parts that surprise people, such as which vendor charges for reads, which one loses detail when a fact changes, and which one can answer "what did we believe in March".

The second thing worth knowing before you read any comparison of these two, including this one, is that the published comparisons are unreliable in a measurable way. We took the eight most-cited comparison pages covering this pair, three of them Mem0's own, pulled out every specific claim each makes about a vendor other than itself, and checked each one against that vendor's current documentation. Of thirty-one claims, fifteen are refuted outright by the other vendor's own pages, six are stale, four cannot be settled because nobody publishes the figure, and six hold up. The single most-repeated error concerns a benchmark number that three separate pages attribute to the wrong thing. That audit is a section of its own further down, and every verdict in it rests on a primary page, in almost every case one published by the vendor the claim is about, read on 10 September 2026 and named in the text.

We build [Maximem Synap](https://www.maximem.ai/synap), a third memory platform, which is a conflict of interest you should hold in mind for the whole page. This is written as a neutral comparison of Mem0 and Zep because that is the question people ask; Synap appears as a third column where it does something the other two do not, and the things it does not have are stated in the same breath. Where Zep beats us, which is compliance, we say so.

[Start free — no credit card](https://synap.maximem.ai/?utm_source=site&utm_medium=compare_hero&utm_campaign=mem0-vs-zep)[Try it live — no signup](https://www.maximem.ai/playground)

01/The short answer

## The short answer, by situation[#](#the-short-answer-by-situation)

| Your situation | What decides it | Pick |
| --- | --- | --- |
| Support or sales agent remembering user preferences and history | Flat facts are the right unit; read cost matters because every turn reads | Mem0, or Zep if the same agent also reasons over account state |
| Agent over facts that change on a date: contracts, tiers, account status, policy windows | Bi-temporal validity, so "what was true in March" is answerable | Zep. Nothing else here models it with named fields |
| Voice agent with a per-turn budget | Published read-path percentiles under the turn budget | Zep publishes 87 ms p50 and 155 ms p95; Mem0's 2026 table publishes 0.88 s p50 and no p95 |
| Multi-tenant B2B SaaS needing a tenant rung above the user | Isolation enforced at write time, not by naming convention | Neither has a tenant object; Zep gets closer with UserGroups and ABAC, Mem0 uses `app_id` |
| Regulated buyer needing a SOC 2 Type II report and a HIPAA BAA on the contract | Attested compliance, retention with legal hold | Zep, on Enterprise. Mem0's badge says SOC 2 Type I today |
| Self-hosting or air-gapped, no exceptions | An open engine with the licence in the repo | Mem0's Apache 2.0 SDK without graph features, or Graphiti plus your own graph database. Zep Cloud itself cannot be self-hosted |
| Smallest possible bill for a first production agent | Which side of the transaction is metered | Zep: retrieval costs zero credits, ingestion is one credit per 350 bytes. Mem0's $19 tier caps retrievals at 5,000 a month |
| Team already on LangChain or LlamaIndex | First-party adapter exists | Mem0. Zep's framework list does not include either |
| Team on Pydantic AI, Strands, NeMo or the Microsoft Agent Framework | First-party adapter exists | Zep. Mem0's list does not include any of them |
| Autonomous or coding agent that should own its memory | Agent-authored memory with version history | Neither. That is [Letta](https://www.letta.com/), which is a runtime rather than a memory layer |

If your answer is "both of those describe us", read the section on running them together before you decide, because the double-write cost is real and there are four parts to it.

02/What each one is

## What each one actually is, in September 2026[#](#what-each-one-actually-is-in-september-2026)

Both products changed enough in 2026 that comparisons written before April are wrong in ways that matter, so start here.

**Mem0** is sold two ways: an Apache 2.0 open-source library with a self-hostable Docker server, and a managed Platform. In April 2026 it shipped a new extraction algorithm and the write path became single-pass and additive. Before that, every incoming fact was compared against the ten most similar stored memories and an LLM chose between adding, updating, deleting or doing nothing. Now `add()` returns ADD only, and the migration guide is explicit about the consequence: when information changes, the new fact is stored alongside the old one, and ranking is expected to surface the newer. Reconciliation moved to a background feature called Dream, which marks older facts superseded and merges duplicates. The Platform is where the product now lives: graph memory, memory decay, temporal reasoning, Dream synthesis, webhooks, custom categories, batch operations, the dashboard and export jobs are all Platform-only, and Mem0's own documentation says the published benchmark scores reflect proprietary optimisations not available in the open-source SDK. Compliance today reads "SOC 2 Type I", "HIPAA Ready" and "GDPR compliant". Pricing is a monthly quota of requests: Hobby free at 10,000 adds and 1,000 retrievals, Starter $19 at 50,000 and 5,000, Pro $249 at 500,000 and 50,000, Enterprise custom.

**Zep** is a hosted temporal knowledge graph service. [Graphiti](https://github.com/getzep/graphiti), the Apache 2.0 engine underneath it, is the open-source piece; Zep Cloud adds multi-scope retrieval, observations, governance, a memory MCP server and, since August 2026, Konig, a proprietary graph database service of its own. Zep Community Edition, the self-hostable server, stopped being maintained in April 2025, and the repository now states that its code has moved to a legacy folder, so self-hosting Zep today means running Graphiti with [Neo4j](https://neo4j.com/), [FalkorDB](https://www.falkordb.com/) or Amazon Neptune yourself, without Zep's higher-level features. A February 2026 deprecation wave retired the V2 SDK entirely, along with fact ratings, the `mode` parameter on `getUserContext` and `min_score` in graph search. Pricing meters ingestion only: one credit per episode up to 350 bytes and one more per additional 350 bytes, with retrieval costing nothing. Free gives 10,000 credits a month, Flex is $125 for 50,000, Flex Plus is $375 for 200,000, and Enterprise carries the SOC 2 Type II report, the HIPAA BAA, bring-your-own-key and bring-your-own-cloud.

**Letta** appears in two of the three questions people ask alongside "Mem0 vs Zep", and it does not belong in the same category. It is an agent runtime, formerly MemGPT, where memory is a property of the agent rather than a service the agent calls. MemGPT is the 2023 Berkeley paper and project that introduced core and archival memory tiers the model edits through tool calls; Letta is the company and product that succeeded it, and in 2026 those tiers became MemFS, a git-versioned repository of Markdown files the agent edits with ordinary file tools. Adopting Letta means adopting an agent loop, and its current Agent SDK is TypeScript only. If you are choosing a memory layer for an agent you already have, Letta is not on the shortlist; if you are choosing how to build the agent, it is a different shortlist.

**Everything else in the field sorts onto the same statement-versus-edge axis**, which is worth knowing so you can tell whether this page is about the right two products. On Mem0's side of the split: [SuperMemory](https://supermemory.ai/), an MIT-licensed hosted API with standing user profiles and the widest file ingestion here, at $19, $100 and $399 with SOC 2 Type II and a HIPAA BAA from the top tier; [Hindsight](https://hindsight.vectorize.io/) from Vectorize, MIT, built around retain, recall and reflect over world facts, experiences and mental models, self-hostable from one Docker command and pay-as-you-go in the cloud; and Synap. On Zep's side: [standalone Graphiti](https://www.maximem.ai/compare/zep-graphiti-alternatives), which is a legitimate alternative to Zep Cloud if you will run Neo4j or FalkorDB yourself and can live without the dashboard, Debug Mode, access control and the Context Block endpoint; and [Cognee](https://www.cognee.ai/), Apache 2.0, which combines relational, vector and graph stores with ontologies, has the deepest permission model in the open-source group with tenants containing users containing roles containing dataset access lists, charges $1.00 per million tokens, and ships the COGX exchange format that imports from Mem0, Zep, Graphiti, LangMem and Letta. Library-shaped options are [LangMem](https://langchain-ai.github.io/langmem/) on the LangGraph store, whose last release was October 2025, and Evermind's EverOS. And if you are already committed to a cloud, all three hyperscalers now sell a managed memory primitive. The short version: SuperMemory and Hindsight compete with Mem0 on price and breadth, Cognee and standalone Graphiti compete with Zep on the graph, and nothing in that list changes the statement-versus-edge decision this page is about.

03/The architectural split

## The architectural difference, and the four things it decides[#](#the-architectural-difference-and-the-four-things-it-decides)

Mem0 stores a **statement**: a natural-language sentence such as "User's dog Biscuit turned 5", written to stand alone, with entity links attached and, since version 3, entity connections inferred from co-occurrence rather than declared. Zep stores an **edge**: a subject, a relationship and an object, with four timestamps and a pointer back to the episode that produced it. Both descriptions come from the vendors' own documentation, and almost every practical difference between the two products is downstream of that one choice.

**It decides what happens when a fact changes.** An edge can be invalidated. Zep sets `invalid_at` (when the fact stopped being true) and `expired_at` (when Zep learned it stopped), keeps the old edge in the graph, and lets you query the state of the world at any past moment. A statement cannot be invalidated in the same way, because there is nothing structural to invalidate; you either overwrite it, delete it, or leave it and hope ranking hides it. Mem0 chose the third, deliberately: additive writes, `expiration_date` to hide a memory after a date without deleting it, a Platform-only decay re-ranker that dampens stale memories without ever filtering them out, and Dream to mark supersession in the background. There is an open issue on Mem0's repository from April 2026 reporting stale employer facts surfacing after the change, which is the predictable failure mode of that trade rather than a bug in the usual sense.

**It decides whether a multi-entity fact survives whole.** "Sarah approved the Q3 budget for the Berlin office on 12 March" has four participants and an edge has two endpoint slots. Graphiti's model is triplets, and nothing in its documentation describes hyperedges, so you either fold the extra participants into the edge's fact sentence and typed attributes, which keeps the sentence but makes Berlin and the date unqueryable as endpoints, or you reify the approval into its own node with four edges hanging off it, which is queryable and is schema design you do rather than something the engine does for you. Mem0 never has the problem, because the sentence is the record. The cost is the mirror image: you cannot ask Mem0 "which approvals did Sarah make for Berlin", because the relationship exists only inside the sentence and the `relations` field is no longer populated.

**It decides what deletion reaches.** Deleting a user's statements is a filtered delete. Deleting a user's edges is harder, and Zep documents the sharp corners in detail: deleting a user removes threads, the user graph and the extracted knowledge, but nodes and edges shared with other episodes persist, the user entity node is never deleted when an episode is deleted, and if an episode invalidated a fact, deleting that episode leaves the fact invalidated. That is not a flaw so much as what a graph is; it is also the thing to test before you promise an erasure SLA.

**It decides what a retrieval costs to assemble.** Zep assembles a Context Block by walking the graph and reranking with a cross-encoder, which is why it can charge nothing for reads: the expensive work happened at ingest, and Zep meters ingest. Mem0 runs a multi-signal search over its stores and meters the request, which is why the $19 tier caps you at 5,000 reads a month. Two different bills for the same conversation, and the difference is not pricing strategy so much as where each architecture put the work.

The reframe that follows is worth stating plainly: "Mem0 or Zep" is a proxy question. The real question is which unit your product needs, and you can answer it without reading a feature table. If someone on your team has ever asked "what did the system believe about this customer last quarter", you need edges. If nobody has, you probably need statements, and statements are cheaper to run and simpler to reason about.

04/Do you need a memory layer

## Before either of them: do you need a memory layer at all?[#](#before-either-of-them-do-you-need-a-memory-layer-at-all)

Three things get called memory and they store different units, so tell them apart by what happens when a fact changes. A **bigger context window** stores nothing: every call replays the history, the cost scales with length on every call forever, and quality falls past a certain size because attention is a budget. **RAG over transcripts** stores passages, which is better and is what most teams end up running; its weakness is the unit, because a passage carries the fact you want plus four you do not, and it carries the March statement and the June correction with no view on which is current. A **memory layer**, which is what both products on this page are, stores derived units and maintains them, which means four operations a vector index does not have: deciding what is worth writing, reconciling a new fact against an old one, retiring a fact, and ranking by more than cosine similarity. The practical test is the failure you are seeing. "It forgot what I told it last week" is a memory-layer problem. "It cannot find the policy document" is a RAG problem. "It loses the thread mid-session" is a buffer or a window problem. And the honest floor is Postgres full-text search plus [pgvector](https://github.com/pgvector/pgvector) plus a summariser, which is defensible for a single-tenant, low-traffic product right up until you need contradiction handling, validity windows, entity resolution across sessions, or a tenant boundary enforced at write time.

Full context is the baseline both vendors measure against, and it wins more often than either page admits. Mem0's own April 2025 paper, on LoCoMo conversations of roughly 26,000 tokens with gpt-4o-mini writing the answers, found that stuffing the whole conversation into the prompt scored **higher** than Mem0: 72.90 percent against 66.88 percent, and 68.44 percent for the graph variant. What Mem0 bought was not accuracy but 1.44 seconds of p95 latency instead of 17.1 and about 7,000 tokens per question instead of 26,000, which is why the paper's headline is a 91 percent latency reduction rather than a better score. Zep's paper found the reverse on longer histories: on LongMemEval-S at roughly 115,000 tokens, full context scored 55.4 percent with gpt-4o-mini against Zep's 63.8, and 60.2 percent with gpt-4o against Zep's 71.2, with latency dropping from about 30 seconds to about 3. The independent 2026 study adds a cost threshold: with prompt caching, a fact-based memory system becomes cheaper than a 100,000-token long-context loop after roughly ten interaction turns. So the rule of thumb is that below about 30,000 tokens of history you are paying a memory layer in accuracy and buying latency and cost, around 100,000 tokens you are buying accuracy as well, and the cost crossover arrives at about ten turns.

05/Head to head

## Head to head[#](#head-to-head)

### Temporal handling[#](#temporal-handling)

|  | Mem0 | Zep |
| --- | --- | --- |
| Model | Timestamps plus a Platform-only temporal reasoning boost at search time | Bi-temporal: `created_at`, `valid_at`, `invalid_at`, `expired_at` on every fact edge |
| On contradiction | New fact stored alongside the old; ranking expected to surface the newer; Dream marks supersession in the background | Old edge invalidated, not deleted; history stays queryable |
| Point-in-time query | Not documented | "Query what is true now, or what was true at any point in time" (Zep docs) |
| Expiry | `expiration_date` hides a memory from search without deleting it | Policy-driven retention with legal hold, on Enterprise |

This is the axis where the two products are least alike and where Zep has no real competition in this pair. If your domain has facts that carry dates (a contract that renews, a tier that changed in March, a policy that applied for one quarter), the four timestamps are the feature you are buying, and Mem0 does not have an equivalent.

### Entities and relationships[#](#entities-and-relationships)

Graphiti runs an LLM deduplication step at ingest whose prompt instructs it never to fabricate entity names or mark distinct entities as duplicates, returning a duplicate candidate identifier or none for each extracted entity, and supports developer-defined entity and edge types through Pydantic models. Mem0's graph memory stores each entity once and embeds it so that differently phrased references can match, with connections inferred from co-occurrence rather than declared, no typed relationships, and no threshold or review control described. Whether Mem0's graph features are available on all plans is a question its own pages disagree about, which we cover in the audit section.

### Retrieval[#](#retrieval)

Mem0 fuses semantic, keyword, entity and temporal signals and reports its benchmark numbers at a top-200 retrieval budget, returning roughly 6,900 tokens per query on its own long-horizon runs. Zep runs multi-scope search across edges, nodes, episodes, summaries and observations, reranks with a cross-encoder, and assembles a Context Block string, reporting 5,760 tokens of context on LoCoMo. Both are token budgets rather than result counts, which is the right design for a prompt.

There is one scale figure worth knowing and only Mem0 publishes it. On BEAM, the benchmark that runs to 10 million tokens, Mem0 reports a mean of 6,719 tokens per query at the 1 million scale and 6,914 at the 10 million scale, so a tenfold increase in store size moves the injected context by about three percent. That is the retrieval budget working as designed. Accuracy is what does not hold, and Mem0 publishes these figures without naming an answer model, a judge or a run date: overall drops from 64.1 to 48.6, and the per-category collapse is sharper, with temporal reasoning falling from 61.8 to 16.3 and multi-session reasoning from 65.2 to 26.1, while preference following actually rises. Zep publishes no BEAM figure and no context-size-versus-store-size figure; what it claims is latency invariance, "sub-200ms context retrieval regardless of graph size or number of graphs", which is a different guarantee and should not be read as the same one.

### Scoping and multi-tenancy[#](#scoping-and-multi-tenancy)

|  | Mem0 | Zep |
| --- | --- | --- |
| Identifiers | `user_id`, `agent_id`, `run_id`, and `app_id` on the Platform | User, thread, user graph, standalone graph |
| Above the user | Organisations and projects, resolved from the API key, for team access rather than data hierarchy | Account and project, plus UserGroups carrying policy grants |
| Access control | Project-level | Attribute-based access control on API keys and UserGroups |
| A tenant object | No; `app_id` is the documented tenant handle | No; UserGroups are a security grouping rather than a data rung |

Neither product gives you a tenant rung above the user that is enforced at write time, which is the gap most multi-tenant SaaS teams hit second, after they have solved recall. Zep gets closer because attribute-based access control can express "this key may not read that group", and standalone graphs give shared business knowledge a first-class home. Mem0 asks you to encode the hierarchy in identifier strings and to trust your own filters, and its documentation is explicit that unmentioned entities are not constrained in a search filter, which is worth reading twice before you ship a multi-tenant product on it.

### Latency[#](#latency)

Zep publishes the tighter figures and publishes them with percentiles: 87 ms p50 and 155 ms p95 retrieval on LoCoMo, 104 ms and 162 ms on LongMemEval, and an end-to-end context block under 200 ms at p95 in its Konig announcement. Mem0's 2026 table reports 0.88 seconds p50 on LoCoMo and 1.09 seconds on LongMemEval at the top-200 budget, with no p95 published and no statement about whether the figure is search only or search plus generation. Those are not comparable measurements, but the order of magnitude is the point: for a voice agent, where [Daily](https://www.daily.co/blog/advice-on-building-voice-ai-in-june-2025/) advises aiming at 800 ms median voice to voice, a 155 ms p95 read fits inside the turn and a second-scale read does not unless it runs off the critical path.

### The write path[#](#the-write-path)

Both write asynchronously and both will make a demo look broken if you write a fact and immediately read it back. Mem0 returns an event identifier with a pending status you poll, and `infer=false` stores a message verbatim without running the extraction model, which is the documented way to make a write synchronous and free of extraction cost. Zep says added data can take a few seconds to a few minutes, exposes a processed flag and webhooks, accepts up to 4,096 characters per message by default and 30 messages per call, and lets you keep whole roles out of the graph with `ignore_roles`, which is the cheapest way to stop storing the assistant's own output.

What the write costs differs in kind. Mem0's original design was one extraction call plus one decision call per candidate fact; the April 2026 algorithm collapsed that to a single pass. Zep meters by episode size rather than by call, and does not publish a call count. That has a consequence worth exploiting: because a Zep credit covers 350 bytes, batching a ten-turn session into one episode costs four credits instead of ten, which is a two and a half times saving on the write side and has no equivalent on Mem0 or on Synap, both of which meter per call.

Which model does the extracting is a choice on one side of each product and not the other. Mem0 Platform and Zep Cloud both run their own extraction models and expose no provider setting, so on the managed products you are buying the vendor's judgement; Zep published its own evaluation of NVIDIA's Nemotron 3 Embed in July 2026, which is the vendor choosing rather than you. Mem0's open-source SDK supports a wide provider list for both the LLM and the embedder, including OpenAI, Anthropic, Gemini, Azure, Bedrock, Groq, Ollama, vLLM, LM Studio, HuggingFace and FastEmbed, although the reference Docker image ships only three of them and you extend it yourself for local models. Graphiti supports OpenAI by default plus Azure, Gemini, Anthropic, Groq, Ollama and any OpenAI-compatible endpoint. Routing extraction to a cheaper model is the obvious cost lever and Graphiti's own documentation carries the warning that matters: avoid smaller local models, because extraction is a structured-output task and a model that fails schema compliance produces silently wrong memories rather than an error. The free version of the same idea is Mem0's `infer=false`, which stores a message verbatim and runs no extraction model at all.

Changing the embedding model later is the expensive version of that choice, and the self-hosted documentation is candid where the managed documentation is silent. Mem0's own example is a default embedder that moved from 768 to 1,024 dimensions, with the instruction to recreate and reindex the collection at the new dimension after upgrading or pin the old model, because `embedding_model_dims` must match the vector store. A dimension change is therefore a collection rebuild and a full re-embed of every stored memory, which you should budget as a planned migration on self-hosted Mem0 and on self-hosted Graphiti alike. On Mem0 Platform and Zep Cloud the embedder is hidden, so the risk sits with the vendor, and neither publishes a policy on re-embedding, migration windows or score drift when they change models. That is a fair question to put in writing before you sign either contract, and Synap's documentation is silent on it too.

### Ingestion breadth[#](#ingestion-breadth)

Mem0's Platform accepts images, PDF, TXT and MDX alongside conversation turns, and multimodal ingestion requires the default inference path. Zep accepts text, JSON and chat messages, with a documents grouping for chunked PDFs, and no image or audio path documented. If your memory has to come from files as well as conversations, that is a real gap rather than a detail.

Keeping the wrong things out of memory is a per-vendor exercise and neither product does it for you. Mem0's own core documentation says it plainly: avoid storing secrets, raw credentials or unredacted sensitive data, because Mem0 is designed to retrieve stored context rather than secure it. Its controls are prompt-level, which means custom instructions at the project level with worked examples such as excluding payment card numbers, passwords and personal identifiers, plus per-call include and exclude hints and custom categories on the Platform. Zep's equivalent is structural rather than prompt-level: `ignore_roles` keeps whole roles out of the graph, which is the cheapest way to stop storing the assistant's own output, and custom entity and edge types constrain what extraction will even look for. Neither offers detection and redaction of sensitive values before storage, so on both products that job belongs in your middleware, ahead of the write. For contrast, this is one place where Synap's documentation goes further than either: a hard floor of field types that are never stored for any account regardless of settings, including full card numbers, security codes, PINs, passwords, API keys, private keys and raw biometric data, with eleven further categories each taking one of six treatments, and published limits on what its detectors do and do not cover.

### Forgetting and consolidation[#](#forgetting-and-consolidation)

Mem0 gives you `expiration_date`, which hides rather than deletes, and an opt-in per-project decay re-ranker that boosts recently reinforced memories and dampens stale ones and never filters candidates out. Since extraction is additive, nothing prunes superseded facts automatically; Dream marks supersession and merges duplicates on a schedule, with synthesis gated to Pro and above. Zep invalidates contradicted facts as part of ingestion, and on Enterprise expires data on a policy you set with legal hold blocking deletion when compliance requires it. Neither product will shrink your store for you without being told to.

### Observability[#](#observability)

Zep's Debug Mode is the deepest tooling in this pair: per-episode workflow logs and, on paid plans, ingestion traces that show why selected LLM stages produced each decision and link a fact back to the episode, the prior episodes, the ontology or the deduplication candidates that informed it, retained 30 days. Debug Mode auto-deactivates after 60 minutes, or 24 hours on Enterprise. Mem0 gives a per-memory history endpoint returning the event type, the old and new text and the triggering messages, a project event feed, and a dashboard on both Platform and the self-hosted stack. Mem0 lets you read what changed; Zep lets you read why.

Editing is the half people assume and neither fully has. On Mem0 a human can read any memory in the dashboard, see how it changed through the history endpoint, edit it with an explicit update call and delete it, but there is no rollback endpoint and attribution is to an identifier rather than to a person. On Zep you can delete edges, nodes and episodes by identifier, and you cannot edit a fact in place or revert an invalidation, and deleting the episode that invalidated a fact leaves the fact invalidated. Letta is the clean case and the reason it keeps coming up: memory is Markdown in a git repository, so inspecting it is `cat`, editing it is an editor, explaining it is `git log` and undoing it is `git revert`. If "who changed this and can I undo it" is a requirement rather than a nice-to-have, neither Mem0 nor Zep answers it today.

### Deletion[#](#deletion)

Mem0 deletes by filter on `user_id`, `agent_id`, `app_id` or `run_id`, queues the work, and states that this satisfies user erasure under GDPR and CCPA; what happens inside the entity store and the history log is not documented. Zep's user delete cascades through threads, thread artifacts and the entire user graph in one call, with the caveats about shared nodes noted above. Verification on both is an audit log plus a re-query; neither issues anything like a deletion certificate.

### Compliance[#](#compliance)

Zep states SOC 2 Type II and HIPAA business associate agreements across its deployment models, attribute-based access control, policy-driven retention with legal hold, and audit logs, with the report, the BAA, bring-your-own-key, bring-your-own-cloud and one-year log retention gated to Enterprise. Mem0's pricing page carries "SOC 2 Type I", "HIPAA Ready" and "GDPR compliant" badges, with on-premise deployment, audit logs and single sign-on on Enterprise. Several widely cited comparison pages say Mem0 holds SOC 2 Type II; Mem0's own page says Type I. If the deal turns on an attestation, Zep wins this axis outright and it is not close.

### What neither of them does[#](#what-neither-of-them-does)

Four gaps are shared, and they matter most to the buyer who is furthest from the code.

**Neither inherits permissions from the source system.** If a Confluence space or a Slack channel is restricted to finance, ingesting it into either store flattens that restriction into whatever scope the write used. There is no rule on either vendor's documentation saying that a user who could not read the source must not receive the derived fact. Zep gets closest with attribute-based access control on API keys and UserGroups, but that is a policy you author rather than an inheritance. This is the single most consequential absence for a regulated enterprise, and it is the ground the self-described context-layer vendors such as [Atlan](https://atlan.com/context-layer/) and [Graphlit](https://www.graphlit.com/) claim. The practical consequence: an agent answering HR or finance questions across an organisation needs either a context layer with inherited access lists, or a design where you only ingest the subset every user of that agent is allowed to see.

**Neither has a governed glossary.** There are no shared, owned, versioned definitions of business terms that extraction must conform to. Zep's custom ontology through Pydantic entity and edge types is the closest thing and it is a schema rather than a glossary.

**Neither traces back to the system of record.** Zep traces a fact to the episode that produced it and Mem0 traces a memory to its input messages, which is provenance within the memory product. Neither traces back to the row in your CRM or the document version in your content system, so "is this still what the source says" cannot be answered inside either product.

**Neither has an approval step before a write lands.** Zep's access control limits what an agent can read; no vendor here documents a workflow where a memory write waits for a human. Every product on this page lets you correct or delete after the fact, and none lets you gate before it.

Retention is the one where they diverge: Zep has policy-driven retention with legal hold on Enterprise, and Mem0 has a per-memory expiry date, which is a developer feature rather than an administrator policy, with no legal hold.

### Self-hosting[#](#self-hosting)

Mem0's open-source SDK is Apache 2.0 with a Docker Compose stack bundling Postgres and pgvector, and you provision the LLM, embedder and vector store; what you do not get is graph memory, decay, temporal reasoning, Dream, webhooks, custom categories, batch operations or the dashboard, and Mem0's documentation says the benchmark scores do not apply to it. Graphiti is Apache 2.0 and needs Neo4j 5.26, FalkorDB or Amazon Neptune, with Kuzu deprecated, so self-hosting the Zep side means operating a graph database as well as the engine. Zep Cloud itself is not self-hostable at any tier below Enterprise BYOC. Both paths are real; both give you a materially different product from the hosted one.

### SDKs, frameworks and MCP[#](#sdks-frameworks-and-mcp)

Mem0 has Python and TypeScript SDKs plus REST, and a hosted MCP server at `mcp.mem0.ai/mcp` with eleven tools, reached with a browser sign-in or an API key, listed for Claude, Claude Code, Codex, Cursor, Windsurf, VS Code and OpenCode. Zep has Python, TypeScript and Go plus REST, and its Memory MCP Server is a per-seat product with twelve tools, one seat on Free, five on Flex, fifteen on Flex Plus, and custom identity provider integration on Enterprise.

The framework lists are the place where "which one integrates with my stack" has a real answer, so here are both as published today. Mem0 names twenty-two: AgentOps, Camel AI, LangChain, LlamaIndex, AutoGen, CrewAI, LangGraph, Vercel AI SDK, LangChain Tools, Dify, LiveKit, ElevenLabs, Pipecat, Agno, Respan, Raycast, Mastra, OpenAI Agents SDK, Google ADK, Flowise, AWS Bedrock and ChatDev. Zep names fourteen: AG2, AutoGen, CrewAI, ElevenLabs, Eve, Google ADK, LangGraph, LiveKit, Mastra, Microsoft Agent Framework, NVIDIA NeMo Agent Toolkit, Pydantic AI, Strands and Vercel AI SDK. Eight names appear on both lists. Mem0 alone has LangChain, LlamaIndex, Dify, Flowise, Agno, Pipecat, AWS Bedrock and several others; Zep alone has Pydantic AI, Strands, NVIDIA NeMo Agent Toolkit, the Microsoft Agent Framework, AG2 and Eve. Notably, LangChain and LlamaIndex, the two most commonly assumed integrations, are not on Zep's list, and Zep's page tells you to use an SDK directly if your framework is missing.

### Multi-agent[#](#multi-agent)

Neither vendor sells a multi-agent feature; both do it with identifiers. On Mem0, two agents share memory by using the same `user_id` with different `agent_id` values. On Zep, the user graph is shared by construction and standalone graphs are the first-class home for knowledge several agents read, with attribute-based access control limiting what each agent's key can reach. If the shared thing is the user, both do it in a line. If the shared thing is the business, Zep has a primitive for it and Mem0 has a convention.

### Maturity and support[#](#maturity-and-support)

Mem0 has the larger community and Zep has the better-instrumented service. Mem0's repository shows 64.3k stars, 7.5k forks, 271 open issues and 433 open pull requests, with a Discord and GitHub Discussions. Graphiti shows 29k stars, 2.9k forks, 268 open issues and 176 open pull requests, with community help in the Zep Discord. The open-issue counts are within three of each other on very different star counts, which is worth noticing before reading the star gap as a support signal. Mem0 announced $24 million in total funding in October 2025, led by Basis Set Ventures; Zep publishes no funding round at all.

Paid support is thinner than both price lists suggest. Mem0 gives community support on Hobby and on the $19 Starter tier, private Slack on Pro at $249, and Slack with an SLA on Enterprise. Zep gives community support on Free and on the $125 Flex tier, priority on Flex Plus at $375, and Slack or Teams with a named account manager on Enterprise. Neither publishes a response-time target below Enterprise. Zep runs a public status page covering API, web app and episode processing, showing 99.99 percent, 100.0 percent and 99.99 percent over ninety days and an incident on 27 August 2026 that affected retrieval and episode processing. Mem0 has a status page, but it could not be read from our environment, so we cannot report its contents.

06/Pricing

## Pricing, with the arithmetic[#](#pricing-with-the-arithmetic)

The two vendors meter opposite sides of the transaction, so the entry price tells you very little and the shape of your traffic tells you everything.

|  | Mem0 | Zep | Synap |
| --- | --- | --- | --- |
| Unit | Add and retrieval requests per month | Credits on ingestion; retrieval is free | Credits on both |
| Free | Hobby: 10,000 adds, 1,000 retrievals | Free: 10,000 credits | Trial: 5,000 credits |
| Entry paid | Starter $19: 50,000 adds, 5,000 retrievals | Flex $125: 50,000 credits | Starter $19: 25,000 credits |
| Mid | Pro $249: 500,000 adds, 50,000 retrievals | Flex Plus $375: 200,000 credits | Pro $249: 150,000 credits |
| High | Enterprise, custom | Enterprise, custom | Scale $999: 750,000 credits |
| Overage | None published | $25 per 10,000 on Flex, $75 per 40,000 on Flex Plus | $2.00 Starter, $1.75 Pro, $1.50 Scale, per 1,000 |

Now a worked bill, because a quota table is not a price. Assume every turn is written once and read once, a turn is about 120 bytes, there is no annual discount and no document ingestion.

**Load A: 1,000 users, 100,000 sessions a month, ten turns per session.** That is 1,000,000 writes and 1,000,000 reads.

-   _Mem0._ 1,000,000 adds is twice Pro's allowance and 1,000,000 retrievals is twenty times it. No published tier fits and no overage rate exists, so this is an Enterprise quote with a floor of $249 and no way to model it in advance.
-   _Zep._ A 120-byte turn is one credit, so 1,000,000 credits. On Flex: $125 plus 95 blocks of 10,000 at $25 each, which is $2,500. On Flex Plus: $375 plus 20 blocks of 40,000 at $75 each, which is $1,875. Retrieval adds nothing. Batch each session into one episode of about 1,200 bytes and the same traffic costs four credits per session instead of ten, so 400,000 credits, which is $375 plus five blocks at $75, or **$750**.
-   _Synap._ A 30-token turn ingests at two credits, so 2,000,000 credits for writes plus 1,000,000 for fast-mode reads, which is 3,000,000 credits. On Scale: $999 plus 2,250 blocks of 1,000 at $1.50, or **$4,374**.

**Load B: 100 users, 5,000 sessions a month.** That is 50,000 writes and 50,000 reads.

-   _Mem0._ 50,000 adds fits Starter exactly, but 50,000 retrievals is ten times Starter's cap, so Pro at **$249** is the smallest tier that works.
-   _Zep._ 50,000 credits fits Flex exactly, so **$125**, and reads are free.
-   _Synap._ 100,000 ingestion credits plus 50,000 retrieval credits is 150,000, which is exactly Pro at **$249**.

Two things fall out of that arithmetic and neither is flattering to everyone. Zep is the cheapest of the three at both loads because it does not charge for reads, and its episode-size rule makes batching a first-order cost lever that the other two do not have. Synap is the most expensive at the larger load, at more than twice Zep's cheapest unbatched bill of $1,875 and nearly six times its batched $750, because we meter both sides. And Mem0's model, which looks cheapest at $19, breaks first: a conversational agent reads far more often than it writes, so the retrieval cap is the binding constraint, and the step from Starter to Pro is thirteen times the price for ten times the quota, which is a feature gate rather than a volume discount.

Run the numbers on your own traffic.

The playground runs the memory engine behind our figures — no signup, no key. Or start free and point your own agent at it.

[Start free — no credit card](https://synap.maximem.ai/?utm_source=site&utm_medium=compare_midpage&utm_campaign=mem0-vs-zep)[Try it live — no signup](https://www.maximem.ai/playground)

07/Benchmarks

## Benchmarks, and why they do not compare[#](#benchmarks-and-why-they-do-not-compare)

Read this section as a warning about the genre rather than a scoreboard.

| Platform | Benchmark | Score | Questions | Answer model | Judge | Run date | Who ran it |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Mem0 Platform | LoCoMo | 92.5% (1,425/1,540) at top-200 | 1,540 | Not restated on the results page; harness default gpt-4o | Not restated; harness default gpt-4o, "±1 point" | Blog dated 11 May 2026, describing an April 2026 algorithm | Mem0 |
| Mem0 Platform | LongMemEval | 94.4% (472/500) at top-200 | 500 | As above | As above | As above | Mem0 |
| Mem0 OSS | LongMemEval / LoCoMo | 49.0% / 57.7% | 500 / 1,986 | GPT-5-mini | GPT-5-mini, three-vote | arXiv 2603.04814, March 2026 | Bricks Technology, independent |
| Zep | LoCoMo | 94.7% (1,459/1,540) | 1,540 | gpt-5.4 | gpt-5.4, chain of thought | No date on the page | Zep |
| Zep | LongMemEval | 90.2% (451/500) | 500 | gpt-5.4 | gpt-5.4 | No date on the page | Zep |
| Zep (2025 paper) | LongMemEval-S | 63.8% with gpt-4o-mini, 71.2% with gpt-4o | 500 | As stated | Per paper | January 2025 | Zep |
| Letta | LoCoMo | 74.0% | Not stated | gpt-4o-mini | Not named | August 2025 | Letta |
| Maximem Synap | LongMemEval / LoCoMo | 92% / 93.2% | 500 / 1,540, categories 1 to 4 | gpt-5-mini | gpt-5-mini, binary, single run | Harness README as of 10 September 2026 | Maximem, reproduced on our open harness |

No two rows in that table were produced under the same conditions. The answer model differs, the judge differs, the question count differs, the retrieval budget differs, and in Mem0's case the scores apply to the managed Platform while the only independent run tested the open-source SDK a month before the algorithm changed. Mem0's own documentation gives the right instruction and then does not follow it on its public pages: compare at equal constraints.

The 2025 LoCoMo dispute is the object lesson and it is worth knowing in full, because it is the clearest public evidence of how far conditions move a score. Mem0's April 2025 paper scored Zep at 65.99 percent. Zep's rebuttal in May corrected its own earlier 84 percent to 75.14 percent with an error bar of 0.17, and argued that Mem0 had assigned the user role to both conversation participants, appended timestamps instead of using the `created_at` field, and run searches sequentially. Mem0's CTO then filed an issue arguing that Zep's earlier figure had counted adversarial questions in the numerator while excluding them from the denominator, and reported 58.44 percent for Zep after standardising. That is four numbers for one product on one benchmark inside five weeks, and every disagreement was about configuration rather than about the product.

A third-party analysis, the Benchmark Theatre essay published on 20 May 2026, adds that LoCoMo's ground truth carries roughly ninety-nine score-corrupting errors across 1,540 questions, about six percent, and that the standard judge accepted 62.81 percent of deliberately wrong but topical answers. Treat any cell in any comparison, including ours, as unverified until it carries the benchmark and variant, the question count, the answer model, the judge model, the run date and the name of whoever ran it.

08/The claim audit

## The claim audit: what these two say about each other, checked[#](#claim-audit)

This is the part of the page we most want you to take away, and it is the reason we wrote it. We read Mem0's two comparison posts and its compare page, [Atlan](https://atlan.com/)'s Zep versus Mem0 page and [Vectorize](https://vectorize.io/)'s Mem0 versus Zep article and three further comparison pages from Gamgee, Developers Digest and Foundrysoft, extracted every specific claim each makes about a vendor other than itself, and checked each against that vendor's own current documentation on 10 September 2026.

**Mem0's pages, about Zep.** The feature table in Mem0's April 2026 post says Zep has no MCP support; Zep runs a Memory MCP Server with twelve tools sold by seat, so that is refuted. It says Zep's memory scopes are "Session, User"; Zep defines users, threads, user graphs and standalone graphs, plus projects and UserGroups with attribute-based access control, so that is refuted. It says Zep's framework support is "LangChain, LlamaIndex"; Zep names fourteen frameworks today and LangChain and LlamaIndex are not among them, so that is refuted twice over, once for the undercount and once for naming the two it does not have. It says Zep ships as a community edition and a cloud; the community edition has been unsupported since April 2025 and its code sits in a legacy folder, so that is refuted, although Mem0's own later post from June correctly describes it as deprecated. The June post's claim that Zep setup often takes more than twenty minutes cannot be settled, because Zep publishes no setup-time figure and its quickstart is a hosted API flow with no service to run.

The most consequential error is a benchmark attribution. Mem0's April post presents 63.8 percent as Zep's full-context baseline rather than as Zep's score. Table 2 of Zep's own paper shows 63.8 percent is Zep's result with gpt-4o-mini and 71.2 percent with gpt-4o, and the full-context baselines are 55.4 and 60.2 percent respectively. Two third-party pages then pair that same 63.8 percent, correctly labelled as Zep's score, against Mem0 at 49.0 percent "on GPT-4o", and that half is wrong twice over: the 49.0 percent comes from a 2026 study that used GPT-5-nano for extraction and GPT-5-mini as reader and judge against Mem0's open-source SDK at a top-k of 20, so it is neither GPT-4o nor the Platform, and it predates the April 2026 algorithm. Putting a January 2025 Zep figure beside a March 2026 Mem0 figure run under different models is the error, not the 63.8 itself.

Two of Mem0's claims about Zep hold up cleanly: Zep publishes no BEAM figure, which is true today, and Zep's entry paid tier really is $125. One more holds with a qualifier: self-hosting the Zep side does require Graphiti plus an external graph database.

**The third-party pages, about both.** Atlan's claim that Mem0 has no MCP server is refuted by Mem0's hosted MCP endpoint. Its claim that Mem0 holds SOC 2 Type II is refuted by Mem0's own badge, which says Type I. Its claim that AWS selected Mem0 as the exclusive memory provider for the Strands Agents SDK is refuted by the Strands integrations catalogue, which lists `zep-strands` alongside `mem0-strands` among several memory stores, and by Mem0's own announcement, which says "collaboration" and never uses the word exclusive. Vectorize's Zep prices, Flex at $25 for 20,000 credits with a 1,000-credit free tier, are refuted by Zep's current page at $125 for 50,000 with 10,000 free; its name for Mem0's $19 tier, "Standard", is refuted by "Starter". A claim that Mem0's open-source package offers graph memory through a `graph` extra is refuted: graph memory was removed from the open-source SDK in version 3 and no such extra exists on the published package. A claimed Mem0 "Growth" tier at $79 does not exist. Star counts of 41,000 for Mem0 and 24,000 for Graphiti are stale against roughly 65,000 and 29,000 today.

Two third-party claims about Zep survive and are worth keeping: the February 2026 deprecation wave is real and documented, retiring the V2 SDK, fact ratings, the `mode` parameter on `getUserContext` and `min_score` in graph search; and Zep does hold SOC 2 Type II with HIPAA business associate agreements, with the qualifier that the report and the BAA are Enterprise-only.

One claim is unsettled because the vendor contradicts itself, and it is the most commercially important one on the list. Mem0's graph memory documentation says entity extraction, linking and the retrieval boost are available on all plans automatically, with only the graph visualisation on Pro and Enterprise. Mem0's pricing page lists "Graph memory (entity linking)" as a Pro feature. Both pages are Mem0's own, they are live at the same time, and the difference between them is $230 a month. Ask before you buy.

The pattern across thirty-one claims is not that one vendor is dishonest. It is that comparison pages are written once and vendors ship every week, and that nobody re-checks. Fifteen claims are refuted by the other vendor's current documentation, six are stale, four cannot be settled, and six hold. That is twenty-one cells wrong against six that survive and four that nobody can check, which is a harsher prior than most readers carry into a comparison, and it applies to this one too. The defence is mechanical and you can run it yourself: for each claim, open the page belonging to the vendor the claim is about, find the tier, the field or the figure it turns on, and note the date you read it. That is the whole method, and it took under ten minutes per claim.

09/The third column

## Where Synap sits, and what it does not have[#](#where-synap-sits-and-what-it-does-not-have)

Synap is our product, so treat this as the third column of a table rather than the point of the page.

Structurally it sits on Mem0's side of the architectural split: memories are discrete, self-contained statements with a type, a confidence score, a storage time and an event time, not edges in a graph. What it adds to that shape is a scope ladder that neither Mem0 nor Zep has, with client, customer and user rungs plus the conversation, where a read prefers the narrowest rung that applies and inherits everything above it and never sees a rung below or a neighbour, extendable to deeper hierarchies with your own rung names. Second, supersession is lossless by rule: a newer statement that is poorer than the one it resembles never replaces it, so "takes a cholesterol medication" cannot overwrite "takes 20mg of Atorvastatin daily", and the old statement is marked historical and linked to its replacement with the reason. Third, entity resolution routes ambiguous matches to a review queue instead of guessing. Fourth, the read path is anticipatory: context is pushed into a cache inside your own process while the conversation is still going, which is where the asserted in-conversation P75 under 15 milliseconds comes from; the cold-retrieval P95 of 450 milliseconds is published as a target rather than a measurement. Benchmarks are 92 percent on LongMemEval and 93.2 percent on LoCoMo with gpt-5-mini answering and judging, binary judging, a single run, reproduced on our open harness rather than independently verified.

What it does not have, against these two specifically: no bi-temporal validity fields, so "what was true in March" is answered through history rather than by querying a validity window, and Zep is the right tool if that question is central to your product; SOC 2 Type II is in progress rather than held and HIPAA is not certified, so a compliance-led purchase belongs to Zep today; there is no memory export endpoint documented, which a buyer should ask us about before signing; it is the most expensive of the three at high volume, as the worked bill above shows; and our accuracy figures are vendor figures like everyone else's, with the harness as the only argument we make for them.

10/Which to pick

## Which one to pick[#](#which-one-to-pick)

**A support or sales agent that remembers people.** Mem0, unless the same agent also has to reason about account state that changes. The unit fits, the integration surface is wider, and the failure mode of additive writes matters less when the facts are preferences rather than contract terms. Watch the retrieval cap.

**An agent over facts with dates on them.** Zep, and it is not a close call. Contracts, tiers, entitlements, compliance windows, org charts: these are the things bi-temporal validity was built for, and the alternative is reimplementing validity windows on top of a flat store.

**A voice agent.** Zep on the published numbers, with the caveat that both should be measured on your own traffic. A p95 of 155 milliseconds fits inside a turn; a second-scale read does not unless it is prefetched or moved off the critical path.

**A multi-tenant B2B product.** Neither gives you a tenant rung enforced at write time. Zep's attribute-based access control gets closest. If a tenant boundary is a compliance requirement rather than a convention, test it hard on whichever you choose, and query for another tenant's facts as part of that test.

**A regulated purchase.** Zep, on Enterprise, for the SOC 2 Type II report and the HIPAA BAA. Everything else on this page is secondary to a requirement that appears in a contract.

**Company-wide memory across systems, with permissions.** Neither, today. Both can hold company knowledge, Zep in standalone graphs and Mem0 at application scope, and neither carries the source system's access control through to retrieval, which is where a per-application memory layer stops and a governed context layer starts.

**Self-hosted or air-gapped.** Mem0's Apache 2.0 SDK if you can live without graph, decay, temporal reasoning and Dream, or Graphiti with your own graph database if you want the temporal model and will operate Neo4j. Neither gives you the hosted product.

**Lowest bill.** Zep, at both loads we modelled, because reads are free and batching is a real lever. Run your own numbers with your own read-to-write ratio, because that ratio is the whole answer.

**Already on LangChain or LlamaIndex.** Mem0, and it is the only one of the two that names either. Already on Pydantic AI, Strands, NeMo or the Microsoft Agent Framework: Zep, for the same reason in reverse.

**On LangGraph or CrewAI**, which both vendors support, the adapter is not the deciding factor because both exist and both plug into the extension point the framework already has. Two things actually differ. Zep's LangGraph integration hands you the assembled Context Block, a single string built from edges, nodes, episodes and summaries, so the framework gets a prompt-ready block; Mem0's hands you ranked facts you place yourself, which is more control and more work. And the asynchronous write gap lands differently: in a LangGraph node that writes and then reads within the same run, Mem0's pending event identifier gives you something to poll, while Zep's answer is a processed flag or a webhook, which fits a graph with a wait node and does not fit a straight-line chain. If your graph writes and reads in one pass, plan for that before you pick.

**A document-heavy or graph-RAG agent.** Neither product replaces a retrieval pipeline over a static corpus, and this is the most common mis-purchase in the category. Zep is the better of the two if your documents describe entities and relationships that change, because `graph.add` takes text and JSON and a documents grouping exists for chunked files, and the graph is the point. Mem0 accepts PDF, TXT and MDX and will extract facts from them, but you pay an add request and an extraction pass per chunk, so a two-hundred-page manual is an expensive way to build something a vector index does better. The sane architecture keeps your document RAG where it is and uses the memory layer for what the document corpus cannot hold, which is what this specific person and this specific account currently need.

**An autonomous or coding agent that should own its memory.** Letta, which is a different kind of adoption. And because the question comes up: Letta's SDK is an MCP client and supports external tools, so a Letta agent can call Mem0 or Zep through their MCP servers, which makes the choice non-exclusive if you want it to be.

11/Running your own comparison

## Running your own comparison[#](#running-your-own-comparison)

The decision is worth a week. Take fifty of your own conversations and split each one so that facts established early are needed late, which is the shape both public benchmarks use. Run both vendors with the same answer model and the same judge, keep the judge blind to which vendor produced the context, and report error bars, because every omission in that sentence is one the 2025 dispute turned on. Then measure the five things the benchmarks do not: update correctness, by asking a question after a contradiction; write-to-readable latency, because both write asynchronously; tokens injected per turn; cost per stored turn at your actual read-to-write ratio; and cross-tenant leakage, by querying one user for another's fact. Our [eval harness](https://github.com/maximem-ai/memory_and_context_eval_harness) is MIT-licensed and runs LongMemEval and LoCoMo end to end against several providers with an interface for adding your own, which covers the first half of that list; the second half is engineering that no vendor page will do for you.

Time to first memory is minutes on both. Mem0's quickstart is four steps and about eleven lines and the page says roughly five minutes; Zep's is five steps, creating a user, creating a thread, adding messages, fetching context and adding the reply. The engineering time is not in the quickstart. It is in deciding the scope model, pacing a backfill against rate limits, and handling the gap between writing a fact and being able to read it.

12/Migrating

## Migrating between them[#](#migrating-between-them)

The path is paved in one direction. Zep publishes a Mem0 migration guide with eight steps, using a bulk ingest tool or the batch API for volume, and its central instruction is also the architectural point: do not translate each Mem0 memory into a Zep fact, ingest the source messages or records so that Zep can build the graph. Mem0 supports the export half with an asynchronous job API where you supply a schema and filters, plus paginated listing.

[Going the other way](https://www.maximem.ai/zep-alternatives), no vendor guide exists on either side, and Zep documents no bulk graph export at all, so you would walk episodes, nodes and edges through the API yourself. What is lost in that direction is the model rather than the data: validity windows have no Mem0 field to land in, typed edges flatten to sentences, entity nodes become untyped co-occurrence links, and a fact that Zep invalidated rather than deleted arrives in Mem0 as just another addition sitting beside its successor. [Cognee](https://www.cognee.ai/)'s COGX exchange format is the only neutral bridge we found, defining seven record types including facts with optional validity windows and shipping import sources for both.

13/Using both together

## Using both together[#](#using-both-together)

Technically yes, and neither vendor documents an interop pattern; we searched both documentation sites and found none. Each is a plain HTTP API, so a middleware layer can write every turn to both and read from both before assembling the prompt. The sensible division follows the units: Mem0's statements for what a person prefers and has done, Zep's standalone graphs for what is currently true about an account, a contract or a product.

The costs are four and they are all real. You pay the write path twice, in Mem0 request quota and Zep credits, and you get two different opinions about what the turn meant. You have two asynchronous completion semantics to handle, so read-after-write correctness becomes two problems. You have two token budgets landing in one prompt, so without a deduplication step the model sees the same fact twice, stated differently, possibly with different currency. And you have two deletion surfaces, so a GDPR erasure has to reach both, with Zep's partial-delete semantics not matching Mem0's filtered delete. On our smaller modelled load that is $374 a month instead of $249 or $125. It is a sane architecture for a team that really does have two memory problems and one engineer to own the merge layer, and an expensive way to avoid a decision otherwise.

14/What this is worth

## What this is worth[#](#what-this-is-worth)

Technically, the choice is between a store that keeps facts whole and cheap to read and a store that keeps facts dated and queryable through time. Commercially, it is narrower than that. An agent that quotes a customer's old contract terms because a superseded fact outranked the current one costs you a support escalation and some trust; an agent that cannot say when a fact stopped being true costs you an audit finding. Pick the failure you can live with, verify it on your own conversations, and hold whichever vendor you choose to the same standard of evidence this page tried to hold both of them to.

## Comparing memory layers? Run the numbers on your own conversations.

Our eval harness is MIT-licensed and runs LongMemEval and LoCoMo end to end against several providers. The playground needs no signup.

[Start free — no credit card](https://synap.maximem.ai/?utm_source=site&utm_medium=compare_footer&utm_campaign=mem0-vs-zep)[Try it live — no signup](https://www.maximem.ai/playground)

## Frequently asked questions

### Mem0 or Zep: which is better for AI agent memory?

Neither is better in general; they store different units and that decides the fit. Mem0 stores facts as self-contained sentences in a flat store, which is the right shape for user preferences and history, is cheaper to operate, and integrates with more frameworks including LangChain and LlamaIndex. Zep stores facts as graph edges with validity windows, which is the right shape when your domain has facts that change on a date and someone will eventually ask what was true last quarter. If you have never needed to answer that question, Mem0 is the simpler system; if you need it, nothing in Mem0 substitutes for it.

### Is Zep more expensive than Mem0?

Not on the loads we modelled, because the two meter opposite sides of the transaction. Zep charges credits on ingestion and nothing on retrieval, so a read-heavy conversational agent costs less on Zep despite the higher entry price of $125 against $19. At 1,000,000 writes and 1,000,000 reads a month, Zep is $1,875, or $750 if sessions are batched into single episodes, while Mem0 exceeds its top published tier twenty times over on reads and has no published overage rate. Your read-to-write ratio decides this, so compute it before you read anyone's price table.

### Does Mem0 handle contradictions?

Additively, since April 2026. Extraction is single-pass and returns additions only, so when information changes, the new fact is stored alongside the old one and ranking is expected to surface the newer, with a background consolidation feature marking supersession and an expiry date available to hide a memory without deleting it. Zep takes the other approach, invalidating the contradicted edge with an end timestamp and keeping it queryable. Ask any memory vendor what happens to "takes 20mg of Atorvastatin daily" when a later turn says "takes a cholesterol medication", because that is where the difference shows.

### Can Zep be self-hosted?

Not the product. Zep Community Edition has been unsupported since April 2025 and its code has moved to a legacy folder, so the open-source path is Graphiti, the Apache 2.0 engine, running against Neo4j, FalkorDB or Amazon Neptune that you operate, without Zep Cloud's multi-scope retrieval, observations, governance or MCP server. Self-hosting inside your own cloud is an Enterprise arrangement. Mem0's open-source SDK is Apache 2.0 and self-hostable, without graph memory, decay, temporal reasoning or consolidation, which are Platform-only.

### Are the published Mem0 and Zep benchmark scores comparable?

No, and the vendors' own history shows why. Mem0 reports at a top-200 budget with harness defaults it does not restate on the results page; Zep reports with gpt-5.4 as both reader and judge and no run date; the only independent run tested Mem0's open-source SDK with different models a month before its algorithm changed. In 2025 the same Zep product was scored at 65.99, 84, 75.14 and 58.44 percent on one benchmark inside five weeks, and every disagreement was about configuration. Demand six conditions per cell: benchmark and variant, question count, answer model, judge model, run date and who ran it.

### What is the difference between Mem0, Zep and Letta?

Mem0 and Zep are memory layers you call from an agent you already have; Letta is an agent runtime where memory is a property of the agent, formerly MemGPT, with memory stored as git-versioned Markdown files the agent edits itself. If you are adding memory to an existing stack, Letta is a re-platforming rather than an integration. Its SDK is an MCP client, so a Letta agent can call Mem0 or Zep through their MCP servers, which means the three are not strictly exclusive.

_Sources: every vendor page, repository, paper and framework document named above was retrieved on 10 September 2026, and the pricing, research and documentation pages behind each figure are named in the sentence that uses it. Maximem product statements come from Synap's published documentation. Corrections to any figure are welcome and will be applied with the previous value left visible._

---

Source: [https://www.maximem.ai/compare/mem0-vs-zep](https://www.maximem.ai/compare/mem0-vs-zep)