Self-Healing Knowledge Graphs: Graphs That Fix Themselves

Provenance is not truth. A triple can be perfectly traced to a published source and still be wrong — contradicted by a later signal, inconsistent with the schema, or hallucinated by the model that extracted it. The industry has spent years building better provenance; the harder problem is what to do when provenance says the fact is sourced but the fact is still garbage. The sharpest 2026 statement of this is TGComplete, which finds that most gold-correct edges have no supporting passage even under exhaustive retrieval — so textual verification measures provenance, not correctness (Kang et al., 2026, arXiv:2606.15833).

This is article #3 in the Autonomous Knowledge Graphs series, and it is a guardrail. Where #1 builds the curriculum concept graph and #2 reasons over it, this article keeps it accurate over time. Every design in the series obeys the same engineering constraints: a control plane built on LlamaIndex — DeepSeek as the LLM client, its PropertyGraphIndex for retrieval — with the autonomous loop itself written in plain Python rather than run by a workflow or graph-orchestration engine, over a Cloudflare D1 concept-graph data plane (concepts, concept_edges, lesson_concepts), with a thin TypeScript layer applying every write; DeepSeek-only model egress through one Cloudflare AI Gateway; a grounding-first record on every write — {confidence, reason, source, evidence} with bi-temporal valid_at/recorded_at stamps; and invalidate-not-delete at every irreversible step. This guardrail runs as a background repair sweep over the stored concept graph.

Loading diagram…

The Two Conflated Lineages

Most "error correction" systems are answer-side filters and graph-side verifiers, not graph repairers. KGHaluBench classifies model responses as aligned, hallucinated, or abstained by cross-checking against a static graph (Robertson et al., 2026, arXiv:2602.19643); FactCheck benchmarks LLMs for validating KG facts via internal knowledge, RAG evidence, and multi-model consensus (Shami et al., 2026, arXiv:2602.10748); and SHARP is a training-free agent that verifies triples with schema-aware planning plus external evidence — surfacing contradictions without itself rewriting the graph (Ma et al., 2026, arXiv:2604.04190). All three tell you a fact is wrong; none repairs the store, so the same wrong fact keeps triggering errors. On the other side are systems that actually modify the stored graph: Better Later Than Sooner applies a post-extraction stage that detects and repairs facts violating ontology or commonsense constraints (Loconte et al., 2026, arXiv:2605.29168). The distinction matters: detection and answer-side fixes are cheap but leave the store polluted; graph-side repair compounds its benefit over every future query. This design borrows SHARP-style detection but commits to an explicit, conservative repair step — invalidate the clear defects, quarantine the ambiguous ones.

Reference Architecture: Detect → Repair → Invalidate-or-Quarantine

The design anchors on a pure-Python repair sweep that walks the stored concept graph at configurable intervals, driven by the autonomous tick. Detect identifies candidate issues; Repair applies invalidation-first corrections; routing then decides whether each issue is invalidated outright or quarantined for a human. The load-bearing rule is conservatism: structural and ungrounded defects are invalidated automatically, but anything genuinely ambiguous — a real contradiction between two plausible edges — is quarantined rather than guessed, mirroring SHARP, where the agent surfaces a contradiction instead of silently rewriting the graph. There is no LLM in this loop; it reasons over the provenance the construct agent already recorded.

Detection Signals: Three Classes

Detection is deliberately bounded to 3 classes — unbounded anomaly detection drives false-positive rates high:

1. Prerequisite cycles — a prerequisite chain that loops back on itself (concept A is a prerequisite of B is a prerequisite of A). A depth-first search over the prerequisite edges finds the ring; a cycle means the curriculum has no valid learning order, so one edge has to go.
2. Contradictions — the same ordered concept pair carrying conflicting edge types: {builds_on, contrasts_with} or {prerequisite, contrasts_with}. The pass groups active edges by their (source, target) pair and flags any pair whose types cannot both hold — the same consistency instinct the multi-LLM consensus of Clinical KG construction applies at build time (Das et al., 2026, arXiv:2601.01844); this loop checks it post-hoc.
3. Low-provenance edges — active edges with no retrievable evidence span and a confidence below the 0.6 repair floor (REPAIR_FLOOR). This catches "out of thin air" edges the construct loop should have gated but didn't.

Repair: Invalidation Is Not Deletion

Every repair is invalidation-first: the offending edge is stamped with invalid_at (current timestamp), status set to invalidated, and a reason like self-heal: breaks prerequisite cycle. No destructive delete occurs — the edge stays in concept_edges but its provenance active flag is now false, so it is non-queryable by default and a later sweep or a human can reprieve it. Routing is by issue kind:

• Prerequisite cycle → invalidate the weakest edge in the ring — the one with the lowest provenance confidence. That restores a valid learning order while disturbing the least-supported claim.
• Low-provenance edge → invalidate it directly. An ungrounded, sub-0.6 edge has nothing to repair to.
• Contradiction → quarantine, not invalidate. Two conflicting edges can both be defensible (a concept that genuinely both builds_on and contrasts_with another), so the loop refuses to pick a winner and routes the pair to a human-review queue with full metadata.

There is no second LLM "verification judge" here. The construct loop already gated every edge on an evidence span at write time (article #1), and the discovery loop re-judges proposals at the 0.80 commit bar (article #5). Self-heal's job is narrower: remove structural and ungrounded defects deterministically, and escalate genuine ambiguity.

Invalidate or Quarantine — Never Guess

The routing maps onto the same tripartite outcome KGHaluBench uses (aligned / hallucinated / abstained):

• Repaired (invalidated) — a prerequisite cycle or an ungrounded low-provenance edge is a clear defect; the offending edge is invalidated automatically and the graph is left in a valid state.
• Kept — edges that pass all three detectors are left untouched; the sweep is conservative by construction and does not re-litigate well-grounded edges.
• Quarantined (abstain) — a contradiction the loop cannot resolve without judgment moves to a quarantine queue, metadata preserved for audit and surfaced to a data steward.

Abstention is the safety valve: when the right repair is genuinely ambiguous, the loop declines to act rather than risk entrenching a wrong edge.

Provenance ≠ Correctness

The corpus repeatedly shows provenance is necessary but insufficient. TGComplete makes the point quantitatively — verifiability tracks provenance, not truth — and argues for verify-or-abstain over recall-maximizing completion (Kang et al., 2026). SHARP's schema-aware planning reveals contradictions pure provenance tracking misses, and Better Later Than Sooner catches ontology violations after extraction. The design's separation of cheap, deterministic detection (cycles, conflicting edge types, the 0.6 provenance floor) from human-judged quarantine mirrors this: automate only the defects that are unambiguous, and abstain on the rest.

Failure Modes

1. Over-aggressive detection. A stylistic contrasts_with sitting next to a builds_on on the same pair can trip the contradiction detector, inflating the quarantine queue with edges a human will wave through.
2. Provenance floor too blunt. The 0.6 floor means an ungrounded edge at 0.59 is invalidated while one at 0.61 survives the sweep; the boundary is a tunable knob, not a learned threshold.
3. One-export lag. The sweep walks an in-memory snapshot exported from D1, so repairs trail the latest writes by one export cycle.
4. Cross-class gluing. A pair that is both inside a cycle and contradictory may have only one issue acted on, leaving the other for the next sweep.

These argue for monitoring, adjustable thresholds, and a human-review queue — repair counts, quarantine growth, and edge-type distribution come out of the tick's own self-log and coverage metrics, not an external tracing service.

Numbered Limitations

1. Detection scope. Only 3 classes are implemented; orphan concepts, stale edges, and cardinality limits are not repaired here (coverage() reports orphans, but the sweep does not act on them), and adding detectors increases latency.
2. Static threshold. The 0.6 provenance floor is fixed; per-edge-type dynamic thresholds are not implemented.
3. Snapshot lag. Detection and repair run over the exported snapshot, so very large graphs are swept from a point-in-time export rather than live D1 — repairs lag the latest writes by one export cycle.
4. Deterministic detectors. detect()/heal() use no LLM — they rely on the provenance the construct loop recorded, so a confidently-wrong edge with a plausible evidence span sails through and must be caught later by discovery's re-judge (article #5).
5. No temporal recovery. Invalidation stamps handle point-in-time corrections; an edge invalidated now but re-acquired later through another lesson may be duplicated.
6. Quarantine growth. Without an effective human-review feedback loop, quarantine accumulates; the design assumes a data steward works the queue.

Decision Table: Invalidate vs Quarantine vs Keep

Condition	Action	Why
Prerequisite cycle detected	Invalidate weakest edge in the ring	restores a valid learning order; disturbs the least-supported claim
Active edge, no evidence span, confidence < 0.6	Invalidate (low-provenance)	ungrounded and low-confidence — nothing to repair to
Same concept pair with conflicting edge types	Quarantine	both edges may be valid; refuse to guess, route to a human
Well-grounded edge passing all three detectors	Keep	a conservative sweep does not re-litigate sound edges

Invalidation is soft — invalid_at is stamped, never a hard delete — so every action is auditable and reversible. The loop has no delete path at all; quarantine holds the genuine contradictions a human must adjudicate.

Conclusion

Self-healing is not a one-time engineering feat but a commitment to continuous maintenance. The 2026 corpus — from SHARP's schema-aware verification to KGHaluBench's abstain framework and TGComplete's provenance-vs-truth result — points to a future where graphs are never fully clean but always getting cleaner. The measure of a healthy graph is not its initial quality but the rate at which it recovers from its own errors. The practical takeaway: invest in verification as heavily as in detection, make invalidation the default, and keep a human on the quarantine queue — the canary for systematic extraction failures no automated loop can yet correct.

Frequently Asked Questions

What is a self-healing knowledge graph? It runs a background loop that detects defects in the stored graph and fixes the graph itself — invalidating clear errors and quarantining the ambiguous ones — rather than only patching a downstream answer. The 2026 canonical scaffold is detect, repair, then inconsistency-tolerant reasoning.

Why is repairing the graph different from repairing the answer? Answer-side filters patch one response without touching the store, so the same wrong fact keeps triggering errors. Repairing the stored graph compounds its benefit across all future queries.

What does "provenance is not truth" mean for KG repair? A triple can be traced to a source and still be wrong. TGComplete shows most gold-correct edges have no supporting passage even under exhaustive retrieval, so textual verification measures provenance, not correctness — the safe response is verify-or-abstain.

Does the loop ever delete data? No. Every detected issue is handled by stamping invalid_at and setting status to invalidated, so the edge becomes non-queryable but stays in concept_edges for audit and possible reinstatement. The repair sweep has no hard-delete path.

How does the loop avoid making things worse? It only auto-acts on unambiguous defects — prerequisite cycles and ungrounded edges below the 0.6 provenance floor are invalidated, while genuine contradictions between two plausible edges are quarantined for a human rather than guessed. Invalidation is soft, so any wrong call is reversible on a later sweep.

Autonomous Knowledge Graphs — the series

1. Autonomous Knowledge Graph Construction: Graphs That Build Themselves (autonomy: high)
2. Reasoning Over the Graph: From GraphRAG to Planning Agents (autonomy: high)
3. Self-Healing Knowledge Graphs: Graphs That Fix Themselves (this article — guardrail)
4. The Graph as Agent Memory (autonomy: medium)
5. Closing the Loop: Evaluation, Debate, and Discovery (guardrail)

A companion thread to The Autonomous Sales Fleet. Next: #4 The Graph as Agent Memory.

References

• Yongqi Kang, Yu Fu, Yong Zhao. When Correct Edges Cannot Be Verified: A Provenance Gap in Incomplete KGQA and a Provenance-Favoring Completion Policy (TGComplete). 2026. arXiv:2606.15833. https://arxiv.org/abs/2606.15833
• Xinyan Ma et al. Schema-Aware Planning and Hybrid Knowledge Toolset for Reliable Knowledge Graph Triple Verification (SHARP). 2026. arXiv:2604.04190. https://arxiv.org/abs/2604.04190
• Lorenzo Loconte, Timothy Hospedales, Cristina Cornelio. Better Later Than Sooner: Neuro-Symbolic Knowledge Graph Construction via Ontology-grounded Post-extraction Correction. 2026. arXiv:2605.29168. https://arxiv.org/abs/2605.29168
• Alex Robertson et al. KGHaluBench: A Knowledge Graph-Based Hallucination Benchmark for Evaluating the Breadth and Depth of LLM Knowledge. 2026. arXiv:2602.19643. https://arxiv.org/abs/2602.19643
• Farzad Shami, Stefano Marchesin, Gianmaria Silvello. Benchmarking Large Language Models for Knowledge Graph Validation (FactCheck). 2026. arXiv:2602.10748. https://arxiv.org/abs/2602.10748
• Udiptaman Das, Krishnasai B. Atmakuri, Duy Ho, Chi Lee, Yugyung Lee. Clinical Knowledge Graph Construction and Evaluation with Multi-LLMs via Retrieval-Augmented Generation. 2026. arXiv:2601.01844. https://arxiv.org/abs/2601.01844