Guide / Agent oversight
Human in the loop vs human on the loop for AI agents
Human in the loop vs human on the loop is a decision about where a person’s judgment sits. In the loop, a person approves each consequential action before it takes effect. On the loop, the agent acts within limits set in advance while a person watches, can step in and reviews the outcome. This guide defines both models, shows when each fits AI agents and explains how to build them into a task workflow.
Sources checked .
Definitions
Where the human sits in the decision cycle
The European Commission’s High-Level Expert Group on AI set out the common definitions in its April 2019 ethics guidelines. Human in the loop (HITL) is “the capability for human intervention in every decision cycle of the system”, which the guidelines note is “in many cases neither possible nor desirable”. Human on the loop (HOTL) is “the capability for human intervention during the design cycle of the system and monitoring the system’s operation”. A third model, human in command, covers deciding when and how to use the system at all, including the decision not to use it.
For an AI agent, a decision cycle is a step with consequences: a tool call that writes data, a merge, a deployment, a payment or a message to a customer. Under HITL the agent prepares the step and waits for a named person. Under HOTL the agent takes the step itself, inside boundaries a person defined beforehand, and a person monitors the results with a way to stop, reverse or redirect the work.
Human out of the loop is the contrast case: the agent acts and nobody can intervene in time to change the outcome. For agents with write access to shared systems, this is usually an accident of configuration, such as an unreviewed key with broad scope, rather than a deliberate design.
- Agent prepares the action
- Human approves or rejects
- Action takes effect
- Agent acts within set limits
- Activity and signals stay visible
- Human intervenes when needed
Comparison
HITL, HOTL and out of the loop side by side
| Decision | Human in the loop | Human on the loop | Human out of the loop |
|---|---|---|---|
| Who decides each action | A person, before it takes effect | The agent, inside limits a person set | The agent alone |
| When the human acts | Before every consequential step | During and after the run | Not in time to change the outcome |
| Throughput | Limited by reviewer availability | Limited by the agent and its checks | Limited only by agent capacity and automated checks |
| Main failure mode | Rubber-stamped approvals and queue delays | Errors land before anyone notices | Undetected harm |
| Typical controls | Approval requests, required reviews, permission prompts | Scoped access, activity records, alerts, stop and rollback | Automated checks only; no human intervention |
| Fits | Irreversible, wide blast radius or unfamiliar work | Reversible, bounded work with a track record | Rarely appropriate for agents with write access |
When to use each
Decide by reversibility, blast radius and track record
Neither model is safer in general. Approvals add latency and invite rubber-stamping; monitoring lets mistakes land before anyone sees them. Choose per action, not per agent, by asking four questions:
- Can the action be undone cheaply? A commit on a branch reverts in seconds. A dropped table, a sent email or a production schema change may not.
- How far does a mistake spread? A draft affects one reviewer. A deployment, a credential change or a bulk edit affects every user of the system.
- Has this agent done this kind of work well before? New task types, new repositories and new permissions start in the loop until there is evidence to relax them.
- What does waiting cost? If an approval queue holds a small, reversible fix for a day, monitored autonomy with a fast rollback may carry less total risk.
A practical rule: put the human in the loop at the irreversible boundary and on the loop everywhere the agent can be stopped and undone. Most agent workflows mix the two. The agent works on the loop inside a branch or sandbox, then stops in the loop before merge, deployment or any destructive action.
Oversight only works if the reviewer is paying attention. Article 14 of the EU AI Act, which applies to high-risk AI systems, requires that the people overseeing them remain aware of the tendency to rely or over-rely on the system’s output, can decide not to use it or override it, and can interrupt it through a “stop” button or a similar procedure. Those criteria make a useful checklist for any agent workflow, whether or not the Act applies to it. An approval nobody reads is monitoring with extra delay. For a staged path from suggestion to self-direction, see the human and AI agent collaboration framework.
Implementation
Build approval states, review queues and escalation into the task
Oversight that lives in a chat thread disappears when the session ends. Put it on the task, where the work, the decision and the evidence stay together.
For human in the loop, make the approval point explicit:
- Name the action that needs approval and who can give it: a person, a team or the project’s administrators.
- Have the agent stop and file a structured request: what it wants to do, why, the evidence and the condition for resuming.
- Route requests to a queue humans check, with a way to retarget a request when the approver is away.
- Resume only after the agent reads the outcome. A rejection is a valid result, not an error to retry.
For human on the loop, set the limits before the run and keep the run visible:
- Scope the agent’s identity and access to the projects and resources the task needs.
- Record every action under that identity, with links to pull requests, test reports and comments.
- Define the signals that need a person: failed runs, stalled work and blocked dependencies.
- Keep a stop and rollback path: cancel the run, revoke the key, revert the change.
Escalation connects the two models. An agent working on the loop should move into the loop on its own when it reaches a boundary: missing access, an ambiguous requirement or an action outside its permissions. Agents should also be able to report a blocker and stop, rather than retrying until something gives.
Coding agent examples
From permission prompts to monitored autonomous runs
Pull request merge approval. A coding agent picks up an issue, works in a branch, runs tests and opens a pull request. Everything up to that point runs on the loop. The merge is the decision cycle with a human in it. GitHub branch protection can require a set number of approving reviews and passing status checks before merge. By default those restrictions do not apply to repository administrators, so include administrators in the rule if the gate must hold for everyone.
Permission modes in the agent itself. Claude Code shows the spectrum inside one tool. Its default mode prompts for permission on first use of each tool. acceptEdits accepts file edits and common filesystem commands in the working directory automatically. plan explores with read-only commands. auto runs without routine prompts while a background classifier checks actions. dontAsk denies any call that would otherwise prompt, so only pre-approved actions run. bypassPermissions skips prompts except for actions no mode auto-approves, and Anthropic advises using it only in isolated environments such as containers or virtual machines. Moving along those modes moves the human from in the loop to on the loop.
Monitored autonomous runs. An agent works an assigned queue overnight in a sandbox with branch-only write access. Nobody approves each step. In the morning a person reads what each run did, cancels anything off track and reviews the pull requests. The run is on the loop. The merge still has a human in it.
Destructive actions. Database migrations against production, data deletion, credential rotation and customer-facing messages stay in the loop even for trusted agents. The agent can prepare the change and the rollback plan, then ask.
In Atoll
Human in the loop for AI agents, recorded on the issue
In Atoll, agents are members of the workspace with their own name, role, scoped API key, assigned queue and activity history. See agent project management in Atoll for the membership model. Agent permissions are edited without replacing the agent’s identity, and permission administration stays with humans.
In the loop. An agent run on an issue can be recorded as an execution with the states assigned, running, waiting, needs_human, succeeded, failed and cancelled. When the agent needs a person, it files a human attention request targeted at one member, a team or the project administrators. The request kinds are approval, clarification, access, decision, destructive action and other. Each request states what the agent needs, why and the condition for resuming, and it moves the execution to needs_human. People respond from the Attention queue; approvals and destructive actions are approved or rejected. The agent sees the outcome in its heartbeat.
On the loop. Every comment, status change and field change on an Atoll issue records the actor, human or agent. Executions can link existing evidence: comments, activity events, pull request links and attachments. Heartbeat task eligibility can exclude work with unresolved dependencies, and executions can be listed by state, so failed, waiting and needs_human runs are easy to find.
Two limits matter. Atoll records management state; it does not start or resume the agent’s harness, so a resolved request still needs your harness to wake the agent. Atoll also does not control merge permissions in GitHub. Enforce the merge gate with branch protection or repository rules, and use Atoll to keep the request, the decision and the evidence on the issue.
FAQ
Human in the loop and human on the loop questions
What is the difference between human in the loop and human on the loop?
Human in the loop means a person approves each consequential action before it takes effect. Human on the loop means the system acts within limits set in advance while a person monitors it and can intervene, stop or reverse its work. The difference is timing: approval before the action, or supervision during and after it.
How do human in the loop AI agents work?
Human in the loop AI agents pause at a defined point, such as a merge, a deployment, a data deletion or a customer message, and wait for a named person to approve or reject that action. They can still do the preparatory work on their own. The human decides whether the consequential step happens.
Is human on the loop safe for coding agents?
It can be, when the work is reversible and bounded. Typical boundaries are branch-only write access, scoped credentials, an isolated environment, required checks and an activity record a person actually reads. Without a working stop and rollback path, on the loop becomes out of the loop.
Can one workflow use both models?
Yes, and most agent workflows should. A coding agent can work on the loop while it plans, edits a branch and runs tests, then stop in the loop before merge or deployment. Place each approval at the point where the action becomes hard to undo.
Does Atoll approve or merge pull requests for you?
No. Atoll records the request and the human decision: an agent can ask a member, team or project administrators for an approval, and a person approves or rejects it in Atoll. Merge permissions stay in your code host. Enforce required reviews with GitHub branch protection or repository rules.
References
Sources
Sources checked 12 November 2026. Product documentation changes; confirm current behavior with each provider before relying on it.