Genesys vs Zep
Zep is the most architecturally serious competitor in agent memory, and this page says so. It is built on Graphiti, a bi-temporal knowledge graph. Genesys is a causal-graph memory engine. Both bet that memory should be a graph you can inspect; they disagree on the axis the graph is organized around. This is the honest comparison — where each is stronger, and how both score under one frozen benchmark.
What Zep is, at its strongest.
Zep's core is Graphiti — open source under Apache-2.0 — a temporally-aware knowledge graph that stores facts as nodes with start and end validity windows. That bi-temporal model is a genuinely good idea: Zep can answer “what was true as of March?” and reconcile a fact that was correct then and wrong now without deleting the history. Its entity resolution tracks the same entity across unstructured conversation and structured business records — exactly what enterprise deployments need.
Retrieval is fast and does no LLM inference at query time: Graphiti fuses semantic embeddings, BM25 keyword search, and direct graph traversal. Zep advertises sub-200ms P95 retrieval regardless of graph size — vendor-reported, retrieved 2026-07-19; its own 2025 benchmark rebuttal measured 0.632s P95 search latency, so treat the marketing figure as aspirational. The company positions itself as “agent memory, at enterprise scale,” with SOC 2 Type II and HIPAA BAA on the Enterprise tier only. The original Zep paper (arXiv:2501.13956) also established one of the few comparable benchmark numbers in this field — which we cite below, and thank them for.
Temporal validity vs. causal lifecycle.
Zep and Genesys agree on the big bet — memory should be a graph, not a flat vector store (see what an AI memory layer is) — and both give you inspectable structure instead of an opaque embedding blob. The difference is the axis the graph is organized around.
| Zep · Graphiti | Genesys | |
|---|---|---|
| Core unit | Fact node with a validity window (bi-temporal) | Memory node in one causal graph per user |
| Edge meaning | Entity relationships, temporally scoped | Typed causal edges: caused_by, supersedes, context |
| Time model | When a fact was valid / invalid | When a memory was reactivated; status-based aging (episodic → dormant) |
| Retrieval | Embeddings + BM25 + graph traversal, no LLM at query time | Vector + graph traversal + multiplicative scoring; concise mode skips chain enrichment |
| Update model | A new edge invalidates the old one within the time graph | memory_amend node supersedes; the old node decays and is demoted naturally |
| Forgetting | Time-scoping; retention governed by the graph | Conjunctive prune: decay-score < 0.01 and orphaned and unpinned and not core |
| Explainability | The graph is inspectable; validity is legible | memory_explain returns the causal chain + live per-force score; memory_traverse returns induced-subgraph edges |
The organizing axis
Zep's organizing axis is time: when was this fact valid. Genesys's organizing axis is causality and lifecycle: why does this memory exist, what did it supersede, and is it still alive. These are complementary, not identical. If your hardest questions are “what did we know, and when,” Zep's bi-temporal model is purpose-built. If your hardest questions are “why does the agent believe this, and what would have to change for it to stop,” Genesys's causal edges and decay scoring target that directly.
Self-hosting
One operational difference worth stating plainly. Graphiti is open source, but Zep's Community Edition is deprecated and no longer supported (per Zep's own FAQ; third-party accounts date the deprecation to April 2025, with further feature retirements in February 2026). Self-hosting the memory service now means running Graphiti plus a compatible graph database — Neo4j, FalkorDB, or Amazon Neptune (Kuzu support exists but is deprecated) — so you provision and operate multiple systems. Genesys's core library runs in-memory with zero external dependencies (pip install genesys-memory); storage backends are pluggable behind a provider interface, not required to start.
The same yardstick.
Genesys scores 85.55 ± 0.37 on LoCoMo — the mean of ten independent runs under a frozen protocol: n = 1,540 questions, categories 1–4, answerer and judge both gpt-4o-mini at temperature 0. The number is certified and reproducible.
| System | LoCoMo J (frozen protocol) |
|---|---|
| Zep (corrected, comparable) | 75.14 |
| Genesys | 85.55 ± 0.37 |
Comparability.Both rows are measured under one frozen protocol — same answerer, same judge, same question set. Zep's 75.14 is its own corrected figure: an early blog post claimed 84% until Mem0 documented a category-5 arithmetic error, and Zep's CEO republished the corrected 75.14 ± 0.17. We cite the corrected number, not the marketing one. Vendor self-reported figures above 90 that use non-comparable configurations are excluded on both sides. See the LoCoMo citation surface and the full methodology.
The gap is real. It isn't the whole story.
The gap here — 75.14 to 85.55 ± 0.37 — is real under a real protocol. But it is a benchmark, not a verdict. On the things LoCoMo does not measure — bi-temporal validity queries, enterprise entity resolution across structured systems, sub-300ms P95 at scale — Zep is strong, and this page will not pretend otherwise. Pick on the axis your product actually turns on.
- Your hardest questions are temporal: “what was true as of date X,” reconciling facts valid then and invalid now. Bi-temporal validity windows are the right primitive, and Zep built the engine around them.
- You need entity resolution across unstructured conversation and structured business data in one graph — CRM records, tickets, and chat resolving to the same entity.
- You need low query-time latency at scale (no LLM in the retrieval path) and enterprise compliance — SOC 2 Type II, HIPAA BAA, on the Enterprise tier.
- You are comfortable operating a graph database (Neo4j / FalkorDB / Neptune) alongside Graphiti, or you will run it fully managed on Zep's cloud.
- You want a mature, well-documented temporal-KG engine — and you value that Zep published a checkable benchmark.
- Causal recall matters more than temporal validity.“Why does the agent believe this, and what caused it?” — traversable causal edges, not just when a fact was valid.
memory_explainreturns the chain and the live score. - Memory lifecycle is the product. Episodic→semantic consolidation, dormancy, and reactivation cascades — memory that ages and revives, not just facts scoped by time.
- Explainability at the scoring layer. Every recall carries an inspectable activation; every prune obeys the conjunctive rule (irrelevant and orphaned and unpinned and not core). You can audit why anything stayed or left.
- You want zero infrastructure to start.
pip install genesys-memoryruns in-memory with no external database; backends are pluggable, not prerequisites. - You want one portable, user-owned graph across ChatGPT, Claude, and anything speaking MCP — inspectable and theirs.
- The head-to-head under the shared protocol is 75.14 vs. 85.55 ± 0.37, and you want to run the harness yourself. It's open source (AGPLv3).
Sources & retrieval date.
Competitor facts were retrieved 2026-07-19 via web search; the sources are linked below. Pricing and self-host terms change — re-verify before relying on them. Genesys figures are the certified frozen-protocol numbers at the LoCoMo citation surface.