2026 07 20 hybrid agent memory symbolic connectionist synchronisation

Symbolic-connectionist synchronisation in hybrid agent memory

Research Question

How can hybrid agent-memory architectures keep structured symbolic knowledge bases synchronised with unstructured Large Language Model (LLM) and retrieval-layer memory so that updates remain consistent, queryable, and operationally affordable over time?

Scope

In scope:

Bridging mechanisms between unstructured traces or embeddings and structured semantic or procedural stores such as knowledge graphs, schemas, or typed observation graphs
Consistency-management patterns: extraction, entity resolution, conflict arbitration, temporal validity, provenance retention, and selective back-propagation into retrieval layers
Concrete systems that combine graph, vector, and memory layers, including graph-augmented Retrieval-Augmented Generation (RAG) and agent-memory products
Operational design choices for synchronisation cadence, event triggers, and partial versus full graph rebuilds
Trade-offs between formal schemas, emergent graph structure, and human-assisted review loops

Out of scope:

Building a domain ontology from scratch or deciding the best ontology vocabulary independent of runtime memory needs
Pure vector Retrieval-Augmented Generation systems with no symbolic layer
General privacy controls except where they directly constrain synchronisation architecture

Constraints: Prioritise architectures with explicit synchronisation or graph-update mechanics from 2024-2026. Use prior repository work on cross-session memory schema and knowledge linking as internal baselines rather than re-deriving those concepts from first principles.

Context

Prior research already established two halves of the problem: unstructured long-term memory needs curation and consolidation, while structured knowledge representations improve reuse, provenance, and cross-session retrieval. What remains unresolved is the bridge itself, meaning how to keep symbolic structures current without rebuilding everything, and how to stop the symbolic and neural sides of the memory system from drifting apart.

Approach

Map the main hybrid-memory patterns: graph plus vector Retrieval-Augmented Generation, observation graphs, temporal knowledge graphs, and schema-guided memory stores.
Identify how systems perform extraction and update: incremental writes, scheduled graph rebuilds, event-triggered entity updates, and human review checkpoints.
Examine consistency risks such as duplicate entities, stale symbolic facts, conflicting timestamps, and divergence between embedding recall and graph truth.
Compare strong-schema versus emergent-schema approaches, including where each needs human curation to remain stable.
Produce design guidance for keeping symbolic and connectionist memory layers aligned after consolidation has produced candidate semantic knowledge.

Sources

Research Skill Output

(Full output from running the research skill. Sections 0 to 5 are the investigation; section 6 seeds the Findings section below.)

Constraint mode: full. External web tools (search and page fetch) were available and used to consult every seeded source.

§0 Initialise

Question: How can hybrid agent-memory architectures keep structured symbolic knowledge bases (for example knowledge graphs) synchronised with unstructured Large Language Model (LLM) and retrieval-layer memory so that updates remain consistent, queryable, and operationally affordable over time?

Scope: bridging mechanisms between unstructured traces or embeddings and structured stores; consistency management (extraction, entity resolution, conflict arbitration, temporal validity, provenance, selective back-propagation); concrete graph-plus-vector systems; synchronisation cadence and partial versus full rebuilds; strong-schema versus emergent-schema trade-offs.

Definitions bound at first use: Knowledge Graph (KG) means a structured model of entities and typed relations between them, defined by the World Wide Web Consortium (W3C) Resource Description Framework (RDF) data model at https://www.w3.org/TR/rdf11-concepts/. Retrieval-Augmented Generation (RAG) means supplying an LLM with externally retrieved context at inference time, defined in the original RAG paper at https://arxiv.org/abs/2005.11401. Model Context Protocol (MCP) is an open protocol for connecting agents to external context servers, documented at https://modelcontextprotocol.io/.

Prior-art scan (Research/completed): four completed items directly qualify this question. The TBox (Terminological Box, a predefined schema) and ABox (Assertion Box, instance-level facts) item settles the strong-schema versus emergent-schema trade-off. The truth-maintenance item settles how contradictions are resolved. The consolidation item settles what triggers a write and how provenance is preserved. The MCP schema item settles duplicate-entity and naming discipline. This item builds the synchronisation bridge on top of those four, rather than re-deriving them.

Output format: full structured synthesis written into Findings.

§1 Question Decomposition

Q1: What distinct hybrid-memory patterns combine a symbolic store with an unstructured or vector retrieval layer? (atomic)
Q2: How does each system write and update the symbolic layer: incremental write, scheduled rebuild, event-triggered update, or human review? (atomic)
Q3: How does each system stop the symbolic view and the retrieval view from diverging over time? (atomic)
Q4: How are the specific consistency risks handled: duplicate entities, stale facts, conflicting timestamps? (atomic)
Q5: What does the strong-schema versus emergent-schema evidence say about synchronisation stability? (resolved by prior TBox and ABox item; atomic here)
Q6: What is the cost profile of each synchronisation cadence, and when is a full rebuild unavoidable? (atomic)
Q7: What design guidance keeps symbolic and connectionist layers aligned after consolidation has produced candidate semantic knowledge? (synthesises Q1 to Q6)

§2 Investigation

Q1 hybrid-memory patterns. [fact] Microsoft GraphRAG extracts entities, relationships, and claims from text units, performs hierarchical Leiden community detection, and generates bottom-up community summaries; at query time it serves global search over community summaries, local search over entity neighbourhoods, Dynamic Reasoning and Inference with Flexible Traversal (DRIFT) search, and basic vector search. (source: https://microsoft.github.io/graphrag/; https://arxiv.org/abs/2404.16130) [fact] Zep is a memory-layer service powered by Graphiti, a temporally-aware knowledge graph engine that ingests unstructured message data and structured business data and updates the graph in a non-lossy manner, maintaining a timeline of facts and their periods of validity. (source: https://arxiv.org/abs/2501.13956) [fact] Mem0 provides multi-level memory (user, session, agent) and ships a graph variant, referred to as Mem0g, that extracts and links entities into relationships in addition to text memories. (source: https://github.com/mem0ai/mem0; https://arxiv.org/abs/2504.19413) [inference] These three systems represent three points on one spectrum: an emergent-community graph over a document corpus (GraphRAG), a temporal fact graph over a conversation and business stream (Zep), and an accumulating entity-linked memory store over agent interactions (Mem0). (source: https://arxiv.org/abs/2404.16130; https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413)

Q2 write and update mechanics. [fact] Graphiti updates the graph as new information arrives and, when a new fact contradicts an existing edge, stamps the old edge with an invalidation time rather than deleting it, using a bi-temporal model that separates when a fact was recorded by the system from when it was true in the world. (source: https://arxiv.org/abs/2501.13956) [fact] Mem0's April 2026 algorithm uses single-pass ADD-only extraction in which memories accumulate and nothing is overwritten, with entity linking across memories and multi-signal retrieval that fuses semantic, Best-Matching-25 (BM25) lexical, and entity-match scores. (source: https://github.com/mem0ai/mem0; https://mem0.ai/research) [fact] Microsoft GraphRAG exposes incremental indexing through standard-update and fast-update methods in its command line interface, distinct from the standard full-build method. (source: https://microsoft.github.io/graphrag/cli/) [inference] Incremental GraphRAG updates detect changed documents by content hashing and update only the affected entities, relationships, and communities, reusing cached extraction output for unchanged text. (source: https://microsoft.github.io/graphrag/cli/; https://deepwiki.com/microsoft/graphrag/4.7-incremental-indexing-and-updates) [inference] Human review is present as a consolidation-time verification step in the prior corpus rather than as a graph-synchronisation primitive in these three systems: the consolidation item found that GitHub Copilot re-verifies extracted facts against source code at read time, but none of GraphRAG, Zep, or Mem0 documents a mandatory human approval gate before a graph write. (source: https://davidamitchell.github.io/Research/research/2026-07-20-agent-memory-consolidation-episodic-semantic.html; https://arxiv.org/abs/2501.13956)

Q3 preventing divergence. [fact] Graphiti's retrieval combines vector similarity, full-text search, and graph traversal over the same temporal graph, so the retrieval index and the symbolic store are one artifact. (source: https://arxiv.org/abs/2501.13956) [fact] Mem0's retrieval fuses semantic embedding, BM25 lexical, and entity-match signals scored in parallel against one accumulating store rather than against two separately-maintained indexes. (source: https://mem0.ai/research; https://arxiv.org/abs/2504.19413) [inference] Divergence between embedding recall and graph truth is avoided by co-locating the retrieval index over the symbolic store, so a write updates both views at once, rather than maintaining a vector index and a graph that are refreshed on independent schedules. (source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research)

Q4 specific consistency risks. [fact] Graphiti deduplicates entities and edges using hybrid search during ingestion, and its bi-temporal timestamps (created_at, valid_at, invalid_at, expired_at) let it store the point at which a fact became true and the point at which it stopped being true. (source: https://arxiv.org/abs/2501.13956) [fact] Mem0's results-generation prompt instructs the model to prioritise the most recent memory when memories contain contradictory information and to convert relative time references to absolute dates. (source: https://arxiv.org/abs/2504.19413) [inference] Stale symbolic facts are handled by temporal invalidation rather than deletion, and conflicting timestamps are handled by the bi-temporal separation of system time from valid time, which the prior truth-maintenance item corroborates as necessary because a policy that treats every contradiction as a binary conflict mishandles facts that are simply superseded by time. (source: https://arxiv.org/abs/2501.13956; https://davidamitchell.github.io/Research/research/2026-07-20-autonomous-knowledge-curation-truth-maintenance.html) [inference] Duplicate entities and schema drift are the dominant failure modes for an LLM-managed graph, and the prior MCP schema item found these are better mitigated by canonical naming and a fixed relation vocabulary than by additional schema complexity, which aligns with Graphiti's ingestion-time deduplication and Mem0's cross-memory entity linking. (source: https://davidamitchell.github.io/Research/research/2026-05-02-knowledge-graph-schema-cross-session-research-mcp.html; https://arxiv.org/abs/2501.13956; https://github.com/mem0ai/mem0)

Q5 strong-schema versus emergent-schema (settled by prior item). [inference] The prior TBox and ABox item found that the largest combined accuracy and efficiency gains come from a hybrid seed-schema design that predefines core entity and relation types while expanding them as new domains appear, rather than from a fully rigid ontology or a fully schema-free design; this is the schema stance a synchronisation layer should adopt so that incremental writes have stable type anchors. (source: https://davidamitchell.github.io/Research/research/2026-07-20-tbox-abox-graphrag.html)

Q6 cost profile and unavoidable rebuilds. [fact] GraphRAG's full-build method re-extracts entities, relationships, communities, and embeddings for the entire corpus, whereas the update methods process only changed content. (source: https://microsoft.github.io/graphrag/cli/) [inference] Full GraphRAG reindexing cost scales with total corpus size rather than change size, so routine ingest is affordable only through incremental update, and a full rebuild becomes unavoidable when the schema or model configuration changes. (source: https://microsoft.github.io/graphrag/cli/; https://deepwiki.com/microsoft/graphrag/4.7-incremental-indexing-and-updates) [fact] Zep and Mem0 both report large latency and token reductions relative to full-context baselines, which is the operational payoff of not re-sending or re-embedding the whole history on each query. (source: https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413)

Q6 reported benchmark numbers. [fact] Zep reports 94.8% accuracy on the Deep Memory Retrieval (DMR) task versus MemGPT's 93.4%, and on LongMemEval reports up to 18.5% higher accuracy with up to 90% lower response latency than a baseline that places the full history in context. (source: https://arxiv.org/abs/2501.13956) [fact] Mem0 reports a 26% relative improvement over OpenAI's memory feature on an LLM-as-a-Judge metric, roughly 91% lower 95th-percentile (p95) latency, and more than 90% token savings versus a full-context approach, with the graph variant adding about 2 percentage points over the text-only variant. (source: https://arxiv.org/abs/2504.19413; https://mem0.ai/research) Access note: DMR and LongMemEval figures, vendor-authored, single-source; no independent replication located this session.

Q7 integration framing. [fact] Pan et al. (2024) organise LLM and KG integration into three frameworks: KG-enhanced LLMs, LLM-augmented KGs, and synergized LLMs plus KGs in which both play equal roles and reason bidirectionally. (source: https://arxiv.org/abs/2306.08302) [inference] Runtime synchronisation is the operational face of the synergized framework: the LLM writes and updates the KG (LLM-augmented KG) while the KG grounds retrieval and reduces hallucination (KG-enhanced LLM), and keeping the two in step is what makes the bidirectional loop coherent over time. (source: https://arxiv.org/abs/2306.08302)

§3 Reasoning

[fact] Every surveyed production system writes into the symbolic store incrementally and event-triggered on new input, not on a fixed schedule. (source: https://arxiv.org/abs/2501.13956; https://github.com/mem0ai/mem0; https://microsoft.github.io/graphrag/cli/)
[inference] Because a full rebuild costs proportional to corpus size, incremental update is the only affordable steady-state cadence, and full rebuild is reserved for schema or model change. (source: https://microsoft.github.io/graphrag/cli/)
[inference] Because superseded facts must remain queryable for temporal reasoning, invalidation-with-timestamps beats deletion, and this is what keeps the symbolic store consistent without losing history. (source: https://arxiv.org/abs/2501.13956; https://davidamitchell.github.io/Research/research/2026-07-20-autonomous-knowledge-curation-truth-maintenance.html)
[inference] Because two independently-refreshed indexes drift, co-locating the retrieval index over the symbolic store removes the drift by construction. (source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research)
[inference] Because incremental writes need stable type anchors, a hybrid seed schema is the schema stance that makes synchronisation stable. (source: https://davidamitchell.github.io/Research/research/2026-07-20-tbox-abox-graphrag.html)

§4 Consistency Check

contradiction_scan: resolved
mem0_add_only_vs_zep_invalidation: reconciled, two designs for staleness (accumulate-and-rank versus invalidate-with-timestamp), both avoid destructive overwrite
benchmark_confidence: vendor-authored single sources held at medium
cross_item_alignment: consistent with tbox-abox, truth-maintenance, consolidation, evaluation-framework, mcp-schema items
scope_guardrail: maintained, no ontology-authoring or pure-vector-RAG claims introduced
acronym_audit: LLM, RAG, KG, MCP, DMR, BM25, W3C, RDF, p95, DRIFT, TMS expanded on first prose use

§5 Depth and Breadth Expansion

Technical lens. [inference] The strongest technical pattern is a single store that carries typed edges plus embeddings plus temporal metadata, queried by a fusion of graph traversal, lexical match, and vector similarity, so that one write keeps both the symbolic and connectionist views current. (source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research) [inference] The weakest technical link is entity resolution: an incorrect merge or a missed duplicate at write time propagates into both views simultaneously, which the prior MCP schema item flags as the dominant failure mode. (source: https://davidamitchell.github.io/Research/research/2026-05-02-knowledge-graph-schema-cross-session-research-mcp.html)

Economic lens. [inference] Synchronisation cadence is primarily a cost decision: incremental update keeps steady-state ingest affordable, and a full rebuild is a periodic capital cost triggered by schema change rather than a routine operation. (source: https://microsoft.github.io/graphrag/cli/) [inference] The token and latency reductions Zep and Mem0 report are the economic argument for maintaining a structured memory at all, since re-sending the full history per query is the baseline these systems beat. (source: https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413)

Historical lens. [inference] The classical answer to synchronised belief is a formal Truth Maintenance System (TMS), but the prior truth-maintenance item found no production LLM-KG agent implements one; current systems substitute narrower purpose-built stages, which is exactly what Zep's edge invalidation and Mem0's recency-priority resolution are. (source: https://davidamitchell.github.io/Research/research/2026-07-20-autonomous-knowledge-curation-truth-maintenance.html; https://arxiv.org/abs/2501.13956)

Behavioural lens. [inference] Provenance retention changes operator trust: a system that invalidates rather than deletes lets a human audit why the current graph state differs from a past state, whereas an ADD-only accumulate-and-rank design keeps every version but shifts the burden of choosing the right one onto retrieval-time ranking. (source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research)

§6 Synthesis

(This section seeds the Findings below.)

Executive summary: Production hybrid agent-memory systems keep the symbolic knowledge graph and the unstructured retrieval layer synchronised by making incremental, event-triggered writes into a single non-lossy store and indexing the retrieval layer directly over that store, so a write updates both views at once. [inference; source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research] Superseded facts are invalidated with bi-temporal timestamps rather than deleted, keeping the graph current while preserving history. [fact; source: https://arxiv.org/abs/2501.13956] Full graph rebuilds are reserved for schema or model changes because their cost scales with corpus size. [inference; source: https://microsoft.github.io/graphrag/cli/] Contradiction handling is a purpose-built detect-then-resolve or recency-priority stage rather than a formal Truth Maintenance System. [inference; source: https://davidamitchell.github.io/Research/research/2026-07-20-autonomous-knowledge-curation-truth-maintenance.html; https://arxiv.org/abs/2501.13956]

Key findings: see numbered list in Findings.

Evidence map: see table in Findings.

Assumptions: Vendor-authored benchmark numbers are treated as directional evidence rather than independently replicated fact. [assumption; source: https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413] The four prior completed items are treated as settled internal baselines. [assumption; source: https://davidamitchell.github.io/Research/research/2026-07-20-tbox-abox-graphrag.html; https://davidamitchell.github.io/Research/research/2026-05-02-knowledge-graph-schema-cross-session-research-mcp.html]

Analysis: Zep's invalidate-with-timestamp design and Mem0's accumulate-and-rank design reach the same non-destructive goal by different routes. [inference; source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research] GraphRAG's split between full-build and update methods exposes the cost boundary that forces incremental update over full rebuild. [inference; source: https://microsoft.github.io/graphrag/cli/] A prior evaluation-framework item finds the vendor benchmarks these systems report do not establish a shared industry standard and do not test provenance or scoping, which supports holding their confidence at medium. [inference; source: https://davidamitchell.github.io/Research/research/2026-07-20-agent-memory-evaluation-framework.html]

Risks, gaps, uncertainties: The Zep and Mem0 benchmark numbers are vendor-authored and were not independently replicated in the sources located this session. [assumption; source: https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413] No located source measures long-run drift between the symbolic and retrieval views directly. [inference; source: https://arxiv.org/abs/2501.13956] Human review before a graph write is under-documented in these systems. [inference; source: https://microsoft.github.io/graphrag/cli/; https://davidamitchell.github.io/Research/research/2026-07-20-agent-memory-consolidation-episodic-semantic.html]

Open questions: How to measure symbolic-connectionist drift directly, and whether ADD-only accumulation or invalidate-with-timestamp scales better past tens of millions of facts.

§7 Recursive Review

review_result: pass
acronym_audit: passed, includes DRIFT and TMS
claim_label_audit: passed, every §2 to §6 claim carries fact, inference, or assumption
source_binding: passed, every fact and inference carries a URL
parity_check: passed, §6 mirrors Findings
em_dash_scan: passed, none present

Findings

(Populated from §6 Synthesis above.)

Executive Summary

Production hybrid agent-memory systems keep the symbolic knowledge graph and the unstructured retrieval layer synchronised by making incremental, event-triggered writes into a single non-lossy store and indexing the retrieval layer directly over that store, so a write updates both views at once, which is the mechanism these systems rely on to keep the two views aligned. [inference; source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research] Superseded facts are invalidated with bi-temporal timestamps rather than deleted, which keeps the graph current while preserving history for point-in-time queries. [fact; source: https://arxiv.org/abs/2501.13956] Full graph rebuilds are reserved for schema or model changes because their cost scales with corpus size, so incremental update is the only affordable steady-state cadence. [inference; source: https://microsoft.github.io/graphrag/cli/] Contradiction handling in these systems is a purpose-built detect-then-resolve or recency-priority stage rather than a formal truth-maintenance system, consistent with prior repository work finding no production agent implements classical dependency-directed belief revision. [inference; source: https://davidamitchell.github.io/Research/research/2026-07-20-autonomous-knowledge-curation-truth-maintenance.html; https://arxiv.org/abs/2501.13956]

Key Findings

Zep's Graphiti engine keeps symbolic facts current with a bi-temporal model that stores when a fact entered the system and when it was true in the world, and when a new fact contradicts an existing edge it stamps that edge invalid instead of deleting it, preserving history while retrieval returns only currently-valid facts. ([fact]; medium confidence; source: https://arxiv.org/abs/2501.13956)
Zep reports 94.8% accuracy on the Deep Memory Retrieval (DMR) task against MemGPT's 93.4%, and on the LongMemEval benchmark reports up to 18.5% higher accuracy with up to 90% lower response latency than a baseline that loads the full history into context. ([fact]; medium confidence; source: https://arxiv.org/abs/2501.13956)
Mem0's April 2026 algorithm writes with single-pass ADD-only extraction so memories accumulate without overwrite, links entities across memories, and retrieves by fusing semantic embedding, Best-Matching-25 (BM25) lexical, and entity-match scores against one accumulating store rather than two separate indexes. ([fact]; medium confidence; source: https://github.com/mem0ai/mem0; https://mem0.ai/research)
Mem0's graph variant, Mem0g, adds explicit extracted entity relationships on top of the text memory and improves the overall benchmark score by roughly 2 percentage points over the text-only variant, evidence that a symbolic relation layer adds a measurable but modest gain above vector recall alone. ([inference]; medium confidence; source: https://arxiv.org/abs/2504.19413)
Mem0 reports a 26% relative improvement over OpenAI's memory feature on an LLM-as-a-Judge metric, roughly 91% lower p95 latency, and more than 90% token savings versus a full-context approach, which is the operational payoff of maintaining a structured memory rather than re-sending the whole history each query. ([fact]; medium confidence; source: https://arxiv.org/abs/2504.19413; https://mem0.ai/research)
Microsoft GraphRAG builds its symbolic layer by having a Large Language Model (LLM) extract entities, relationships, and claims, then applies hierarchical Leiden community detection and bottom-up community summarisation, and serves the same graph and embeddings through global, local, DRIFT, and basic search modes. ([fact]; medium confidence; source: https://microsoft.github.io/graphrag/; https://arxiv.org/abs/2404.16130)
GraphRAG synchronises without a full rebuild through standard-update and fast-update incremental indexing methods exposed in its command line interface, which process only changed content instead of re-extracting the entire corpus. ([fact]; medium confidence; source: https://microsoft.github.io/graphrag/cli/)
Full GraphRAG reindexing cost scales with total corpus size rather than with the size of the change, and a schema or model change forces a full rebuild, so synchronisation cadence is an operational-cost decision that favours incremental update for routine ingest and full rebuild only on schema change. ([inference]; medium confidence; source: https://microsoft.github.io/graphrag/cli/; https://davidamitchell.github.io/Research/research/2026-07-20-tbox-abox-graphrag.html)
Pan et al. (2024) frame symbolic-connectionist integration as three designs, KG-enhanced Large Language Models, Large-Language-Model-augmented knowledge graphs, and a synergized bidirectional design, and runtime synchronisation is the operational realisation of the synergized design in which the model updates the graph while the graph grounds retrieval. ([inference]; medium confidence; source: https://arxiv.org/abs/2306.08302)
These systems are designed to limit divergence between embedding recall and graph truth by co-locating the retrieval index over the symbolic store, so Graphiti searches vector, full-text, and graph traversal over one temporal graph and Mem0 fuses entity and vector signals over one accumulating store rather than refreshing two indexes on independent schedules. ([inference]; medium confidence; source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research)
Duplicate entities and stale facts are handled at write time through ingestion-time deduplication and entity linking plus temporal invalidation, which aligns with the prior repository finding that duplicate-entity alignment, schema drift, and provenance loss are the dominant failure modes and are better mitigated by naming and vocabulary discipline than by added schema complexity. ([inference]; medium confidence; source: https://arxiv.org/abs/2501.13956; https://github.com/mem0ai/mem0; https://davidamitchell.github.io/Research/research/2026-05-02-knowledge-graph-schema-cross-session-research-mcp.html)
No surveyed production system runs a formal Truth Maintenance System; contradiction handling is a purpose-built stage in which Mem0 prioritises the most recent memory and Zep invalidates superseded edges, consistent with the prior repository finding that autonomous curation substitutes narrow pipeline stages for dependency-directed justification tracking. ([inference]; medium confidence; source: https://davidamitchell.github.io/Research/research/2026-07-20-autonomous-knowledge-curation-truth-maintenance.html; https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413)

Evidence Map

Claim	Source	Confidence	Notes
[fact] Graphiti uses a bi-temporal model and invalidates superseded edges rather than deleting them	https://arxiv.org/abs/2501.13956	medium	vendor-authored primary paper
[fact] Zep reports 94.8% DMR versus MemGPT 93.4%, and up to 18.5% higher LongMemEval accuracy with up to 90% lower latency	https://arxiv.org/abs/2501.13956	medium	single vendor-authored source, no independent replication located
[fact] Mem0 uses ADD-only extraction, entity linking, and fused semantic, BM25, and entity retrieval	https://github.com/mem0ai/mem0; https://mem0.ai/research	medium	vendor repository and research page
[inference] Mem0g graph variant adds about 2 points over text-only	https://arxiv.org/abs/2504.19413	medium	primary paper, modest single-source effect
[fact] Mem0 reports 26% over OpenAI, ~91% lower p95 latency, >90% token savings	https://arxiv.org/abs/2504.19413; https://mem0.ai/research	medium	vendor-authored
[fact] GraphRAG extraction, Leiden communities, community summaries, four query modes	https://microsoft.github.io/graphrag/; https://arxiv.org/abs/2404.16130	medium	official docs plus primary paper
[fact] GraphRAG offers standard-update and fast-update incremental indexing	https://microsoft.github.io/graphrag/cli/	medium	official CLI reference
[inference] Full reindex cost scales with corpus size; schema change forces full rebuild	https://microsoft.github.io/graphrag/cli/; https://davidamitchell.github.io/Research/research/2026-07-20-tbox-abox-graphrag.html	medium	docs plus prior item
[inference] Synchronisation realises Pan et al. synergized framework	https://arxiv.org/abs/2306.08302	medium	primary survey
[inference] Co-located retrieval index over the symbolic store is designed to limit drift	https://arxiv.org/abs/2501.13956; https://mem0.ai/research	medium	two vendor primaries, same evidence family per system
[inference] Write-time dedup and linking mitigate duplicate/stale entities	https://arxiv.org/abs/2501.13956; https://github.com/mem0ai/mem0; https://davidamitchell.github.io/Research/research/2026-05-02-knowledge-graph-schema-cross-session-research-mcp.html	medium	vendor primaries plus prior item
[inference] No production Truth Maintenance System; purpose-built resolution substitutes	https://davidamitchell.github.io/Research/research/2026-07-20-autonomous-knowledge-curation-truth-maintenance.html; https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413	medium	prior item plus two primaries
[inference] Vendor recall benchmarks do not establish a shared standard and do not test provenance or scoping, supporting medium confidence	https://davidamitchell.github.io/Research/research/2026-07-20-agent-memory-evaluation-framework.html	medium	prior evaluation-framework item

Assumptions

Vendor-authored benchmark numbers from Zep and Mem0 are treated as directional evidence rather than independently replicated fact, justified because no independent replication of the DMR or LongMemEval results was located in this session. [assumption; source: https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413] The four prior completed repository items on TBox and ABox trade-offs, truth maintenance, consolidation, and MCP schema discipline are treated as settled internal baselines, justified because each was reviewed and completed under the same corpus quality gate. [assumption; source: https://davidamitchell.github.io/Research/research/2026-07-20-tbox-abox-graphrag.html; https://davidamitchell.github.io/Research/research/2026-05-02-knowledge-graph-schema-cross-session-research-mcp.html]

Analysis

The evidence points to one conclusion, that the systems reporting the strongest synchronisation behaviour are the ones that refuse to maintain two independently-updated stores. [inference; source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research] Zep and Mem0 reach the same non-destructive goal by different routes, since Zep invalidates superseded edges with timestamps while Mem0 accumulates every memory and defers the choice to retrieval-time ranking, and neither route destructively overwrites prior state. [inference; source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research] GraphRAG's split between full-build and update methods exposes the cost boundary that makes incremental update the default and full rebuild an exception triggered by schema change. [inference; source: https://microsoft.github.io/graphrag/cli/] A plausible competing interpretation is that the symbolic layer is unnecessary because a large enough context window or a pure vector index would suffice, but the reported token and latency reductions against full-context baselines and the roughly 2-point Mem0g gain over text-only argue that the structured layer earns its place, though the margin is modest and vendor-reported. [inference; source: https://arxiv.org/abs/2504.19413; https://arxiv.org/abs/2501.13956] A second competing interpretation is that a formal truth-maintenance system would synchronise better than these ad-hoc stages, but the prior repository item found no production agent implements one, so the purpose-built stage is the current state of practice rather than a chosen optimum. [inference; source: https://davidamitchell.github.io/Research/research/2026-07-20-autonomous-knowledge-curation-truth-maintenance.html] A prior evaluation-framework item sharpens the confidence calibration for the Zep and Mem0 numbers, finding that LongMemEval and LoCoMo provide useful recall benchmarks but do not establish a shared industry standard and do not test governance, provenance, or scoping correctness, which is a more specific reason than vendor authorship alone to keep those benchmark-derived findings at medium confidence. [inference; source: https://davidamitchell.github.io/Research/research/2026-07-20-agent-memory-evaluation-framework.html]

Risks, Gaps, and Uncertainties

The headline Zep and Mem0 benchmark numbers are vendor-authored and were not independently replicated in the sources located this session, so their confidence is held at medium. [assumption; source: https://arxiv.org/abs/2501.13956; https://arxiv.org/abs/2504.19413] A prior repository evaluation-framework item independently finds that the LongMemEval and LoCoMo benchmarks these systems report against do not establish a shared industry standard and do not test governance, provenance, or scoping correctness, which limits how far the reported scores generalise beyond recall. [inference; source: https://davidamitchell.github.io/Research/research/2026-07-20-agent-memory-evaluation-framework.html] No source located in this investigation measures long-run divergence between the symbolic view and the retrieval view directly, so the drift-prevention claim rests on architectural reasoning rather than a longitudinal measurement. [inference; source: https://arxiv.org/abs/2501.13956] Human-in-the-loop gating before a graph write is under-documented in GraphRAG, Zep, and Mem0, so the role of human review in synchronisation remains an evidence gap. [inference; source: https://microsoft.github.io/graphrag/cli/; https://davidamitchell.github.io/Research/research/2026-07-20-agent-memory-consolidation-episodic-semantic.html]

Open Questions

How can symbolic-connectionist drift be measured directly rather than inferred from architecture, for example by comparing graph-truth answers against embedding-recall answers over a fixed query set as a corpus evolves? Whether ADD-only accumulation or invalidate-with-timestamp scales better past tens of millions of facts, given that accumulation grows the store monotonically while invalidation grows the number of expired edges. Whether a lightweight human approval gate on high-impact graph writes improves downstream accuracy enough to justify its latency cost.

Output

Type: knowledge
Description: A synthesis of how production hybrid agent-memory systems keep a symbolic knowledge graph synchronised with an unstructured retrieval layer, concluding that incremental event-triggered writes into a single non-lossy store, bi-temporal invalidation, and a co-located retrieval index are the load-bearing mechanisms. [inference; source: https://arxiv.org/abs/2501.13956; https://mem0.ai/research; https://microsoft.github.io/graphrag/cli/]
Links: