MnemoverseDocs

Appearance

Edward Izgorodin·Published Aug 15, 2026

Knowledge Graph vs Retrieval for AI Agent Memory: The Real Split Is Learned vs Asserted Structure ​

TL;DR

  • The choice that matters in agent memory is learned structure vs asserted structure, not graph vs retrieval.
  • A learned graph never asserts identity, so its failure mode is bias in what surfaces; an asserted graph answers structural questions, and every merge can be precisely wrong.
  • Store the verbatim span, source link, and retrieval date rather than a paraphrase, so staleness is detectable instead of silent.
  • LLM-extracted memories beat raw-chunk retrieval on the LOCOMO benchmark in the Mem0 team's own evaluation (J = 66.88 vs 60.97); this position accepts that cost because the argument is auditability, not benchmark supremacy.

The real split in agent memory: learned structure vs asserted structure ​

When an engineer types "knowledge graph vs retrieval for agent memory," the question usually hides a deeper architectural fork. On one side sits a system that stores associations it learned from use. On the other sits a system that stores facts someone asserted about the world. The two are not interchangeable, and the honest answer is that a serious memory engine ends up with both, at different layers, connected by provenance rather than merged.

Four terms carry the argument.

A knowledge graph is typed, directed relations between resolved entities, answered by traversal; it asserts facts about the world.

A learned graph, also called associative memory, is untyped, weighted links from co-occurrence and use; it asserts nothing attributable and never merges identities.

Entity resolution is the decision that two mentions denote the same thing: the load-bearing and most expensive assertion in any knowledge graph.

Provenance is the record of where a memory came from and who put it there: the asserter's identity, the source link, the retrieval date, and the exact text read.

The two structures fail differently. An asserted edge that is wrong is precisely wrong, and the error propagates through every traversal that crosses the merged node. A learned edge that is wrong is never an explicit falsehood; it is a bias in what the system chooses to surface, and that bias can be just as damaging.

What a learned graph guarantees (and what it does not) ​

A learned graph does not say "Alice works at Acme." It may only make "Alice," "Acme," and related traces more likely to surface together. That avoids an attributable false claim, but it does not remove risk: a structure built from co-occurrence is itself a world model, and world models can mislead.

Caliskan, Bryson, and Narayanan showed that word embeddings trained purely from language co-occurrence statistics predict 2015 US Bureau of Labor Statistics occupational gender composition at rho = 0.90 and replicate human-measured bias effect sizes (Science 356, 2017). Co-occurrence is not neutral just because no person typed an explicit edge. The false-memory literature makes the same point from another direction: in the DRM paradigm, hearing associated words such as bed, rest, and tired produces confident false recall of a never-presented word, sleep, in roughly 40% to 55% of trials, from associative structure alone (Roediger and McDermott 1995).

So the guarantee a learned graph offers is narrow. It makes no attributable claim. It never merges identities. It can still mislead, because it decides what surfaces. The honest formulation is "no attributable claim, no identity merging," not "cannot be wrong."

If a learned edge causes irrelevant material to surface, the system has a ranking or association problem. If an asserted graph merges two different people, the system has a false world model. Both can be harmful. Only one is a stored factual assertion.

The cost of asserting identity: entity resolution in a knowledge graph ​

A knowledge graph earns its power by asserting structure: traversal over typed relations answers questions that plain retrieval handles poorly. The cost is entity resolution, and the cost is structural, not incidental. If the system decides that "J. Smith," "Jane Smith," and "Jane A. Smith" are one person, it has made a structural claim, and if that claim is wrong, every traversal through the merged node inherits the error.

Large extraction systems treat this with care. Google Knowledge Vault attached a calibrated confidence to every extracted triple rather than asserting it flat; only a minority of triples reached high-confidence status (Dong et al., KDD 2014). Even at that scale, extraction output is evidence with uncertainty, not ground truth by default.

Zep's Graphiti describes a temporal knowledge graph for agent memory: edges carry validity intervals, and entity resolution happens at ingest with an LLM in the loop (arXiv:2501.13956). Microsoft GraphRAG builds an LLM-derived entity graph with community summaries; the paper's own framing is that indexing is expensive and the win is on global, corpus-level questions, not needle lookup (arXiv:2404.16130). Neither treats entity resolution as a solved, cheap step. Adding asserted structure means accepting that cost and the risk of precise wrongness. It is not the right default for every memory workload.

Stored paraphrase is a stored misgrounding ​

A common shortcut in agent memory pipelines is to extract a natural-language summary at ingest and store it next to a source pointer. The summary is what the retriever sees; the pointer is what the auditor checks later. The problem is that the auditor rarely checks.

A preregistered study of commercial legal AI tools found hallucination rates of 17% to 33%, where hallucination includes misgrounded answers: key factual propositions are cited, but the cited source does not support the claim (Magesh et al., Journal of Empirical Legal Studies). A stored paraphrase next to a pointer is exactly that failure mode, and it cannot be detected without re-reading the source.

A bare pointer, by contrast, rots. The Hypothes.is anchoring study examined 20,953 quote-anchored web annotations collected over roughly two years, 20,133 of which had resolvable targets and were analyzed: 22% no longer matched their live page, 19% were permanently unrecoverable orphans, and only about 12% of the broken subset could be re-attached through web archives (arXiv:1512.06195). A bare pointer is honest only at write time.

The alternative is to store the verbatim span that was read, next to the source link and the retrieval date. The span does three jobs at once. It is deterministic: bytes from the source, not a model interpretation. It is ordinary text, so it embeds and searches semantically. And it is exactly what a W3C Web Annotation TextQuoteSelector is: exact text with prefix and suffix, which re-locates the passage later and fails detectably when the document changed (W3C Web Annotation Data Model). Fuzzy anchoring reports failure; it does not silently lie.

Anthropic's Citations API follows the same instinct: cited text is extracted directly, with start and end character indices, so citations contain valid pointers to the provided documents, and interpretation happens at read time rather than being stored as a paraphrase (Anthropic Citations).

Provenance as the bridge ​

If learned structure and asserted structure answer different questions with different truth guarantees, the bridge between them cannot be a merge. It must be provenance: a record of consultation that points at sources, with the exact text read kept verbatim.

The double reference, origin link plus dated snapshot, is standardised prior art, not invention. Memento (RFC 7089) defines the Original Resource, the Memento as an archived state with a Memento-Datetime, and the TimeGate and TimeMap vocabulary (RFC 7089). Robust Links carry data-originalurl, data-versionurl, and data-versiondate; the date lets a reader find a replacement snapshot if one archive dies (Robust Links specification, archived 2025-05-23). Wikipedia's CS1 url-status enum records drift as a state, not an error: "deviated" means the URL is live but no longer supports the cited text.

There is a limit to state plainly. Ainsworth, Nelson, and Van de Sompel measured that at most 38.7% of composite web mementos are temporally coherent and at most 17.9% are both coherent and complete, because embedded resources are captured at different times (DOI 10.1145/2700171.2791044). The safe promise is therefore for the text span, not for the full page. And when the text was read is not the same as when the fact was true; that second time axis belongs to Bitemporal memory for AI agents.

When extraction wins on LOCOMO, auditability still matters ​

This position has a cost that must be stated openly. The field's dominant memory architectures store interpretations, not raw spans. Generative Agents stores natural-language experience records and synthesises reflections (arXiv:2304.03442). RAPTOR stores recursive summaries as retrieval units (arXiv:2401.18059).

The two approaches differ in what sits in storage. Chunk retrieval keeps the conversation as raw text fragments and answers by fetching the most similar ones; nothing is rewritten. Extraction runs an LLM at write time that distills the conversation into short memory statements, so storage holds the model's interpretation rather than the source text. On LOCOMO, a public benchmark of question answering over very long multi-session conversations, the best chunk-based RAG configuration reaches a judge score of J = 60.97 while LLM-extracted dense memories reach J = 66.88 (Table 2 of arXiv:2504.19413; note this is the Mem0 team's own evaluation of its own system). The mechanism is no mystery: a distilled fact is denser than the chatter around it, so the same retrieval budget hits the answer more often.

That result should not be waved away. Extraction can buy benchmark points. The price is auditability. An extracted memory is already a paraphrase or judgment, and a system that stores it can only trust the extractor. The chunk-retrieval approach preserves the original wording and the original source pointer; the lower score is the measured price of that. The choice is whether you need the points more than you need the audit trail; make it explicitly, and never let an extractor's sentence become the stored fact silently.

A practical decision rule for agent memory architecture ​

An architect choosing memory for an agent gets a decision rule, not a verdict.

Use retrieval when the agent needs to find past evidence. Add learned association when lexical retrieval misses useful related memories, and treat the result as ranking influence rather than truth. Add an asserted knowledge graph when the agent needs structural answers over resolved entities, and only where the system owner accepts entity resolution as a stored assertion. Keep provenance across all three: source link, retrieval date, exact text read, and, where available, a dated snapshot link.

Do not merge learned and asserted structure into one vague memory graph. Their guarantees differ. A learned edge says, in effect, "these things have appeared together." An asserted edge says, "this relation holds between these resolved entities." A provenance record says, "this is what was read, from here, at this time." Those are three different artifacts.

Mnemoverse's shipped memory engine takes the learned side. Its association layer links concepts through weighted edges strengthened by co-activation, with feedback tuning the weights over time (Hebbian memory for AI agents). Those edges carry no relation types, no direction, and no entity resolution: the association layer never asserts that two records denote the same thing. What is stored is the caller's text verbatim: an importance gate may reject a write, but no write is rewritten or replaced by an extracted interpretation. A consolidation stage that clusters similar memories into prototypes exists in the engine and is deliberately switched off on the hosted service (API overview). That makes the live path a retrieval and associative-memory substrate, not an asserted knowledge graph.

The cluster fills in the pieces: when an agent consults memory is covered in Agent memory: evidence vs policy, the who behind each assertion in Provenance in agent memory, whose asserter-side fields complement the source, date, and span record argued for here, and the retrieval floor in Not a vector database.

The two structures do not need to merge. They need to be connected by a record that can be checked. Treating them as one artifact is how memory systems become confident without becoming checkable.

Common questions ​

What is better for AI agent memory: knowledge graph or retrieval? ​

Neither is categorically better. Retrieval and learned association fit experience memory because they do not assert identity; a knowledge graph fits structural questions when you accept entity resolution as a stored assertion.

When should agent memory use a knowledge graph? ​

Use a knowledge graph when the agent must answer structural questions over resolved entities, such as traversing typed relations, and when the system owner accepts the cost of asserting identity at ingest.

Why not store LLM-extracted memories instead of source text? ​

Extraction can improve benchmark scores, but it stores an interpretation. On LOCOMO, chunk RAG reached J = 60.97 while LLM-extracted dense memories reached J = 66.88 in the Mem0 team's own evaluation (arXiv:2504.19413); the tradeoff is auditability, not whether extraction is useful.

How does provenance reduce stale or false agent memory? ​

Provenance keeps the source link, retrieval date, and exact text read, so later reads can detect drift instead of trusting a bare pointer. In the Hypothes.is anchoring study, 22% of quote-anchored annotations collected over roughly two years no longer matched their live page.

Does Mnemoverse use a knowledge graph for agent memory? ​

Mnemoverse ships a learned associative graph, not an asserted knowledge graph. Its edges carry no relation types, no direction, and no entity resolution, so the association layer never asserts that two records denote the same thing; a consolidation stage that clusters similar memories into prototypes exists in the engine and is switched off on the hosted service. The associative layer itself is described in the Hebbian memory for AI agents article in this library.

Sources ​

Papers and studies:

Standards and specifications:

Product documentation:

— Edward Izgorodin · Last updated 2026-08-15

— Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Docs: Getting Started