State, Memory and Knowledge Graphs

Three memory tiers, three lifetimes: the context window (this exchange), session memory (this conversation), durable memory (this relationship). Bigger windows didn't solve memory — they postponed forgetting to the next session. The engineering question of the decade: what deserves to survive the run, and in what structure?

The Zep paper's framing became canonical: RAG was built for static documents; agents need memory that updates from live conversations and business data simultaneously.

OpenAI Agents SDK sessions handle the middle tier; LangGraph stores + Neo4j handle the durable tier. The routing rule from the field: relational/multi-hop questions → graph; broad semantic search → vectors; this-session facts → context.

Durable memory is built by a pipeline, not a dump. Extract entities and typed claims from raw material (cheap model, schema-forced). Resolve aliases into canonical nodes ('Buzz Aldrin' = 'Edwin Aldrin' — judgment, so a stronger model). Assemble typed edges with provenance and confidence on every claim. Verify before writing — contradictions get flagged or superseded, never silently overwritten. Persist, then repeat: the graph grows, it is never rebuilt.

Emil Eifrem on relationships as first-class data; the bi-temporal insight from Zep/Graphiti: every edge carries when-it-happened and when-we-learned-it, so 'what did we believe in June' stays answerable.

Neo4j stores the graph and Cypher queries it; LlamaIndex extraction pipelines feed it; Graphiti automates the temporal bookkeeping if you want the managed version.

Retrieval that traverses beats retrieval that guesses — on multi-hop questions, production reports put graph traversal 36–46% ahead of vector-only search. GraphRAG combines both: vectors find entry points, edges walk to the answer, and every claim cites a specific edge. Consolidation keeps it healthy: periodic passes that merge duplicates, decay stale confidence, and supersede contradictions — memory hygiene as a scheduled graph job.

Jerry Liu's agentic-retrieval framing: agents should route between retrieval strategies per question, not commit to one; the router itself is judgment.

Neo4j's GraphRAG stack combines vector search with Cypher traversal; LlamaIndex router agents pick the strategy per query.

A multi-agent system needs two graphs, and they must not be collapsed into one. The commit DAG stores work lineage: what changed, which experiment is the parent, which lineages are still alive. The knowledge graph stores domain meaning: which entities exist, which sources support which relation, which claims conflict. Production systems link them — agent_run —produced→ claim —about→ entity, claim —supersedes→ claim, run —modified→ commit —evaluated_by→ evaluation — so every fact knows the work that produced it.

The Karpathy→Anthropic synthesis (J. Parajan, July 2026): swarms scale not by copying every worker transcript into an orchestrator’s window, but by writing findings into shared graph state. The agent forgets; the graph does not. Failed experiments stay addressable as evidence, and a new worker queries the lineages it needs instead of replaying history.

Anthropic’s Knowledge Graph Cookbook versus Neo4j. The cookbook replaces a trained NLP pipeline with structured outputs: a small model extracts typed entities and relations against a Pydantic schema (“the schema is the only training data”), a stronger model resolves aliases as a reasoning task — merges reversible, aliases and rationale retained — and assembly attaches provenance to every edge. The payoff is graph-grounded evaluation: a critic checks each claim against edges and returns structured missing-evidence feedback (“no supported path from Vendor X to Incident Y; required: a source-backed supplied edge”) — far more actionable than a free-form review.

A folder of markdown becomes a graph the moment you add the two files most vaults never get: a router (read every session, kept under 500 tokens — a map, not a manual) and an index (one line per note: name, link, one sentence). Nodes hold one idea per file — the mega-note that covers ten topics costs all ten to use one line. Edges are purposeful pointers, not the pretty graph view: “ten sharp edges make a graph; fifty is noise wearing a graph’s clothes.” The distinction that organizes everything: a pile (ask anything, read everything), a graph (ask anything, read two or three files), a system (a graph with memory that compounds — a state file every run reads first and writes last).

unicode (@unicodef1wn)’s 458K-view 11-step Obsidian-to-graph roadmap, and its sharpest line: “The pretty graph is for you. The index is for the model. Only one of them makes it faster.” The hoarder owns everything and finds nothing; the librarian hands you the right book in five seconds.

Retrieval here is logic, not model calls: strip the question to keywords → score nodes from the index alone (opening nothing) → open only the best match → read only the answering section → follow one edge if it points elsewhere → the model runs once, evidence in hand. Five of six steps cost zero tokens — the same traversal-over-guessing shape as this module’s GraphRAG lab, at markdown scale.