Graph memory is no longer a novelty.
A knowledge graph represents entities and the relations between them: a person, a company, an “acquired” edge. GraphRAG names a retrieval technique built on top of one, most prominently Microsoft's open-source GraphRAG project, which improves retrieval for questions that span more than one document, at a documented indexing cost, set out in the comparison with vector memory and RAG.
The technique has since become a configurable option rather than a distinguishing claim. Neo4j ships a first-party GraphRAG package, LlamaIndex offers a property-graph index, and Mem0's default vector-first memory stack has an optional graph mode. A memory system built as a graph is, on its own, no longer evidence of anything unusual.
Substrate memory shares the graph form with each of the above. The comparison worth having is not whether a graph is present but how it came to exist and what its edges are asserted to mean.
An extraction pipeline, read after the fact.
Microsoft's GraphRAG builds its graph in four stages: a language model reads a document corpus and extracts entities and relations, a clustering algorithm groups the resulting graph into hierarchical communities, each community is summarized by a further model call, and retrieval runs across the summaries and the underlying graph together. A later variant, LazyGraphRAG, defers the summarization step to query time to cut indexing cost, but the pipeline is still extraction first: a model reads a corpus that already exists and infers a graph from it.
Substrate memory names a different write path. An entry and its typed links are set by the agent doing the work, as a direct product of that work, rather than inferred afterward by a separate model reading a transcript. There is no corpus to extract from and no indexing pass to run, because the structure is asserted at write time instead of read back out of prose at index time. What counts as a relation under that scheme, and what it takes for one entry to supersede or implement another, is set out in full under causal memory.
Zep's Graphiti: incremental, and still extracted.
The comparison above understates one shipped tool. Zep's Graphiti builds a bi-temporal graph: each edge carries the interval during which the fact it represents held true, separate from when it was ingested. New information is checked against the existing graph and used to update or invalidate an edge's validity interval, rather than triggering the large-scale recomputation a batch-indexed graph requires when its source corpus changes. Of the tools compared on this page, Graphiti comes closest to updating the way a substrate does: continuously, without a full reindexing pass.
The distinction that remains is in where the edge comes from. Graphiti ingests raw conversation messages and extracts facts and their temporal validity from them, a step run by the system over content it received. A substrate's typed links are asserted by the agent that did the work, as part of doing it: an entry that reverses an earlier decision is linked to it as a supersession by the author who made the reversal, not inferred from a later message that happens to contradict an earlier one. Both graphs update continuously. One infers what changed from ingested text; the other is told, directly, by whoever changed it.
Extracted entities, or authored decisions.
An extraction-based knowledge graph typically stores entities and the relations inferred between them. A live-authored substrate stores a different unit.
| On the graph | Description |
|---|---|
| extracted entity | A knowledge-graph node representing a person, organization, or concept, identified by a language model reading a document or transcript after it was written, then resolved against other mentions of the same entity. |
| typed entry | A substrate node representing a unit of reasoning — a decision, a question, a blocker — set by the author at the moment of writing, not identified afterward by a separate extraction pass. |
| extracted relation | An edge such as “acquired” or “founded,” inferred by a model from co-occurring text and typically carrying a confidence score rather than a claim of certainty. |
| typed link | An edge such as supersedes or implements, asserted directly by the entry's author because that relation holds, not inferred from how two entries are worded. |
The distinction is not graph versus no graph; every tool compared on this page uses one. It is between a node and edge inferred from text a model was not present for, and a typed record of a decision written by the agent that made it, with the record of who wrote it and when carried alongside, a property covered in full under provenance and trust.
Common questions.
Is this an argument against GraphRAG?
No. GraphRAG is a well-studied technique for a specific job: building a retrievable graph from an existing corpus and using it to answer questions that span more than one document. Substrate memory addresses a different question — what a graph is asserted to mean and when it is written — which applies whether or not a corpus-extraction step is present at all.
Isn't Zep's Graphiti already a live-updating graph?
Graphiti updates incrementally and tracks when a fact held true, which is a real advance over a batch-indexed graph that has to be substantially rebuilt as a corpus changes. Its edges are still produced by an extraction step run over ingested messages, distinct from an edge an acting agent asserts directly as a product of doing the work, covered further under causal memory.
Does the reference implementation run any graph extraction?
No. Entries and their typed links are written directly by the agent doing the work. The reference implementation also runs pgvector for semantic-similarity search, a separate layer covered in the comparison with vector memory and RAG.