Platform · The mechanism

Five roles that make an agent pod provable.

Sheaf wraps a group of working agents in a supervision layer. Some of it sits in the path of every action to stop it; the rest sits alongside to measure it. Here is exactly how the parts fit — and what you get at the end.

The shape of it

The stop is dumb and instant. The judgment sits to the side.

That single design choice is what makes the whole thing work in production. The component that halts an action can't afford to be slow or clever — so it isn't. The component that judges coherence needs room to reason — so it runs off the critical path and never becomes a bottleneck. Five roles, each doing one job.

Ledger
Declares the shared facts the agents reason over and the actions that need human consent. The rulebook.
Gate
In the path. Deterministic, instant. Blocks a consent-listed action before it fires.
Witness
Alongside. One per agent. Extracts each agent's claims about the shared facts.
Warden
Holds the red phone. Pauses the run and puts the decision in front of a human.
Reporter
Continuous. Checks that every claim fits together, and issues the coherence certificate.

01 Before the run

The Ledger — a declared world, not a guess

The hard part of supervising agents isn't the maths; it's knowing when two agents are talking about the same fact. Sheaf solves that by declaration: the pod's configuration names the shared facts and the relations allowed over them up front. Witnesses then extract against that closed vocabulary — a bounded problem, not open-ended guesswork. Anything outside the Ledger is invisible by design, which is what makes the guarantee precise instead of hand-wavy.

Pod configuration · ledger ledger:
  facts:
    - income      # numeric
    - ltv         # numeric
    - rate        # numeric
    - risk_tier  # ordinal: A > B > C > D
  relations: [ordering, equality, implication]
  consent_required: # the Gate blocks these pending a human
    - submit_application_to_lender
    - send_binding_quote
    - pull_hard_credit_check

02 During the run · the stop

The Gate and the Warden — an unbreakable halt

Every action an agent takes routes through the Gate before it executes. The Gate is deliberately simple: it checks the action against the Ledger's consent list. If it's there, the action does not fire — full stop. No model in the loop to be slow, prompt-injected, or talked out of it; just a lookup on the critical path.

When the Gate blocks, the Warden picks up the red phone: it pauses the run and puts the decision in front of a human — approve, deny, or step in — then resumes or aborts. Nothing consequential happens without that door, and the door can't be argued with.

Why an LLM can't do this job. To stop an action you must sit in front of it. An observer that notices after the fact is a log, not a control. The Gate is the control — and controls have to be things that cannot fail open.

03 During the run · the measurement

The Witness and the Reporter — coherence, continuously

Each agent gets a Witness watching from the side. It reads what its agent is reasoning and doing, and extracts that agent's relational claims about the shared facts — risk_tier(applicant) > threshold, rate_quoted = rate_offered — never bare opinions.

The Reporter collects every Witness's testimony and continuously checks that it glues together. If two agents have quietly diverged — one acting on a fact another has already contradicted — it surfaces the exact contradiction while the run is live and rings the red phone. When the run ends, it issues the certificate below.

Relational claims are the point. If agents only stated absolute values, every clash would be a simple two-way mismatch. It's the relations — A says x = y, B says y = z, C says z ≠ x — that create the contradictions no pairwise check can see. Sheaf is built to find exactly those.

What you get

A coherence certificate, not a confidence score

Two genuine measurements a model can't fake about itself — the same consistency mathematics used in signal fusion and formal verification.

H⁰ · consistent

Every agent's claims glue into one coherent view of the world.

1.00coherence — a global section exists
H¹ · contradiction

Each pair agrees, yet no single account holds them all — an irreducible loop.

0.41coherence — contradiction located

Signed and stored per run. It's the artifact your risk team signs, your regulator accepts, and your board relies on — before you let agents act on their own. See the mathematics →

Built for your stack

Three ways to put Sheaf in front of your agents

You choose how much Sheaf does — from a read-only check to actually stopping the action. All three return the coherence certificate; two of them give you the hard stop.

Measure You enforce
Post your agents' outputs to one endpoint — you get the coherence certificate and a contradiction warning. Your system enforces. One call, no change to how your agents run. If the agent acts anyway, Sheaf recorded the warning; it didn't stop it.
Gate via MCP Hard stop
Route your agents' tool calls through Sheaf over MCP. A contradiction parks the action until a human releases it — the agent can't skip it. Standard MCP work, not bespoke Sheaf code; you run the gate in front of your agents.
Orchestrate Hard stop
Let Sheaf run the pod and return one answer. Attach the action it feeds and a contradiction parks it automatically — no integration on your side. Measurement, answer, and the stop in a single call.
Measurement is common to all three. The hard stop comes with Gate and Orchestrate; Measure advises, you enforce.
POST /api/v1/pod/run  ·  Orchestrate { "pod": { "members": [ /* your agents */ ],
        "ledger": { "facts": […], "holdOnObstruction": true } },
  "input": "…",
  "proposedAction": { "name": "submit_recommendation", "args": {…} } }

# → returns the H⁰/H¹ certificate + the answer.
# Contradiction + proposedAction → the action is PARKED for human release.
# Also: POST /measure (advise only) · route via MCP (Gate) — same held-action machinery.

What Sheaf checks

Three checks on every answer

Sheaf checks three things: your agents' claims against the sources of truth you designate, the plausibility of the values themselves — flagging what's obviously false or impossible — and whether the whole thing holds together, as a single coherence certificate. What it catches is the failure that causes the incident: agents that look fine one by one but have silently pulled apart underneath — correct in the parts, broken in the whole.

See it run against your agents.

Book a demo

Or read the proof behind the certificate — the mathematics.