“Human-in-the-loop” is, as of 2026, one of the most-overloaded phrases in agentic AI. It gets used to mean a human watches a dashboard, a human approves each tool call, a human supervises a fleet of agents, a human-labeled dataset trains the policy, and a human pulls the kill switch — all of which are different engineering problems with different failure modes, different cost profiles, and different mitigations. The first useful move in this space is to separate them, which is what Part I of this two-part monograph is for.
The framing is borrowed from supervisory control theory, the field that figured out most of these questions in the context of human-machine systems decades before LLM agents were a thing. Sheridan’s ten-level taxonomy of autonomy — from “human does everything” through “agent acts autonomously and informs the human” up to “agent acts and chooses whether to inform” — still maps cleanly onto modern agent architectures, with the small twist that the lower levels are increasingly cheap (the model can wait for approval) and the higher levels are increasingly attractive in ways the supervisory-control literature warned about thirty years ago. This monograph is the careful walk through that taxonomy with the 2026 specifics filled in.
Part I covers foundations and mechanisms: the autonomy taxonomy, the single-agent loop with its interrupt, the irreversibility-and-cascade math that decides where gates earn their keep, gate placement across a multi-agent graph, the critic-as-pre-filter pattern, and the labeling and escalation disciplines that turn a gate into a learning signal for downstream RL. Part II — Learning, Securing & Overseeing the Loop — picks up there and covers RL methods, alignment, capable-optimiser failure modes, and the wider mitigations toolbox.
This is the natural companion to the Why Agentic AI Fails field guide (unsafe-tool-use is precisely the failure mode HITL gates address), the Loop Engineering field guide on classical feedback control (supervisory control is its descendant), and the AI Agent Teams monograph (multi-agent gate placement is the centerpiece of §4).
What it covers
Eleven sections, about twenty-four minutes of careful reading.
§ 01 — How much loop the human is in. Sheridan’s ten-level taxonomy of autonomy, refreshed for 2026 agent architectures. Why “human-in-the-loop” without specifying which level is meaningless. The decision framework for choosing the right level for a given task.
§ 02 — The single-agent loop. The simplest version. One agent, one task, one interrupt point where the human can pause-inspect-resume-redirect-abort. The interface design that makes this usable.
§ 03 — Irreversibility and the compounding cascade. The math that decides where gates earn their keep. If an action has irreversibility r and the cascade depth is n, the cost of a wrong decision scales like r·f(n). Gates belong at the points where this product is highest.
§ 04 — Gate placement across a multi-agent graph. The multi-agent version. In a graph of agents passing artifacts between them, where do you put the gates? The bottleneck-versus-fan-out trade-off. The pattern most production systems converge on.
§ 05 — An interrupt firing in a fleet-diagnostics swarm. A worked example. Sixteen agents, three escalation tiers, one interrupt that fires when the swarm’s confidence diverges from its progress rate. The actual signal-detection math.
§ 06 — The critic as a pre-filter. The pattern that reduces human load without reducing oversight quality. A second-pass critic agent that flags only the calls the human would want to see, letting the rest pass through. The eval discipline that keeps the critic honest.
§ 07 — Labeling: when the gate becomes the dataset. Why every human approval / rejection is, secretly, a labeled datapoint. The labeling protocol that makes this useful for downstream training. The traps (selection bias, confirmation bias, the lazy-human-clicking-approve pathology).
§ 08 — Escalation: teaching the agent when to ask. The other half of the labeling story. The agent learns not just “what did the human do” but “when did the human want to be asked.” The reward signal that teaches this.
§ 09 — Interface design. The forgotten layer. A great HITL architecture with a bad interface is a bad HITL architecture. The handful of UI patterns that work (the side-by-side diff, the timeline-with-pause, the explain-then-approve) and the ones that don’t.
§ 10 — Verified fallbacks. What happens when the human isn’t there. The fallback policy. The conservative-by-default discipline. The audit-after-the-fact mechanism that turns “agent acted without approval” from a security incident into a normal operating mode.
§ 11 — A short bridge to Part II. What gating buys you and what it doesn’t. The handoff to Part II, where the question shifts from where do gates go to how do you learn the gating policy, and where the failure modes shift from “human is overloaded” to “capable optimiser plays the gate against you.”
Read it
Part I lives at its own URL with a warm-paper editorial layout — terra-cotta accent, eleven sections, interactive figures showing gate placement and cascade-cost math. The page links forward to Part II — Learning, Securing & Overseeing the Loop at the close.
← Back to Autonomy