Sheaf-Guarded Updates: Streaming Structural Verification for Evolving Agent State

Jason Leonard VolkAI4Math @ ICML 2026 · OpenReview

TL;DR

This paper introduces a high-performance topological substrate that verifies the internal consistency of self-evolving AI agents in real-time. By modeling agent knowledge as a "cellular sheaf" on a graph, the system uses cohomological signals to detect contradictions with microsecond latency, scaling to millions of nodes on a single machine.

What Problem Does This Paper Address?

As AI agents move from simple chat interfaces to "self-evolving" systems—generating their own hypotheses, proofs, and long-term memories—they face a "state maintenance" crisis. Every time an agent adds a new claim or dependency to its internal knowledge base, it risks introducing a global inconsistency.

Current neural generators (like LLMs) are excellent at proposing content but terrible at certifying that this content is compatible with everything else they "know." Traditional formal verification is often too slow or too rigid for a rapidly growing, mutable graph of ideas. The authors identify a critical gap: we need a way to verify the structural coherence of an agent's state at "update-time" without re-checking the entire system from scratch.

Methods

The authors turn to Sheaf Theory, a branch of mathematics that deals with how local data fits together into a global whole.

  1. The Agent-State Model: They represent the agent's knowledge as a growing graph where vertices are claims and edges are relations. Each vertex has a "stalk" (a vector space of data), and edges have "restriction maps" (linear constraints).
  2. The Verification Signals: To catch contradictions, they monitor:
  3. Coboundary checks: Measuring how much local data "disagrees" across an edge.
  4. $H^1$ Obstruction: A topological signal that identifies cycles in the graph where the logic doesn't "close" correctly.
  5. Laplacian Spectra: Using the eigenvalues of the sheaf Laplacian to monitor the overall stability and "pressure" of the system.
  6. The "Purity Gate" & "Governor": These are architectural constraints. The Purity Gate ensures all new information is "contractive" (it doesn't amplify error), while a closed-loop Governor triggers "vertex expansion"—forcing the agent to break complex, high-pressure claims into simpler, verifiable sub-steps.
  7. Cellular Decomposition: To make this fast, they use a "Mayer-Vietoris" assembly. Instead of solving the whole graph, they break it into small cells. Updates only recompute the affected cell, leading to $O(1)$ amortized cost regardless of total graph size.

Datasets

The paper evaluates the system across three distinct regimes:

  • ProofDAG: A newly introduced synthetic benchmark for proof-dependency coherence. It allows for controlled injection of "contradictions" (circular logic, type mismatches) to test detection accuracy.
  • Lean/mathlib Subset: 507 declarations and 954 kernel-certified edges from the real-world Lean mathematical library. This tests the system against "exact" formal logic.
  • 990-Lemma LLM Study: A dataset of valid generalizations vs. "plausible-sounding" but invalid condition-dropping statements generated by a frontier LLM.

Key Insights and Ideas

  • "Neural Proposes, Sheaf Verifies": The authors argue for a clean separation of concerns. Let the LLM be the creative engine, but use a deterministic, topological substrate as the "safety gate" that decides whether to commit an update.
  • Structural Aliasing: One of the most striking findings is that natural language is often too "coarse" for autonomous verification. In the 990-lemma study, valid and invalid claims often looked identical to the loader (aliasing), meaning the bottleneck for AI safety isn't the math—it's the "fidelity" of how we translate language into structure.
  • Stability by Construction: By using Lyapunov stability theory, the authors prove that their "Governor" mechanism keeps the graph's density and spectral gap within safe bounds, preventing the agent's state from "exploding" or becoming a tangled mess as it grows.

Key Results

  • Exact Detection: On formal math (Lean) and synthetic tests (ProofDAG), the system achieved an F1 score of 1.000, catching 100% of injected contradictions with zero false positives.
  • Hallucination Audit: In a live test, the system detected 100% of 732 hallucinated dependencies proposed by an LLM.
  • Massive Scale: The system maintained a graph of 5 million vertices on a single commodity machine with a median per-edit latency of just 35 microseconds.
  • Noise Resilience: Even when 14% noise was added to the data, the system maintained an F1 score above 0.94.

Limitations and Future Work

  • The "Loader" Bottleneck: The system is "loader-agnostic," meaning it's only as good as the front-end that translates text into sheaf data. Current natural language loaders are the weak link, often failing to capture the nuance required for perfect verification.
  • Semantic vs. Structural Truth: The substrate checks if things are consistent, not necessarily if they are "true" in a vacuum. A perfectly consistent lie would still pass the gate.
  • Deletions: While the streaming infrastructure handles deletions and retractions, the formal stability proofs in this paper focus primarily on the growth (addition) of the graph. Extending these proofs to "shrinking" graphs is a noted area for future work.

Summary updated

Abstract

Self-evolving scientific agents need update-time verification: does the agent's internal state remain coherent after a local self-modification? We model agent state as a growing graph equipped with a cellular sheaf and use coboundary checks, H1H^1 H1 obstruction, Dirichlet energy, and Laplacian spectra to detect represented structural contradictions before commit. Under explicit policy and regularity assumptions, we prove conditional Lyapunov stability results for density and spectral-gap dynamics. A cellular decomposition localizes cohomological recomputation to O(1)O(1) O(1) amortized per-edit cost under bounded-cell and cached-assembly assumptions, enabling maintenance at V=5V{=}5 V=5M vertices with 35 μ35\;\mu 35μs median per-edit latency and zero assembled-cohomology drift on a single commodity machine. On ProofDAG, a controlled proof-dependency coherence test, per-edge coboundary testing achieves exact separation (F1=1.000\textrm{F1} = 1.000 F1=1.000) under exact representation and F1≥0.94\textrm{F1} \geq 0.94 F1≥0.94 under 14%14\% 14% relative noise. A 990-lemma study with live LLM proposals across 10 mathematical domains shows that coarse natural-language loading causes structural aliasing: valid and contradictory coboundary distributions overlap, identifying loader fidelity as the binding constraint for autonomous commit decisions. A Lean/mathlib benchmark confirms the exact-loader path on 507 declarations and 954 kernel-certified dependency edges across 6 namespace groups, with zero clean residuals (max 2.61×10−162.61 \times 10^{-16} 2.61×10−16) and all 62 controlled corruptions detected. We present an implemented demonstration of bounded-cell sheaf-cohomological verification under streaming graph mutations at multi-million-vertex scale.
BibTeX
@inproceedings{volk2026sheaf,
  author = {Jason Leonard Volk},
  title = {{Sheaf-Guarded Updates: Streaming Structural Verification for Evolving Agent State}},
  booktitle = {AI4Math @ ICML},
  year = {2026},
  url = {https://openreview.net/forum?id=6NkQDugCm7},
}

Loading related content...

Figure