Sheaf is the coherence layer for agentic AI. The Sheaf API is what your agents call through, the way a program calls into the kernel before it does something that matters. A configuration is how you set up Sheaf for one decision: the AI models on the panel, each with its own role and briefing, how they work together, and the coherence threshold below which Sheaf holds. Call one endpoint and get back one reconciled answer plus a coherence audit, or a held run when the models don't hold together.
First decide who runs them. Keep your own agents and Sheaf watches from outside — it can warn you, or it can stop the action. Or let Sheaf run the panel itself, and the stop comes built in. All three return the coherence certificate. This page is mostly about Orchestrate; the Gate has its own setup, and Measure is a single /measure call.
Post your agents' outputs to /measure: the coherence certificate plus a contradiction warning. Your system decides — no change to how your agents run.
Sheaf sits in your agent's tool calls and parks a contradictory action until a person releases it — the agent can't skip it. Connects over MCP; set one up in minutes.
Sheaf runs the panel (this page). Attach the action and a contradiction parks it automatically — measurement, answer, and the stop in one call.
Measurement is common to all three. Keep your agents: Measure warns, Gate stops. Hand them to Sheaf: Orchestrate stops.
A configuration is your setup for one decision — the thing you send Sheaf to run. You choose the members (any mix of models, each with a role and briefing), the topology (how they work together), and the coherence threshold below which Sheaf holds the result. Point it at frontier models Sheaf hosts — across Anthropic, OpenAI, Google and xAI — at your own provider keys, or at local models running on-prem or in your VPC. The OS runs wherever you put it, and the answer comes back with the work shown.
Members answer independently and blind, then Sheaf reconciles them into one answer. For advice, analysis, "many expert opinions → one call."
Members run in order, each transforming the last one's output. For workflows: brief → script → shot list → polish.
Members see each other and argue over rounds, then converge — a genuine argument, not parallel voting.
Members each return a verdict, aggregated by a decision rule (majority, unanimous, supermajority, or synthesis) — with the vote tally.
Calling many models is a commodity. The hard, valuable part is knowing whether they actually agreed. Every run returns a coherence score plus the explicit list of agreements and conflicts between members — the disagreements surfaced, not averaged away. That's Sheaf's math of local-to-global consistency, applied to your own AI calls. How the coherence layer works →
Anyone can fan out to N models. Sheaf tells you whether the answer holds together.
Set holdBelowCoherence and the audit becomes a control. Below that score Sheaf treats
the answer as untrusted: it withholds it and parks the run until a person reviews the conflicts
and releases it. Above it, the answer passes with a coherence certificate. The threshold is yours —
strict holds more, loose lets more through. This is the coherence layer doing what an operating system
does: deciding what is allowed to proceed.
See it in action: build a gate from a schema in the gate modeler, or watch a working accounts-payable agent get stopped by Sheaf in the AP agent demo.
Three call modes, same API underneath. A run is several model calls in one request, so runs take
~10–60s — call it sync, stream it with stream, or fire-and-forget with
async + a webhook for backend pipelines.
Build and run a configuration in the browser, watch each mind land, read the audit. Paste a key and go. The OS console is where your agents, runs, held actions and ledger live.
Open the pod console →Just want to see it work? Watch a panel of minds deliberate to one answer, or watch the gate stop an agent mid-action. No signup, no key.
Watch it run →A zero-dependency CLI (no install) and an agent-readable integration guide for sync / stream / async.
Read the docs →From the command line (Node ≥ 18):
# install the CLI once
npm i -g sheaf-pod
export SHEAF_POD_KEY=sk_pod_…
# run a council pod and get one reconciled answer + a coherence audit
sheaf-pod run -f pod.json -i "Should we ship this week?" --asyncDrop a deliberating panel into a nightly, headless workflow — async + webhook, clean stdout for piping.
High-stakes calls where one model isn't enough and you need to know how much the experts actually agree.
A pipeline of specialist roles — draft → critique → revise — with drift between stages caught by the audit.
Research, QA, compliance, reconciliation — get the answer and a map of exactly where the sources split.