Sheaf Labs makes the coherence layer for agentic AI. The Sheaf API is how your agents ask Sheaf before they act, for any decision that matters. A configuration is how you set up Sheaf for one decision: the AI models that take part, each with its own role and briefing, how they work together, and how much agreement you need before the answer goes through. Make one call and get back one combined answer plus a report of where the models agreed and disagreed, or a stopped run when the models disagree too much.
First decide who runs your agents. Keep your own agents, and Sheaf watches from outside. It can warn you, or it can stop the action. Or let Sheaf run the AI models itself, and the stop comes built in. All three return a signed record of whether the reasoning held together. This page is mostly about the third way, Orchestrate. The Gate has its own setup, and Measure is a single /measure call.
Send your agents' answers to /measure. You get the signed record, plus a warning if the answers contradict each other. Your system decides what to do. Your agents run as before.
Sheaf sits between your agent and its tools. If an action contradicts the agent's own reasoning, Sheaf stops it and parks it until a person releases it. The agent cannot skip this. It connects over MCP, the standard way tools are connected to an AI agent. Set one up in minutes.
Sheaf runs the AI models itself (this page). Attach the action, and a contradiction parks it for a person. You get the check, the answer, and the stop in one call.
All three check the same way. Keep your agents: Measure warns, Gate stops. Hand them to Sheaf: Orchestrate stops.
A configuration is your setup for one decision. It is what you send Sheaf to run. You choose the members (any mix of AI models, each with a role and briefing), the topology (how they work together), and the threshold, the level of agreement below which Sheaf holds the result. Point it at the models Sheaf hosts, from Anthropic, OpenAI, Google and xAI, at your own provider keys, or at models you run on your own machines or in your own cloud. Sheaf works wherever you put it, and the answer comes back with the work shown.
Members answer separately, without seeing each other, then Sheaf combines them into one answer. For advice and analysis: many expert opinions, one answer.
Members run in order, each working on the last one's output. For step-by-step work: brief, then script, then shot list, then polish.
Members see each other and argue over several rounds, then settle on one answer.
Members each return a verdict. A rule combines them (majority, unanimous, supermajority, or synthesis). You get the vote count too.
Many tools can ask several models. The useful part is knowing whether they actually agreed. Every run returns a coherence score plus a list of the agreements and conflicts between members. Each disagreement is shown on its own. This is the mathematics behind Sheaf, a check that the answers fit together as one picture, applied to your own AI calls. How the coherence layer works →
Several models answer. Sheaf tells you whether the answer holds together.
Set holdBelowCoherence and the report becomes a control. Below that score Sheaf does
not trust the answer: it holds it back and parks the run until a person reviews the conflicts
and releases it. Above that score, the answer passes with a signed record that the reasoning held together.
You choose the threshold. A strict one holds more, a loose one lets more through. This is how Sheaf
decides what is allowed to proceed.
See it in action: build a gate from your own data layout in the gate modeler, or watch an agent that pays invoices get stopped by Sheaf in the AP agent demo.
Three ways to call, same API underneath. A run asks several models in one request, so it takes
about 10 to 60 seconds. Wait for it with sync, watch it arrive with stream, or send it and collect the result later with
async plus a webhook, a web address Sheaf calls when the run is done.
Build and run a configuration in the browser, watch each model answer, read the report. Paste a key and go. The OS console is where your agents, runs, stopped actions and the record of every decision live.
Open the pod console →Just want to see it work? Watch several AI models reach one answer, or watch Sheaf stop an agent mid-action. No signup, no key.
Watch it run →A command-line tool with no install needed, and a guide to the three ways to call, written so an AI agent can read it too.
Read the docs →From the command line (Node ≥ 18):
# install the CLI once
npm i -g sheaf-pod
export SHEAF_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?" --asyncPut several models into a nightly job that runs on its own. Use async plus a webhook. The output is plain text you can pass to the next step.
Important decisions where one model is not enough and you need to know how much the models actually agree.
A pipeline of specialist roles: draft, then critique, then revise. The report catches where a later step drifts from an earlier one.
Research, checking, compliance, reconciling records. Get the answer and a map of exactly where the sources split.
The coherence score in the API response comes from the sheaf Laplacian over the panel's claims. Agents and claims form a graph, disagreement becomes energy on it, and the score reads that energy from 0 to 100. The H¹ index flags a contradiction that runs in a loop across the panel, one that no pair of answers shows on its own. Rules passed to the gate are checked with a formal-logic solver before they are enforced, so a rule set that cannot hold together is caught before it governs an agent. How it works at Sheaf Labs →