Sheaf Theory for Multi-Agent Systems

1. The Agent-Task Site

The foundational insight of jugeo-agents is that a multi-agent AI pipeline is a site in the sense of Grothendieck. This is not a metaphor — it is a precise categorical construction that lets us import 60 years of sheaf-theoretic machinery into multi-agent verification.

The morphisms encode data dependency: if agent \(a_k\) on subtask \(t_l\) reads the output of agent \(a_i\) on subtask \(t_j\), that creates a morphism \((a_i, t_j) \to (a_k, t_l)\). In a CrewAI pipeline, these are the task handoffs. In a LangGraph graph, they are the edges.

1.1 The Grothendieck Topology

A Grothendieck topology \(J\) on \(\mathbf{AgentTask}\) specifies which families of agent-subtask pairs "cover" the full task. Concretely: a family \(\{U_1, \ldots, U_n\}\) covers \(T\) when the union of subtasks accounts for every dimension of the original task.

In jugeo-agents, the CoverageChecker implements this topology. It uses a TaskDimensionExtractor to identify the semantic dimensions of a task (content, quality, format, process, ethics, technical), then a SubtaskDimensionMapper to verify that each dimension is covered by at least one agent-subtask pair:

from jugeo_agents.core.covers import CoverageChecker

checker = CoverageChecker(completeness_threshold=1.0)
report = checker.check(
    task_description="Analyze the competitive landscape for EV batteries",
    subtasks=[
        {"name": "market_size",   "agent_id": "analyst_1", "scope": "Estimate TAM/SAM/SOM"},
        {"name": "competitors",   "agent_id": "analyst_2", "scope": "Map key players"},
        {"name": "tech_trends",   "agent_id": "researcher", "scope": "Patent & R&D analysis"},
        {"name": "risks",         "agent_id": "analyst_3", "scope": "Regulatory & supply chain"},
    ]
)
# report.is_complete == True means {U_i} is a covering family
# report.gaps lists any uncovered dimensions

2. Presheaves of Agent Outputs

A presheaf \(\mathcal{F}\) on the agent-task site assigns to each open set (agent-subtask pair) a structured set of factual claims, and to each morphism a restriction map that extracts relevant claims.

In code, a local section is created when an AgentOutput is processed by the DescentEngine:

from jugeo_agents import AgentOutput
from jugeo_agents.core.descent import DescentEngine

engine = DescentEngine()

section_a = engine.add_section(AgentOutput(
    agent_id="analyst_1",
    subtask="market_size",
    output_text="The EV battery market was $70B in 2024.",
))
section_b = engine.add_section(AgentOutput(
    agent_id="analyst_2",
    subtask="competitors",
    output_text="The EV battery market was about $68B in 2024.",
))

print(len(section_a.claims))
print(section_a.trust.name)
print(section_b.agent_id, section_b.subtask)

2.1 Restriction Maps

When \(U_i \cap U_j \neq \emptyset\) — two agents' subtasks overlap — the restriction map \(\rho_{ij} : \mathcal{F}(U_j) \to \mathcal{F}(U_i \cap U_j)\) extracts the claims from agent \(j\) that pertain to the overlapping subject matter.

This is the key step that transforms raw agent outputs into a sheaf-theoretic structure. Without restriction maps, we'd have isolated blobs of text. With them, we have a diagram that the descent machinery can analyze.

2.2 The Math ↔ Code Rosetta Stone

Every mathematical concept in the sheaf framework corresponds directly to a class or method in jugeo-agents:

3. The Sheaf Condition and Descent

The sheaf condition (also called the descent condition) is the central axiom. It states that local data can be uniquely assembled into global data if and only if the local pieces agree on overlaps.

In categorical language, the presheaf \(\mathcal{F}\) is a sheaf if the natural map from global sections to the equalizer of the restriction maps is an isomorphism:

In jugeo-agents, this check is performed by DescentEngine.check_all(), which iterates over every pair of local sections and calls check_pairwise():

from jugeo_agents import AgentOutput
from jugeo_agents.core.descent import DescentEngine

engine = DescentEngine()
engine.add_section(AgentOutput(agent_id="a", subtask="market", output_text="Battery demand reached 1.0 TWh."))
engine.add_section(AgentOutput(agent_id="b", subtask="market", output_text="Battery demand reached 0.9 TWh."))

result = engine.check_all()

print(result.is_consistent)
print(result.checked_pairs)
print(result.total_claims_checked)
for obs in result.obstructions:
    print(obs.cohomology.value, obs.description)

3.1 Obstruction Classes

When descent fails, the obstructions are classified by cohomological degree. Each degree captures a qualitatively different failure mode:

4. The Čech Complex

The machinery that detects all four obstruction classes is the Čech complex of the covering \(\mathcal{U} = \{U_1, \ldots, U_n\}\) with coefficients in the claim presheaf \(\mathcal{F}\):

Each term of the complex has a concrete interpretation in the multi-agent setting:

4.1 The Coboundary Maps

The coboundary maps \(d^n\) are the "difference operators" that measure inconsistency at each level:

4.2 The Computational View

The Čech cohomology groups are then:

Each group has a direct interpretation:

The dimensions of these groups — the Betti numbers \(h^n = \dim H^n\) — are the pipeline's topological invariants. They are computed and stored in the CohomologyComputation dataclass:

from jugeo_agents import AgentOutput, TrustLevel
from jugeo_agents.core.fusion import GlobalSectionAssembler

assembler = GlobalSectionAssembler(
    trust_threshold=TrustLevel.WEAK_MODEL_GENERATED,
    phantom_detection=True,
    cascade_detection=True,
)

for output in [
    AgentOutput(agent_id="researcher", output_text="Battery costs fell to $139/kWh.", citations=["bnef:2024"]),
    AgentOutput(agent_id="writer", output_text="Battery costs fell to $139/kWh."),
]:
    assembler.ingest(output)

global_section = assembler.assemble()
coh = global_section.cohomology

print(coh.betti_numbers)
print(coh.euler_characteristic)
print(f"{coh.obstruction_density:.2%}")

5. Trust as an Ordered Semilattice

The claim presheaf is not valued in plain sets — it is valued in trust-graded sets. Every claim carries a trust level drawn from a bounded lattice. This lattice structure is what allows jugeo-agents to resolve contradictions without majority vote.

This is a bounded total order, hence automatically a (bounded, distributive) lattice with \(\land = \min\) and \(\lor = \max\). In jugeo-agents, the TrustLevel is an IntEnum with values 0 through 100 in steps of 10:

5.1 Lattice Operations

The trust algebra provides three fundamental operations, each with a precise algebraic characterization:

from jugeo_agents.types import conservative_join, TrustLevel

# Trust composes via meet: the weakest link determines the chain's trust
chain_trust = conservative_join(
    TrustLevel.TOOL_VERIFIED,        # 80
    TrustLevel.STRONG_MODEL_GENERATED, # 30
    TrustLevel.RAG_GROUNDED,          # 60
)
assert chain_trust == TrustLevel.STRONG_MODEL_GENERATED  # min = 30

5.2 Evidence Channel Ceilings

Each evidence channel has a trust ceiling — the maximum trust level achievable through that channel. This is enforced by the TrustCeilingEnforcer:

6. The Global Section Assembler

The GlobalSectionAssembler is the algorithmic heart of jugeo-agents. It computes the Čech cohomology of the agent pipeline and assembles a VerifiedGlobalSection — the trust-graded, provenance-tracked, obstruction-free fusion of all agent outputs.

6.1 The Assembly Pipeline

In mathematical terms, the algorithm computes the following:

6.2 The Euler Characteristic

The Euler characteristic of the pipeline is the alternating sum of Betti numbers:

The Euler characteristic provides a single scalar health metric for the pipeline. It is computed by CohomologyComputation.compute_derived() and stored as euler_characteristic alongside the full Betti number tuple.

from jugeo_agents import AgentOutput
from jugeo_agents.core.fusion import GlobalSectionAssembler

assembler = GlobalSectionAssembler()
assembler.ingest(AgentOutput(agent_id="a", output_text="Tesla was founded in 2003."))
assembler.ingest(AgentOutput(agent_id="b", output_text="Tesla was founded in 2004."))

gs = assembler.assemble()
coh = gs.cohomology
h0, h1, h2 = coh.betti_numbers
rho = coh.obstruction_density

if h2 > 0:
    print("CRITICAL")
elif h1 > 0:
    print("WARNING")
elif rho < 0.05:
    print("HEALTHY")
else:
    print("MODERATE")

7. Why Majority Vote Fails

The standard approach to resolving multi-agent disagreements is majority vote: poll all agents and take the plurality answer. This fails in precisely the cases that matter most.

Formally, majority vote computes a function \(v : \text{Claims} \to \{0, 1\}\) by:

JuGeo replaces this with trust-weighted resolution:

7.1 Phantom Consensus

The deepest failure mode of majority vote is phantom consensus: all agents agree on a fabricated "fact," each seemingly "confirming" the others.

The Čech cohomology detects phantom consensus because it tracks not just whether agents agree, but the trust provenance of the agreement. A phantom section lives in \(\ker(d^0)\) — it passes the consistency check — but it fails the grounding check, which is orthogonal to cohomological consistency.

from jugeo_agents import AgentOutput
from jugeo_agents.core.fusion import GlobalSectionAssembler, QuarantineReason

assembler = GlobalSectionAssembler(phantom_detection=True)
assembler.ingest(AgentOutput(agent_id="a", output_text="NeuralForge raised $500M in 2024."))
assembler.ingest(AgentOutput(agent_id="b", output_text="NeuralForge raised $500M in 2024."))

gs = assembler.assemble()

for q in gs.quarantined:
    if q.reason == QuarantineReason.PHANTOM_UNGROUNDED:
        print(q.claim.text)
        print(q.claim.trust.name)

7.2 Failure Mode Comparison