Every agent action that a person looks at is looked at either before it runs, which stalls the agent, or after it runs, which means the harm may already be done. Synchronous approval blocks the action until a named person says yes; asynchronous review lets it run and puts a person on the record afterwards, by sampling, queue or exception. This guide is about choosing the human timing for each class of agent action: by reversibility, value and blast radius, by what the approval-fatigue data says about reviewer attention, and by the middle pattern of a hold window that gives a reviewer time to cancel before commit. It is for agent platform engineers, security architects and the risk owners who staff the review queue. Thresholds and spend limits are covered in the AI Agent Action Approvals and Spending Limits Guide, and the machine policy check that sits in front of both modes in Pre-Execution Policy Checks vs Post-Execution Monitoring; this page decides when the human comes in.
Key takeaways
- Human attention is the scarce resource. Anthropic reports that users accept 93% of manual permission prompts in Claude Code. A blocking approval that is almost always granted is a latency cost with little assurance, so spend synchronous approval only where a no is plausible and consequential.
- Asynchronous review is only a control if something can still change. Reviewing an action after money has moved or data has left produces a finding, not a prevention. Pair async review with reversible actions, or with a hold window that lets the reviewer cancel before commit.
- The hold window is the underused middle option. Queue the action, notify the reviewer, and execute automatically after a fixed delay unless someone cancels. It turns many approvals into reviews without giving up the ability to stop irreversible effects.
- Cut prompt volume with containment, not with standing approvals. Sandboxing reduced permission prompts by 84% in Anthropic's internal use. "Always allow" shortcuts reduce prompts too, but they turn a one-off decision into a standing rule nobody reviews again.
- Measure the reviewer, not only the agent. Approval rate, time to decision, review backlog age and seeded-test catch rate tell you whether either mode still has a human paying attention.
The short answer
Use synchronous approval for actions that are irreversible and high value or high blast radius, where a deterministic policy cannot decide alone, and where the approver can see enough to say no. Use asynchronous review for reversible actions, for actions already bounded by hard limits, and for building the evidence that tells you which rules to tighten. Use a hold window for actions that are irreversible once committed but tolerant of a delay, such as outbound messages, scheduled payments and production configuration pushes. In every mode, the machine policy check runs first and blocks what is out of scope; the human decision is an extra layer for what remains, never a substitute. OWASP's Top 10 for LLM Applications 2025 lists "Require user approval" for high-impact actions under LLM06 Excessive Agency, and notes it may be implemented in a downstream system outside the LLM application. MITRE ATLAS records the same control as mitigation AML.M0029 Human In-the-Loop for AI Agent Actions.
The two modes compared
| Dimension | Synchronous approval | Asynchronous review |
|---|---|---|
| When the human acts | Before the side effect; the call waits | After the side effect, or during a hold window before commit |
| Latency added | Seconds to days, set by reviewer availability | None on the call path (a hold window adds its fixed delay) |
| Coverage | Every gated call, by design | All, a sample, or only flagged actions |
| Main human failure | Approval fatigue and rubber-stamping | Backlog, late review, review of a summary not the action |
| Main technical failure | Approval not bound to the exact action; replayed or forged approval; duplicate execution on resume | Effects that cannot be reversed; logs that miss the arguments; no authority to revert |
| What an attacker exploits | Reviewer habit, misleading summaries, prompt floods | Speed (harm completes before review), sampling gaps, low-and-slow activity |
| Best for | Irreversible, high value, privilege changes, first use of a new target | Reversible writes, bounded spend, routine operations, tuning evidence |
Synchronous approval in depth
Threat model
The threat synchronous approval addresses is an agent, steered by a prompt injection, a bad plan or a misread instruction, taking a high-impact step that policy rules allow in principle but that should not happen in this instance. A person who sees the exact action can catch the wrong payee, the wrong environment or the wrong scope. The threats against the approval itself are different: the approver who no longer reads (fatigue), the approver who trusts the agent's summary over the raw arguments (automation bias, which EU AI Act Article 14(4)(b) requires overseers of high-risk systems to remain aware of), the attacker who floods prompts until one is approved, and the approval that is replayed or applied to a different action than the one shown. The same mechanics produced push-prompt fatigue in identity systems, as the Uber breach showed.
Architecture in words
The tool layer intercepts the call, the policy engine returns "requires approval", and the runtime persists the pending call with its full arguments, issues an approval request to a named approver through a channel outside the agent's context, and suspends the task. When the decision comes back, the runtime checks that it refers to the stored request, that the approver is authorised and is not the requester, and that the arguments are unchanged, then executes once. Agent frameworks now expose this pattern directly:
- OpenAI Agents SDK: tools carry
needs_approval(a boolean or a callable that inspects the arguments); a paused run returnsToolApprovalItementries ininterruptions, and the serialisedRunStatecan be stored and resumed later. The documentation warns that deserialisation does not authenticate the snapshot or submitter, and that consequential tools need idempotency keys. - LangGraph:
interrupt()pauses a node, a checkpointer persists state, and the graph resumes on the samethread_idwithCommand(resume=...). The node restarts from its beginning on resume, so any side effect before the interrupt must be idempotent or moved after it. - Workflow engines: AWS Step Functions callback tasks with
.waitForTaskTokenpause untilSendTaskSuccessorSendTaskFailurereturns the token; AWS recommendsHeartbeatSecondsso an unanswered task fails withStates.Timeoutinstead of waiting until the execution limit. - Out-of-band user approval: OpenID CIBA Core 1.0 (Final) lets a client ask the authorisation server to obtain a user's decision on a separate device, with a
binding_messageshown on both devices, anexpires_inlifetime and poll, ping or push delivery. For an agent acting for a user, this keeps the approval outside the agent's own channel. See the OIDC CIBA Guide.
Failure modes
- Approval as a habit: at a 93% acceptance rate, the reviewer learns that the right answer is nearly always yes.
- The standing-rule escape hatch: "always allow" options convert one approval into a permanent rule. In the Claude Code settings leak research, commands approved with "don't ask again" were saved verbatim as allow rules in a project settings file, and researchers found 2,539 secrets across 1,994 public repositories in those files and related history.
- Summary, not action: the approver sees "update the vendor record" rather than the new bank account number.
- Duplicate execution on resume: both LangGraph and the OpenAI Agents SDK document cases where resumed or retried work can run twice without idempotency.
Controls that make it worth having
- Gate few, gate precisely: per-call conditions (production target, new payee, amount over threshold) rather than per-tool approval.
- Show the raw action: exact arguments, target, amount and the untrusted content that led to the request.
- Bind and consume: hash the arguments into the request, validate the decision against the server-stored request and consume it atomically, as the OpenAI Agents SDK guidance recommends.
- Separate requester and approver: see Dual Control and Four-Eyes Approval.
- Fail closed with a ceiling on waiting: an expiry, a heartbeat or a CIBA
expires_in, after which the task stops. - Escalate on repeated denials: Claude Code's auto mode stops the model and hands back to the human after 3 consecutive or 20 total denials in a session; an equivalent circuit breaker stops an agent from probing the approver.
Asynchronous review in depth
Threat model
Asynchronous review addresses errors and misuse that are cheap to correct if found soon: wrong ticket updates, mislabelled records, configuration drift, a bad pattern of small refunds. Its own threats are timing and coverage. Anything that completes before review, such as data egress or a settled payment, is out of reach. An attacker who knows that only 5% of actions are sampled stays in the other 95%. And the review that sees only an agent's narrative ("tidied old branches") misses what was actually done.
Architecture in words
The action runs immediately within machine limits. The runtime writes a structured record (agent identity, delegating user, tool, full arguments, result, prior context hash) to an append-only store, and a review service routes records to a queue: all of them for a new agent, a risk-weighted sample for mature agents, and every record that trips a detection rule. Reviewers mark each item accepted, corrected or escalated; corrections trigger a tested undo; escalations suspend the agent. For audit evidence, see the AI Agent Audit Trails for Regulators Guide.
Failure modes
- Review after irreversible harm: the queue fills with actions whose effects cannot be recalled.
- Backlog: a queue reviewed weekly is an archive. Age of the oldest unreviewed item matters more than queue length.
- No authority to act: the reviewer can flag but cannot pause the agent or run the revert.
- Sampling blind spots: uniform random sampling under-samples the rare, high-impact actions that matter most.
Controls that make it worth having
- Review SLA tied to the revert window: if a change can be reverted for 24 hours, review must happen inside that period.
- Risk-weighted sampling: 100% review of new agents, new tools and new targets; lower rates only once error rates are known.
- Tested compensating actions: each async-reviewed tool has a documented undo that has been exercised.
- Reviewer authority: a stop control and the right to drop the agent back to synchronous approval. EU AI Act Article 14(4)(e) describes a "stop" button or similar procedure that brings a high-risk system to a halt in a safe state.
- Detection rules feeding the queue: see the AI Agent Behaviour Baselining and Anomaly Detection Guide.
The middle option: hold windows and deferred commit
A hold window queues an approved-by-policy action, notifies a reviewer with the full action, and executes automatically after a fixed delay unless the reviewer cancels. The agent's task keeps moving, the click disappears from the happy path, and a person can still stop an irreversible effect. It fits actions that are irreversible once committed but tolerant of delay.
| Action | Typical hold | Why a hold beats a click | When to use full approval instead |
|---|---|---|---|
| External email to an existing contact | Minutes | Most sends are correct; cancel catches the rare wrong one | New external recipients or attachments with customer data |
| Scheduled supplier payment within limits | Until the next payment run | Payment runs already batch; review the batch before release | New payee, changed bank details, amount above threshold |
| Production configuration push with rollback | Change window | Reviewer sees the diff before the window opens | Identity, network boundary or logging changes |
Hold windows fail in two ways: the hold is too short for anyone to look, or cancellation is not authoritative (the action was already sent to a provider that will execute it). Commit the external call only when the window closes, and log every cancellation with its reason, because cancellations are the best evidence of where a rule is missing.
Choosing by reversibility, value and blast radius
The three axes are treated in detail in Pre-Execution Policy Checks vs Post-Execution Monitoring. For the human timing decision, add a fourth question: will the reviewer plausibly say no? If the realistic denial rate is close to zero, a synchronous click buys little; tighten the machine limit instead and review asynchronously.
| Reversibility | Value or blast radius | Realistic denial rate | Human timing |
|---|---|---|---|
| Irreversible | High | Any | Synchronous approval, separate approver, bound to the exact action |
| Irreversible | Low to medium, tolerant of delay | Low | Hold window with cancel |
| Irreversible | Low, latency sensitive | Very low | Machine limit plus asynchronous review of all items |
| Reversible with tested undo | High | Medium | Synchronous approval until error data supports async review |
| Reversible with tested undo | Low to medium | Low | Asynchronous review, risk-weighted sample, SLA inside the revert window |
| Privilege or credential change | High regardless of reversibility | Any | Synchronous approval; never self-approved |
Small versus large organisations: a small team often cannot staff a synchronous queue out of hours, so it should prohibit more actions outright and rely on hold windows that fail closed. A large organisation can run a staffed queue, but must cap per-reviewer load and rotate reviewers; the bigger risk there is diffusion of responsibility across many approvers.
Approval fatigue: what the data says
Published figures on agent approvals are few, but they point the same way.
| Finding | Source | Design implication |
|---|---|---|
| Users accept 93% of manual permission prompts | Anthropic engineering, Claude Code auto mode | A prompt that is nearly always approved should become a rule or a review item |
| Sandboxing reduced permission prompts by 84% in internal use | Anthropic engineering, Claude Code sandboxing | Contain the blast radius first; then fewer approvals are needed |
| A classifier replacing prompts showed 0.4% false positives on real traffic and 17% false negatives on real over-eager actions | Anthropic engineering, Claude Code auto mode | Automated review also misses things; keep hard limits for irreversible actions |
| "Don't ask again" approvals persisted commands, and the secrets inside them, into project files | Apiiro research summarised on the NHI Mgmt Group breach page | Standing approvals need their own review and must never capture credentials |
Capacity arithmetic makes the same point. An agent fleet producing 2,000 gated calls a day at 30 seconds of genuine review each needs about 17 reviewer hours daily; reviewers who have that load spread across other work will not spend 30 seconds. Rubber-stamping controls are covered in the Human-in-the-Loop for AI Agents Guide.
Worked scenario: an accounts payable agent
An agent reads supplier invoices from a shared mailbox, matches them to purchase orders, updates the ledger and schedules payments. The first design gated every tool call, and within two weeks the finance lead was approving about 400 a day in seconds each.
- Reclassify: invoice matching and ledger coding are reversible with a journal correction, so they move to asynchronous review with a 100% sample for the first month and a 24-hour SLA.
- Hold window: payments to existing payees within the per-invoice cap are scheduled into the daily payment run, and the finance team reviews the run before release. Cancellation removes the item before the bank file is created.
- Synchronous approval: new payees, changed bank details and any amount above the threshold go to an approver who is not the requester, through an out-of-band request that shows the payee, account, amount and the source email. Unanswered requests expire after four hours and the payment is not made.
- Machine limits underneath: per-day payment ceiling, payee allowlist and a block on the agent editing payee records.
- Result: synchronous approvals fall to a handful a day, so each one is read.
The bank detail change is the classic invoice fraud step,, and a supplier email carrying injected instructions could lead an agent to it, so it stays synchronous whatever the volume.
How to implement
- Inventory actions: list every tool and argument pattern each agent can use, with reversibility, value ceiling and blast radius.
- Measure before you gate: run new agents in shadow or with 100% asynchronous review for two to four weeks to see real volumes and error types.
- Assign a timing per class: synchronous, hold window or asynchronous, using the table above; prohibit what nobody should approve.
- Build the plumbing: durable pending-action store, out-of-band approval channel, argument binding, atomic consumption, expiry that fails closed, idempotency keys.
- Staff and size the queue: compute reviewer hours, set per-reviewer caps, name a backup approver and define out-of-hours behaviour.
- Pilot with one agent: track approval rate, decision time and corrections; seed known-bad requests in non-production.
- Tune monthly: classes with near-zero denials move to rules or review; classes with corrections move back to approval.
- Roll back safely: any agent can be switched to "all actions synchronous" or suspended with one configuration change, tested in each release.
Detection and measurement
Log approval requests, decisions, approver identity, time to decision, expiries, cancellations within hold windows, async review outcomes and compensating actions, all correlated with the agent run ID. Useful metrics:
- Approval rate per action class: sustained rates near 100% mean the gate should become a rule or a review.
- Median and minimum time to decision per reviewer: decisions in one or two seconds on complex actions signal rubber-stamping.
- Seeded-test catch rate: share of known-bad test requests that reviewers deny.
- Oldest unreviewed async item versus revert window: any item older than its revert window is a coverage failure.
- Hold-window cancellation rate and reasons: a rising rate shows a missing machine rule.
- Post-review correction rate: the error rate that justifies, or rules out, lower sampling.
Framework mapping
| Framework | Reference | How it applies |
|---|---|---|
| OWASP Top 10 for LLM Applications 2025 | LLM06 Excessive Agency, "Require user approval" | Human approval for high-impact actions, enforced downstream of the model |
| MITRE ATLAS | AML.M0029 Human In-the-Loop for AI Agent Actions | The synchronous control this page sizes |
| EU AI Act | Article 14(4)(b), (d), (e) | Awareness of automation bias, ability to override, and a stop procedure for high-risk systems |
| NIST SP 800-53 Rev 5 | AC-3, AC-6, CM-3, AU-6, SI-4, IR-4 | Enforcement, least privilege, change approval, audit review, monitoring and incident handling |
| NIST CSF 2.0 | PR.AA-05, GV.RR-02, DE.CM-09, RS.MI-01 | Authorisations enforced and reviewed, oversight roles, monitoring, containment |
| ISO/IEC 27001:2022 Annex A | 5.15, 8.15, 8.16, 8.32 | Access control, logging, monitoring activities, change management |
Common failure patterns
- Gating by tool rather than by action: every call to the email tool needs a click, so reviewers click everything, including the one send to a new external domain.
- "Always allow" as fatigue relief: standing rules accumulate unseen and can capture secrets, as the Claude Code settings leak research found.
- Asynchronous review of irreversible egress: the review finds the export a week later. Egress needs a gate or a hold.
- Approvals inside the agent's channel: an approval prompt rendered in the same chat the injected content controls can be imitated or pre-empted. Use an out-of-band channel.
- Timeouts that proceed: an expired approval treated as consent.
Practitioner checklist
- Every agent action class has a recorded human timing: synchronous, hold window, asynchronous or prohibited.
- Synchronous approvals show raw arguments and are bound to them, consumed once and fail closed on expiry.
- Approvals use a channel outside the agent's context, and requesters cannot approve their own actions.
- "Always allow" options are disabled or their rules are inventoried and reviewed.
- Asynchronous review has an SLA shorter than each tool's revert window, and every reviewed tool has a tested undo.
- Reviewer load is calculated, capped and rotated, with a named out-of-hours owner.
- Approval rate, decision time, seeded-test catch rate and backlog age are reported monthly.
- Any agent can be switched to all-synchronous or suspended with one tested change.
Standards and references
- OWASP: LLM06:2025 Excessive Agency
- MITRE ATLAS: AML.M0029 Human In-the-Loop for AI Agent Actions
- European Commission AI Act Service Desk: Article 14 Human Oversight
- OpenID Foundation: Client-Initiated Backchannel Authentication Flow Core 1.0
- OpenAI Agents SDK: Human in the loop
- LangChain: LangGraph interrupts
- AWS: Step Functions service integration patterns
- Anthropic: Claude Code auto mode
Related NHI Mgmt Group resources: Human-in-the-Loop for AI Agents Guide, AI Agent Action Approvals and Spending Limits Guide, Pre-Execution Policy Checks vs Post-Execution Monitoring, AI Agent Autonomy Levels Framework, OIDC CIBA Guide.