Genesys vs. Mem0
Mem0 is the most widely adopted memory layer for AI agents, and it earned that position. This is an honest architectural comparison — what the two systems store, how they handle a correction, and how they score on LoCoMo under one frozen protocol. Steelmanned, with the numbers held to the same yardstick and the caveats published alongside them.
The steelman.
Mem0 ships as an open-source core (Apache-2.0, mem0ai/mem0) plus a managed cloud. You call add() after a turn and search() before one; the retrieval surface is small and the SDK is genuinely easy to adopt. The current algorithm (their v3, 2026) is deliberately simple on the write path: a single-pass, ADD-only extraction— one LLM call that distills a turn into atomic facts, scoped to a user, session, or agent, and stores them without rewriting what came before. Mem0's earlier design ran a second reconciliation pass on every write; they dropped it because that is where cost, latency, and silent deletions lived. The trade is explicit and, for their goals, sensible: writes are one cheap call, old facts survive alongside new ones, and the conflict problem moves downstream to read time, where multi-signal retrieval ranks what comes back.
Storage is a hybrid matched to access patterns: a SQL store as the source of truth for facts and metadata, a vector store for semantic recall, and an entity/graph store for relationship-aware retrieval when graph memory is enabled. The open-source core is backend-agnostic on the vector side (Qdrant, Chroma, Milvus, pgvector, Redis, and others), which makes it easy to drop into an existing stack. For a large class of applications — “remember this user's preferences and past facts, cheaply, across sessions” — Mem0 is a sensible default and a fair benchmark for everyone else.
Accumulated facts vs. a causal graph.
The two systems disagree less about storage than about what an edge means and whether memory has a lifecycle.
| Mem0 | Genesys | |
|---|---|---|
| Core unit | Atomic fact — an extracted statement | Memory node in one causal graph per user |
| Relationships | Entity links (Alice → works_at → Acme), gated to the Pro tier | Typed causal edges: caused_by, supersedes, context |
| Update model | ADD-only accumulation — a new fact lives alongside the old one, unlinked; conflicts are resolved at read time by retrieval ranking | memory_amend records a new node with a typed SUPERSEDES edge — which fact replaced which, and why, is stored structure |
| “Layers” | SQL + vector + graph stores, matched to access pattern | Status tags on one graph (TAGGED → ACTIVE → EPISODIC → DORMANT) — no second database |
| Forgetting | Explicit delete / batch-delete APIs; otherwise facts accumulate | Conjunctive: pruned only when decay-score < 0.01 and orphaned and unpinned and not core |
| Explainability | Retrieved facts plus ranking signals | memory_explain returns the causal chain plus a live per-force score breakdown; memory_traverse returns the induced-subgraph edges |
The honest distinction is not “graph vs. no graph” — Mem0 has a graph. It is what the edges mean. Mem0's graph links entities. Genesys's edges are causal: they record why a memory exists, what it superseded, and what context it belongs to, and the scoring engine walks those edges to decide what stays alive.
Nor is the distinction “they delete history, we keep it” — that was true of Mem0's old reconciliation design, and it is not true anymore. In today's Mem0, when a fact changes, the old and new versions both survive. What does not survive is the relationship between them: the two facts coexist as unlinked rows, and it falls to read-time ranking to guess which one is current. In Genesys the correction is an edge — memory_amend writes a SUPERSEDESlink, so “what did I believe before, and why did it change?” is a traversable query, not a ranking heuristic, and the superseded node is down-weighted at recall by structure, not by inference.
The second real difference is lifecycle. Mem0's store grows until you call delete. Genesys treats memory as a system with states — new memories consolidate from episodic to semantic, unused ones go dormant, and a reactivation cascade can bring a whole neighborhood back when one node is touched. Forgetting is conjunctive and auditable, not manual. That machinery is the product, not a config flag.
Same yardstick.
The protocol is frozen and identical for both systems below: n = 1,540 questions, categories 1–4, answerer and judge both gpt-4o-mini at temperature 0. Whatever is frozen defines comparability; whatever we tuned is a lever every competitor also controls.
Genesys, frozen LoCoMo protocol, evaluated July 2026: 85.55 ± 0.37 on LoCoMo — the mean of ten independent runs under a frozen gpt-4o-mini answerer and judge at temperature 0 (n=1,540, categories 1–4; evaluated July 2026). That figure is the mean over ten independent full runs (84.87, 85.84, 85.71, 85.58, 85.26, 85.78, 85.52, 86.17, 85.52, 85.19); the spread is the standard deviation across them.
| System | LoCoMo J (frozen protocol) |
|---|---|
| Mem0 — published, comparable · arXiv 2504.19413 | 66.9 |
| Genesys — certified, ten-run mean | 85.55 ± 0.37 |
Why 66.9 and not 92.5.We cite Mem0's 66.9 because it was published under a configuration comparable to ours — same dataset, same J-score metric, same frozen answerer and judge. We do not cite 92.5 as if it were, for the same reason we keep our own 89.68 out of the headline. The full method — the frozen protocol, the per-category results, and the failure ledger — is the LoCoMo citation surface and the methodology dossier.
Choose the failure you can least afford.
This is not a winner-take-all comparison. Mem0 optimizes the write path and hands conflict resolution to read-time ranking; Genesys pays a richer write path to make corrections, lifecycle, and explanations first-class structure. Pick the tradeoff you can live with.
- Adoption is the feature — you want the largest community, the most integrations, and the most battle-tested SDK in the category.
- Your need is atomic facts about a user, cheaply, across sessions — not reasoning over why a fact holds or how it changed.
- Write-path cost and latency are the binding constraint — single-pass ADD-only extraction is one LLM call per turn.
- You are committed to a specific vector backend (Qdrant, pgvector, Milvus…) and want memory to sit on top of it, not a new datastore.
- You want to start free and stay vector-only — Mem0's graph features are gated to the Pro tier at $249/month; Hobby and $19 Starter are vector-only.
- Read-time ranking is enough conflict resolution — you only ever need the current value, and retrieving the newest matching fact is acceptable.
- Causal recall matters — you need to traverse why the agent believes something, not just retrieve it. memory_explain returns that chain plus a live score breakdown.
- Memory lifecycle matters — episodic→semantic consolidation, dormancy, and reactivation cascades as first-class behavior, not a table that only grows.
- Corrections should be structure, not a ranking guess — memory_amend writes a typed SUPERSEDES edge, and superseded memories are down-weighted deterministically.
- Explainability matters — every recall carries an activation score you can inspect; every prune obeys a conjunctive rule you can audit. Nothing disappears silently.
- You want one portable, user-owned graph that follows you across ChatGPT, Claude, and anything that speaks MCP — inspectable, and yours.
- You want the number checked — the engine is AGPL and open; the harness, the ten run artifacts, and the failure ledgers are published.
Verified 2026-07-19.
Competitor facts were verified 2026-07-19 against Mem0's pricing page, docs, GitHub, and blog. Pricing and gated-feature tiers change often — re-verify at publish time. Genesys figures are the certified frozen-protocol numbers.
Related.
LoCoMo results
The number and how to cite it, with the comparability caveats spelled out.
What is an AI memory layer?
Vector stores vs. temporal knowledge graphs vs. causal graphs, and the honest tradeoffs.
The methodology dossier
The frozen protocol, the gain/loss ledger, and the negative results.
The open-source engine
AGPL, inspectable, MCP-native — one graph you own, read everywhere.