Join our Newsletter — 33% off our NHI Course
Home› Guides› Synchronous Approval vs Asynchronous Review of Agent Actions:…
Guide Agent Controls & Monitoring

Synchronous Approval vs Asynchronous Review of Agent Actions: When to Block and When to Review Later

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 14 November 2026 17 min read
On this page

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

DimensionSynchronous approvalAsynchronous review
When the human actsBefore the side effect; the call waitsAfter the side effect, or during a hold window before commit
Latency addedSeconds to days, set by reviewer availabilityNone on the call path (a hold window adds its fixed delay)
CoverageEvery gated call, by designAll, a sample, or only flagged actions
Main human failureApproval fatigue and rubber-stampingBacklog, late review, review of a summary not the action
Main technical failureApproval not bound to the exact action; replayed or forged approval; duplicate execution on resumeEffects that cannot be reversed; logs that miss the arguments; no authority to revert
What an attacker exploitsReviewer habit, misleading summaries, prompt floodsSpeed (harm completes before review), sampling gaps, low-and-slow activity
Best forIrreversible, high value, privilege changes, first use of a new targetReversible 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 returns ToolApprovalItem entries in interruptions, and the serialised RunState can 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 same thread_id with Command(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 .waitForTaskToken pause until SendTaskSuccess or SendTaskFailure returns the token; AWS recommends HeartbeatSeconds so an unanswered task fails with States.Timeout instead 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_message shown on both devices, an expires_in lifetime 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.

ActionTypical holdWhy a hold beats a clickWhen to use full approval instead
External email to an existing contactMinutesMost sends are correct; cancel catches the rare wrong oneNew external recipients or attachments with customer data
Scheduled supplier payment within limitsUntil the next payment runPayment runs already batch; review the batch before releaseNew payee, changed bank details, amount above threshold
Production configuration push with rollbackChange windowReviewer sees the diff before the window opensIdentity, 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.

ReversibilityValue or blast radiusRealistic denial rateHuman timing
IrreversibleHighAnySynchronous approval, separate approver, bound to the exact action
IrreversibleLow to medium, tolerant of delayLowHold window with cancel
IrreversibleLow, latency sensitiveVery lowMachine limit plus asynchronous review of all items
Reversible with tested undoHighMediumSynchronous approval until error data supports async review
Reversible with tested undoLow to mediumLowAsynchronous review, risk-weighted sample, SLA inside the revert window
Privilege or credential changeHigh regardless of reversibilityAnySynchronous 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.

FindingSourceDesign implication
Users accept 93% of manual permission promptsAnthropic engineering, Claude Code auto modeA prompt that is nearly always approved should become a rule or a review item
Sandboxing reduced permission prompts by 84% in internal useAnthropic engineering, Claude Code sandboxingContain 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 actionsAnthropic engineering, Claude Code auto modeAutomated review also misses things; keep hard limits for irreversible actions
"Don't ask again" approvals persisted commands, and the secrets inside them, into project filesApiiro research summarised on the NHI Mgmt Group breach pageStanding 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.

  1. 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.
  2. 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.
  3. 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.
  4. Machine limits underneath: per-day payment ceiling, payee allowlist and a block on the agent editing payee records.
  5. 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

  1. Inventory actions: list every tool and argument pattern each agent can use, with reversibility, value ceiling and blast radius.
  2. 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.
  3. Assign a timing per class: synchronous, hold window or asynchronous, using the table above; prohibit what nobody should approve.
  4. Build the plumbing: durable pending-action store, out-of-band approval channel, argument binding, atomic consumption, expiry that fails closed, idempotency keys.
  5. Staff and size the queue: compute reviewer hours, set per-reviewer caps, name a backup approver and define out-of-hours behaviour.
  6. Pilot with one agent: track approval rate, decision time and corrections; seed known-bad requests in non-production.
  7. Tune monthly: classes with near-zero denials move to rules or review; classes with corrections move back to approval.
  8. 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

FrameworkReferenceHow it applies
OWASP Top 10 for LLM Applications 2025LLM06 Excessive Agency, "Require user approval"Human approval for high-impact actions, enforced downstream of the model
MITRE ATLASAML.M0029 Human In-the-Loop for AI Agent ActionsThe synchronous control this page sizes
EU AI ActArticle 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 5AC-3, AC-6, CM-3, AU-6, SI-4, IR-4Enforcement, least privilege, change approval, audit review, monitoring and incident handling
NIST CSF 2.0PR.AA-05, GV.RR-02, DE.CM-09, RS.MI-01Authorisations enforced and reviewed, oversight roles, monitoring, containment
ISO/IEC 27001:2022 Annex A5.15, 8.15, 8.16, 8.32Access 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

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.

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 14 November 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.