Human in the Loop for AI Agents: Where a Harness Should Pause
Learn where an AI agent harness should pause for human approval, which actions need a gate, and how to resume the work without losing context.

A human in the loop AI agent is one whose harness stops the work at defined points, shows a person the exact proposed action and the evidence behind it, and continues only after an explicit decision. Pause points belong where an action is hard to reverse, spends money, sends information outside the company, or changes what the agent is allowed to do. The step most teams underbuild is the resume: the agent must continue from the state it had reached, with the decision attached, and without asking the model to reconstruct what happened.
Key takeaways
- Place pause points at actions that are hard to reverse, that spend money, that send information outside the company, or that change a permission.
- Make each pause carry the full proposal: the action, the inputs and their sources, the exact output, and what happens if the person says no.
- Record every decision as data the harness can read, including who decided, when, and under which version of the task.
- Resume from a saved checkpoint rather than from the conversation, and re-check the preconditions before anything executes.
- Start with a small set of gates, review the pause log regularly, and remove any gate that never changes an outcome.
Why a pause is a harness decision, not a prompt instruction
Telling an agent in its prompt to ask before sending is a weak control. The model can skip the instruction, a tool can run anyway, and afterwards nobody can prove which rule applied. A pause point belongs in the harness, the layer that decides which tool calls execute, with which inputs, and under which permissions. The prompt describes what you want; the harness enforces it.
Before you place any gate, define the role itself: its single job, the memory and tools it needs, its approval boundaries, and one observable success criterion. Gates are easier to place when those boundaries already exist. Without them, teams tend to add approval to everything after an incident, and the result is slow work that people approve without reading.
Where an agent must wait
Start from the actions, not from the conversation. A useful test is whether the step can be undone on the same working day without a customer, supplier or auditor noticing. If the answer is no, the step needs a gate. In most business agents, that covers these categories:
- Messages to people outside the company, especially the first message in a new thread.
- Payments, refunds, purchase orders, and any edit to a price, invoice or contract term.
- Writes to records other teams depend on, such as customer files, stock levels or case status.
- Changes to permissions, new tool connections, or new data sources added to the agent's memory.
- Actions based on information the agent could not verify against a source of record.
- Any step attempted after a stop condition, a budget limit, or repeated failures.
Reads, drafts, internal summaries and reversible updates that store the previous value usually need no pause. Gating everything produces approval fatigue, and approvers begin clicking through. For the boundary between gates and automatic checks, see Human Approval Gates for AI Agents.
How do you build the pause itself?
A pause is useful only if the approver can decide from what is on the screen. Build it in this order:
- Name the action in plain words the approver already uses, such as send a renewal reminder to one customer, not the tool identifier.
- Attach the inputs the agent used, with the source system for each one, so the approver can check them.
- Show the output exactly as it will execute, including recipient, value, field names and file names. A summary of the proposal is not enough.
- State what changes if approved and how it can be reversed, or say plainly that it cannot be reversed.
- Offer three decisions: approve as shown, edit specific fields and approve, or reject with a reason the harness stores.
- Set an expiry. When the window closes, the task moves to a parked state and nothing executes.
The rejection reason matters. A note such as wrong customer segment becomes input for the next version of the task definition instead of a dead end.
Designing the resume step so context is not lost
When the decision arrives, the harness should not open a new conversation and ask the model to pick up where it stopped. A fresh run may plan differently, read different records, or repeat an earlier tool call. The resume should load a saved checkpoint that holds the task version, the current step, the tool results already received, the proposal as it was shown, the decision, the approver's role, and the timestamp. Anthropic's guidance on long-running agents makes the same point: progress belongs in durable artifacts the next session can read, not only in one context window.
A sound resume follows this sequence:
- Load the checkpoint and confirm the task version still matches the one that produced the proposal.
- Re-read the preconditions from the source system, such as record status or available quantity, and compare them with the values the approver saw.
- If anything differs, stop and return to the approver with the current values. Do not execute the old decision.
- If the approver edited fields, validate the edited values against the tool schema before the call.
- Execute the approved action once, with a stable request key so a retry cannot duplicate it.
- Write the result and the decision to the log, then continue with the earlier results available to the next step.
Illustrative scenario: an agent prepares a refund for a customer whose delivery arrived damaged. The harness pauses before the payment call and shows the order record, the refund value taken from the billing system, and the policy rule the agent cited. The approver edits the reason text and approves. On resume, the harness checks that the order is still marked delivered with an open claim and that no refund exists, makes one payment call with the approved values, and logs the decision. If the status had changed in the meantime, the agent would have returned to the approver instead of paying.
For the mechanics of saving state, see Checkpoints for Long-Running AI Agents.
What should the pause log record?
Each pause should produce a trace: the task, the gate that fired, the reason it fired, who was asked, how long the wait lasted, the decision, and what the harness verified on resume. OpenTelemetry's observability primer describes traces and spans as a way to follow one piece of work across steps, and a pause fits naturally as a span with a visible wait. Keep the fields that answer audit questions: who approved, which rule version applied, and which values were executed. Leave out raw prompt text unless your privacy review allows it.
Common failure modes and how to catch them
Most pause problems show up in the logs before they show up in customer complaints. Watch for these patterns:
- Approval fatigue: too many gates trains people to approve without reading. Find the gates that never change a decision and remove them.
- Summary approvals: the approver sees send update to supplier but not the recipient list. Show the executable payload instead.
- Resume by re-planning: the agent decides again and takes a different path. Resume only from the checkpoint.
- Stale approvals: an approval given yesterday is used against today's stock or status. Re-check preconditions on every resume.
- Invisible queues: paused tasks sit unseen until someone asks where the work went. Give each pending approval an owner and an age limit.
If a paused task keeps retrying or repeating the same step, the stop rules should halt it and escalate. See Stop Conditions for AI Agent Loops for how to set those limits.
How Be Human handles pause points in managed operations
Be Human defines pause points during the first engagement, together with the single role, its memory and tools, its approval boundaries and its success criterion, so gates are designed before launch rather than added after an incident. In managed operations, the team reviews the pause log on a regular schedule, runs permission review when a tool or channel changes, and handles incidents when a resume finds state that no longer matches the approval. The work is remote, in English or Portuguese. Take the free Be Human AI diagnostic to find the first task worth handing to an agent.
Frequently asked questions
Does every AI agent need a human in the loop? No. Reads, drafts and reversible internal updates can usually run without a pause, as long as the harness logs them. Reserve human approval for actions that are hard to undo, that spend money, that reach people outside the company, or that change what the agent can do.
How many approval gates should a first agent have? Keep the number small and tied to specific actions. Start with the irreversible or external steps, run the agent for a while, and review which pauses changed an outcome. Remove the ones that only added waiting time.
What should happen if the approver is unavailable? The task should move to a parked state with an expiry, not execute by default. The pending request should appear in a queue with an owner, so the work does not disappear. When the window closes, the harness records the expiry and can notify a backup approver if your process names one.
Can an agent resume after the underlying system has changed? It can, but only after checking. The harness should re-read the preconditions from the source system and compare them with what the approver saw. If the values differ, the agent returns to the approver with the current facts instead of executing the earlier decision.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


