/ ml vs Zep & Graphiti

A frontier AI memory system vs. async LLM entity/edge extraction queues into Neo4j/FalkorDB.

/ ml Frontier AI Memory System
  • ✓94.5% LoCoMo (+19.4 pts over Zep) & 77.2% at 10M tokens on BEAM (+35.1 pts)
  • ✓0.86 ms P50 recall (1,500× faster) & synchronous <10 ms writes (zero queue lag)
  • ✓$0 Free & $19/mo Pro ($0.50/1k ops — 5× cheaper) with zero Neo4j/FalkorDB containers to run
Zep Zep & Graphiti Async LLM Edge Extractor + Neo4j
  • ✕75.1% LoCoMo in Zep's re-run (58.4% before async queue finishes) & collapses to 42.1% at 10M tokens
  • ✕1,290 ms P50 recall & 5–20s async graph ingestion lag (2–4 LLM prompts per message)
  • ✕$125/mo Zep Flex ($2.50/1k ops) or heavy Neo4j/FalkorDB + LLM extraction bills in self-hosted VPC
LoCoMo Accuracy +19.4 pts
/ ml 94.5%
Zep Zep 75.1%
Zep scored 58.4% before async queue drained
BEAM 10M Scale +35.1 pts
/ ml 77.2%
Zep Zep 42.1%
ICLR 2026 10M-token long-horizon benchmark
Recall P50 Latency 1,500× Faster
/ ml 0.86 ms
Zep Zep 1,290 ms
<10 ms sync write vs 5–20s async queue
Paid Plan & Ops 5× Cheaper
/ ml $19/mo
Zep Zep Flex $125/mo
$0.50/1k ops vs $2.50/1k ops ($0 Free tier)

How / ml outperforms Zep & Graphiti across LoCoMo, BEAM 10M, and latency

Evaluated across LoCoMo (ACL 2024; Mem0 & Zep published evaluations) and BEAM 100K–10M (ICLR 2026 long-horizon memory benchmark).

LoCoMo & BEAM 1M → 10M · Higher is Better

Retrieval Accuracy Across Scales

+19.4 pts LoCoMo · +35.1 pts @ 10M
/ ml LoCoMo Top-20
94.5%
Zep LoCoMo Re-Run
75.1%
Zep LoCoMo Async Queue
58.4%
/ ml BEAM 1M Scale
83.5%
Zep BEAM 1M Scale
58.3%
/ ml BEAM 10M Scale
77.2%
Zep BEAM 10M Scale
42.1%
Recall P50 · Write Queue Lag · Pricing · Lower is Better

Latency, Queue Lag & API Cost

1,500× Faster · 5× Cheaper
/ ml Recall P50
0.86 ms
Zep Recall P50 (Graph)
1,290 ms
/ ml Write Queue Lag
<10 ms
Zep Write Queue Lag
5–20 s
/ ml Base Paid Plan
$19/mo
Zep Flex Base Paid Plan
$125/mo
/ ml Cost per 1k Ops
$0.50/1k
Zep Cost per 1k Ops
$2.50/1k

Three structural bottlenecks behind external Neo4j temporal property graphs

Zep and Graphiti prompt an LLM on every episode to extract entities, edges, and bi-temporal timestamps into Neo4j/FalkorDB. Here is why that pipeline breaks down—and why / ml wins.

Zep scored 58.4% when queried before its async queue finished

/ ml 94.5% LoCoMo · <10 ms Sync Write
Zep Zep 58.4% Async / 75.1% Re-Run · 5–20s Lag

Because Graphiti runs multiple LLM prompts per message to extract nodes, resolve entity duplicates, and update edge validity windows in Neo4j, writes are queued asynchronously for 5–20 seconds. In Mem0's evaluation, querying Zep immediately scored 58.4%; even after waiting for the queue in Zep's re-run, it reached only 75.1%.

/ ml Advantage: Assimilates streams synchronously in <10 ms and scores 94.5% (+19.4 pts over Zep).

Bi-temporal entity graphs saturate at scale with 1,290 ms traversal

/ ml 77.2% @ 10M · 0.86 ms Recall
Zep Zep 42.1% @ 10M · 1,290 ms Recall

As user histories grow from 100K to 10M tokens, LLM-extracted entity graphs suffer from "hub node explosion"—central entities accumulate thousands of conflicting edges. On the ICLR 2026 BEAM benchmark, Zep drops from 58.3% at 1M tokens to 42.1% at 10M tokens while graph traversal takes 1,290 ms P50.

/ ml Advantage: Sustains 83.5% at 1M and 77.2% at 10M tokens (+35.1 pts over Zep) with 0.86 ms P50 recall (1,500× faster).

5× pricier API overages ($2.50/1k) or heavy Neo4j + LLM bills in VPC

/ ml $19/mo · $0.50/1k Ops · 0 Neo4j DBs
Zep Zep $125/mo · $2.50/1k Ops · Neo4j Required

Zep Flex starts at $125/mo for 50,000 credits ($2.50 per 1,000 operations—5× more expensive than / ml). If you self-host open-source Graphiti in your VPC, you must operate Neo4j/FalkorDB clusters and pay for 2–4 GPT-4o extraction calls on every episode (~$30,000 per 1M writes).

/ ml Advantage: Starts at $0 Free and $19/mo Pro (100k ops, $0.50/1k overage), or deploys in your VPC as a single appliance with $0 external LLM API fees.

Complete Head-to-Head Breakdown: / ml vs. Zep & Graphiti

Every benchmark, latency percentile, and billing line-item side by side.

Dimension Zep / Graphiti / ml Your Advantage with / ml
Core Architecture Async LLM Edge Extractor + Neo4j / FalkorDB Frontier AI Memory System Single self-contained state machine; zero Neo4j clusters
LoCoMo Accuracy 75.1% (Zep re-run) · 58.4% (immediate async eval) 94.5% SOTA (Top-20 Retrieval) +19.4 pts over Zep's best run (+36.1 pts on immediate eval)
BEAM Scale (100K → 1M → 10M) 68.2% → 58.3% → 42.1% 88.9% → 83.5% → 77.2% +35.1 pts at 10M tokens (no hub-node graph saturation)
Recall Latency (P50) 1,290 ms 0.86 ms 1,500× faster recall (99.93% latency reduction)
Write Speed & Queue Lag 5–20 seconds async graph ingestion queue Synchronous (<10 ms) Writes are searchable immediately on the very next turn
Monthly Base Subscription $125 / mo (Zep Flex · 50k credits) $0 Free (10k+1k) · $19 / mo Pro (100k ops) 85% lower base plan with 2× more included operations
Effective Cost & Overage Rate $2.50 / 1,000 credits $0.19 / 1k included · $0.50 / 1k overage 5× to 13× lower cost per 1,000 operations
Self-Hosted VPC Requirements Neo4j/FalkorDB + 2–4 LLM calls/write (~$30k/1M) 1 VPC appliance · $0 external LLM API fees Eliminates graph DB ops and internal LLM extraction bills

Replace Zep & Graphiti with / ml in minutes

Retire your Neo4j containers and async episode queues—ingest sessions directly in milliseconds and recall temporal state in 0.86 ms.

1

Swap Zep / Graphiti Episode Calls for Synchronous / ml State

Replace zep.memory.add() or graphiti.add_episode() with / ml's synchronous .add() and 0.86 ms .search(). Temporal supersession (latest-state resolution) happens automatically.

agent.py — Zep / Graphiti to / ml Migration Diff Python / TypeScript 
-from zep_cloud.client import Zep-zep = Zep(api_key=ZEP_API_KEY)+from slashml import Memory+mem = Memory(api_key="<SLASHML_API_KEY>") -# Zep queues async Neo4j extraction (5-20s lag) & searches in 1,290 ms-zep.memory.add(session_id="sess_01", messages=[Message(role="user", content=text)])-facts = zep.memory.search_sessions(text=query, user_id="user_01", limit=10)+# / ml updates temporal & relational state synchronously (0.86 ms recall):+mem.add(text, user_id="user_01", metadata={"session_id": "sess_01"})+facts = mem.search(query, user_id="user_01")
2

1-Command Importer from Zep Cloud or Graphiti Neo4j

Export your existing Zep sessions or Graphiti Neo4j episodes into / ml with instant synchronous indexing and zero external LLM fees.

Automatic Zep / Graphiti Importer CLI Migration 
$# Option A: Import directly from Zep Cloud API into / ml+npx -y @slashml/memory migrate --from zep --zep-key $ZEP_API_KEY --api-key <SLASHML_API_KEY> $# Option B: Import from self-hosted Graphiti Neo4j / JSON dump+python -m slashml.migrate --from graphiti --input ./graphiti_episodes.jsonl --api-key <SLASHML_API_KEY>

Ready to upgrade from Zep & Graphiti in 60 seconds?

Start free with 10,000 ingests + 1,000 retrievals/month and zero feature locks, or contact our team for custom VPC migration support.

Start Free & Get API Key Contact Engineering Support