Genesys vs Cognee
Cognee and Genesys are the two most alike systems in this comparison — both graph-native, both with an explicit memory-lifecycle stage, both rejecting memory-as-flat-vector-store. Cognee's strength is the ingestion-to-graph pipeline: 38+ formats, a structured ECL pipeline, 14 retrieval modes. Genesys's is the legibility of the retention decision: causal edges, a multiplicative score you can audit force by force, and a certified recall number. This is the fairest architectural fight in the set — here is where each one wins.
What Cognee is.
Cognee is the graph-native, pipeline-first memory platform, and of everyone in this list it is the closest in spirit to Genesys — which is exactly why the comparison has to be careful and fair. It is open source (Apache-2.0), self-hostable for free, and built around an ECL pipeline — Extract, Cognify, Load — that turns raw data into a queryable knowledge graph. The Cognify stage is a real, six-step transformation: classify documents, check permissions, extract chunks, use an LLM to pull entities and relationships, generate summaries, then embed everything and commit edges to the graph. It ingests 38+ formats (PDF, CSV, JSON, audio, images, code) and exposes 14 retrieval modes, from classic RAG to chain-of-thought graph traversal, so agents can reason over structure rather than just semantic surface.
The most Genesys-adjacent piece is Cognee's memify stage: after ingestion, it refines the graph by pruning stale nodes, strengthening frequent connections, reweighting edges based on usage signals, and adding derived facts. That is a genuine memory-lifecycle idea, not just storage — and we should say so plainly. Cognee has real traction (a $7.5M seed led by Pebblebed in February 2026, live in 70+ companies, pipeline volume past a million runs in its last reported year). If you want a graph-vector hybrid you fully control, with rich ingestion and many retrieval strategies, Cognee is a serious, credible choice.
Knowledge graph vs. causal graph.
Cognee reweights an entity/relationship graph by usage; Genesys walks a causal graph and scores retention as a single multiplicative decay. Same rejection of the flat vector store; different semantics for what an edge means and how a memory earns its place.
| Dimension | Cognee | Genesys |
|---|---|---|
| Build model | ECL pipeline (Extract → Cognify → Load) over 38+ formats | Per-turn store; heavy work (embedding, causal inference) is async |
| Graph | Entity/relationship knowledge graph (graph-vector hybrid) | One causal graph per user; typed causal edges |
| Edge meaning | Ontology / entity relationships, usage-reweighted | caused_by, supersedes, context — causal semantics the scorer walks |
| Lifecycle | memify: prune stale nodes, strengthen frequent edges, reweight by usage, derive facts | Status FSM (TAGGED → ACTIVE → EPISODIC → DORMANT) + consolidation + reactivation cascade |
| Retention rule | Reweighting + pruning (usage-driven) | Conjunctive prune: decay-score < 0.01 and orphaned and unpinned and not core |
| Scoring | Usage signals reweight edges | Multiplicative: relevance × causal connectivity × reactivation frequency |
| Explainability | Graph is inspectable; 14 retrieval modes incl. CoT traversal | memory_explain returns causal chain + live per-force score; memory_traverse returns edges |
Both systems reject “memory = flat vector store,” both are graph-native, and both have an explicit lifecycle stage — this is the fairest architectural fight in the set. The differences are in emphasis and semantics. Cognee's edges are primarily ontological (entities and their relationships), reweighted by usage; Genesys's edges are primarily causal (why a memory exists, what it superseded, what context it belongs to), and its retention is a single multiplicative decay formula with a conjunctiveforgetting rule — a node survives unless it is simultaneously irrelevant, orphaned, unpinned, and non-core. Cognee's memify strengthens and prunes by usage frequency; Genesys separates the three forces (relevance, connectivity, reactivation) so you can inspect which force is keeping a memory alive.
Put bluntly: if you want the richest ingestion pipeline and the most retrieval strategies over a self-hosted graph, Cognee is ahead. If you want the memory decision— what's recalled, what's forgotten, and why — to be causal and auditable to the individual force, that is the Genesys axis. Where Cognee's strength is the ingestion-to-graph pipeline (38+ formats, 14 retrieval modes), Genesys's is the legibility of the retention decision — memory_explain's score model and memory_amend's supersede-don't-overwrite semantics.
The number, measured.
One yardstick, applied to everyone the same way — and a blank cell where we could not measure honestly, rather than a fabricated one.
Genesys, under the frozen LoCoMo protocol evaluated July 2026, scores 85.55 ± 0.37 J-score — the mean ± standard deviation 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 protocol is frozen and identical for every scored system: n = 1,540 questions, categories 1–4, answerer and judge both gpt-4o-mini at temperature 0.
We could not source a Cognee LoCoMo result under a comparable configuration, so this page does not assign Cognee a number. Cognee publishes its own benchmark material, but we found nothing under this exact frozen judge/answerer/dataset setup that we can cite honestly, and we will not convert an unlike figure into a false comparison. For context, the two competitor numbers we can cite under the shared protocol, next to ours:
| System | LoCoMo J (frozen protocol) |
|---|---|
| Mem0 | 66.9 |
| Zep | 75.14 |
| Genesys | 85.55 ± 0.37 |
Comparability rule. A LoCoMo number is comparable only when the dataset, the answering model, and the judge all match. The rows above share all three. Vendor self-reports produced under different answerer/judge configurations are not comparable and are excluded here — and we hold ourselves to exactly the same rule: our own non-comparable run, which changes only the frozen answerer, is disclosed below and never quoted as the headline. See the LoCoMo citation surface for the exact claim and the ten runs, and the methodology dossier for the full ledger, including the negative results.
If Cognee publishes a LoCoMo number under this configuration, we will add it verbatim. We would rather show a blank cell than a fabricated one.
Which to choose.
Neither system is a strict superset of the other. Choose on the axis your workload actually lives on — ingestion breadth and retrieval variety, or causal recall you can audit and cite.
memory_explain returns the chain and a live per-force score.memory_amend records a new node that supersedes the old and keeps the history queryable.Related.
LoCoMo results
The number and how to cite it — 85.55 ± 0.37, with the comparability caveats spelled out.
What is an AI memory layer?
Vector stores vs. temporal knowledge graphs vs. causal graphs — the honest tradeoffs.
How we measured
The frozen protocol, the failure ledger, and the measured ceiling — the full dossier.
Genesys overview
A causal-graph memory you own and can inspect — connected once, read everywhere.
Where these facts come from.
genesys.astrixlabs.ai/benchmarks/locomo.