AI orchestration · when an agent may act on its own

An agent has to know when it doesn't know enough — before it acts, not after.

Putting AI agents into production, the hard part isn't wiring them together — the frameworks do that (LangGraph, CrewAI, AutoGen). The hard part is knowing, step by step, when an output is too uncertain to trust. That is what we measure: friction = competing routes per decision — read for free off the model's own output. Low friction → run autonomously. High friction → stop, retrieve more, or hand the task to a human.

One node in the graph: measure → gate → commit / retrieve / human
1 · CALL model / tool with logprobs 2 · FRICTION METER competing routes + entropy → per-step uncertainty · free 3 · GATE vs. threshold LOW FRICTION Commit — run autonomously MEDIUM Extend · retrieve (RAG) · abstain HIGH / OOD Human in the loop · escalate every call → auditable uncertainty trace ONE POLICY · THREE OUTCOMES

What the gate gives you

  • Uncertain hallucination caught before it spreads. A step where friction rises is flagged on the spot instead of propagating through the rest of the agent chain.
  • Autonomy gated on measured uncertainty. The model acts on its own when it is sure and holds back when it isn't — you set the threshold, not the model's mood.
  • An auditable trace per decision. Every call carries its own uncertainty number, so an agent action can be documented and reviewed after the fact.
  • Almost free. The signal reuses data the call already returns — no second judge model in the critical path.

What it replaces

  • A second judge model on every step — expensive, slow, and carrying its own uncertainty on top of the one you were trying to measure.
  • Rule stacks that collapse compliance. Our own research measures it: as a rule set went from 1 to 10 competing directives, adherence fell ~90% → ~36%. That is why we gate on one measured signal rather than stacking rules.
  • Binary choices — "always run autonomously" (unsafe) or "always escalate everything" (no automation left). The gate gives the middle path: graded by uncertainty.

Gate hard when

the step is hard to undo — a transaction, an outbound message, a deletion — or the claim can be checked against a source. Here we verify independently, regardless of friction. This is the layer that catches confident-wrong: a fluent, low-friction answer that is simply wrong — friction won't flag it, the stakes do. Here we gate on consequence and measured contestability — never on the model's own confidence. See the architecture →

Gate soft when

the step is cheap and reversible and base trust is high. Let the model run on its own, and use the trace to catch the few cases where friction rises anyway.

“We measure the model's own uncertainty at each step and let it act on its own when it's sure, retrieve more when it isn't, and hand the task to a human when it's on shaky ground — and every step is something you can measure and audit.”

1Measure friction: competing routes, free from the model's output.
2Calibrate the threshold: per model × task, against your own data.
3Gate: commit · retrieve · human — with a trace on every call.