Human-in-the-Loop AI Agents: Who Can Approve External Actions?

When an agent changes a record or sends a message, who is authorized to approve it?

The person whose recorded mandate covers that exact action, version and destination—and whose identity the application verifies. A mandate is a written allocation of authority, not a job title: name who may release each action, within what limits, who covers an absence and whether the preparer may also approve it.

Human-in-the-loop AI agents use human input at selected points. For external actions, design that input as an enforceable permission control rather than assuming a click supplies authority. “A human checked it” still leaves three questions: what did they review, what could they authorize and what happened afterward?

A note marked v3 passes through an authority-and-version gate toward case C17; a changed v4 follows a separate path back to review. Headline: Approval belongs to one version.
A click records a decision; it does not by itself give the authority to release an action.

For a financial or professional-service team handling recurring document casework, start with one action. The design advice below is not a validated security algorithm; responsible owners must define and evaluate the controls for their systems.

Advice, review and authorization are different jobs

Consider a proposed internal financial-document review note. An agent can prepare a draft from permitted evidence. A domain reviewer can check its support. A separate authorized person may permit that exact version to be attached to a named case-management record.

None of those acts necessarily authorizes a client message, a payment or a financial conclusion. A reviewer may have knowledge without release authority; an administrator may have system permissions without domain competence. A CTO can advise on the design without holding either mandate.

Set the maker–approver rule explicitly. May the person who prepared or requested the action approve it? A single-owner firm is a counterexample to assuming two different people are always available. Its responsible owner would need to record any permitted self-approval arrangement and its limits, while resolving applicable requirements separately. Adding a second username is not a substitute for independent judgment.

Compare three arrangements against the same task. These are fit heuristics, not validated thresholds:

ArrangementWhere it can fitWhere it falls short
Draft-only assistant; human performs the action Existing tools can retain review, destination checks and manual release The manual handoff becomes the capacity bottleneck or loses the reviewed version
Fixed workflow with a human gate Preparation and release follow known routes, including defined exceptions Frequent unmodeled exceptions make those routes impractical
Agentic workflow: the agent proposes steps and tools, with controlled action gates The next step genuinely needs flexible selection Identity, exact-version binding or recovery cannot be evidenced for the proposed action

All three still need authority, version control and an outcome record. A fixed process or existing case-management tool may be enough; document work does not inherently require agent-directed tool use.

As a starting heuristic, consider a gate when an action crosses a system or organizational boundary, commits money or a client, is hard to reverse, or creates a record others will rely on. A permitted draft kept in a controlled workspace may need no release gate yet; an internal record can still be consequential. Decide per action, not per agent.

Agent permission controls: bind approval to the exact proposal

Keep the approved content, not merely an event saying “approved.” A useful approval packet identifies:

  • Evidence: permitted source fragments, their versions and unresolved contradictions.
  • Scope: case, intended use, operation, destination and recipient.
  • Payload: the exact content and parameters presented for release.
  • Action identity: the logical action and its stored pending request.
  • Human authority: authenticated person, applicable mandate and separate specialist acceptance.
  • Decision: approve, reject or clarify, with conditions, time and locally defined expiry.

Retain the reviewed payload as a protected snapshot or an immutable version reference. At the execution boundary, the application needs to establish that the proposed content, operation and target still match the authorized proposal. The executor should use that stored proposal, not re-read a mutable draft after the check. Fetching “the latest note” defeats the binding. A version label or content fingerprint alone also says nothing about who may authorize it.

Define what invalidates a pending decision: an edited payload, changed recipient, revoked authority, changed source access or a new applicable policy. The relevant owners determine what needs fresh review and where enforcement occurs.

This page concerns the approval itself. For product and runtime comparison, the companion article AI Agent Governance Platforms: What They Enforce and What They Leave to You examines control coverage.

The failure: v4 inherits the decision for v3

Invented example, not a performed test or client result. A professional-service team prepares an internal case note. Reviewer R checks note v3 against source packet P2. Action authorizer A has a recorded mandate to release internal attachments to case C17, and permits attaching v3 there. This does not authorize advancing the case or contacting the client.

Before execution, a new draft v4 changes “Owner confirmation is still required” to “Owner confirmation has been received.” The release worker reads the newest draft but checks only a case-level approved flag. It attaches v4 under the decision for v3.

The defect is specific: the reviewed payload and the executed payload differ. The presence of a reviewer, an authorizer and an approval log has not prevented it.

The illustrative v3 sentence says owner confirmation is still required; v4 says it has been received. The approval for v3 does not transfer to v4. A separate recovery box says an unknown attempt outcome needs reconciliation, not blind replay.
Changed content and an uncertain execution result require different responses.

The intended control is to prevent v4 from using v3's decision and route the changed proposal for the necessary review. Keep v3 and its decision intact in the record. If v4 supersedes the pending proposal, retire that stale request too; automatically attaching old v3 is not a sensible substitute for reviewing the change.

Counterexample: an exact match can still be unreleasable. Suppose the worker retains v3 correctly, but A's authority is revoked before the attempt. Payload equality has passed; the authority condition has changed. The owners must define the reauthorization rule and how the application enforces it. Exact-version binding is necessary for this design, not sufficient proof of safe release.

A runtime pause is not business authorization—or execution proof

The OpenAI Agents Python SDK's human-in-the-loop flow can pause configured tool calls, expose pending interruptions and resume from `RunState` after decisions. That describes runtime behavior, not the reviewer's business mandate.

Its server-side approval guidance says deserialization does not authenticate the snapshot or submitter. The application must authenticate the reviewer, authorize them for stored pending calls and validate decisions against server-owned requests. It also calls for coordinated consumption so concurrent or replayed responses cannot resume the same snapshot twice. A run ID is not permission.

Resume behavior is runtime-specific. LangGraph's interrupts documentation says resuming restarts the interrupted node from its beginning, so code before `interrupt()` runs again. Moving a side effect after approval gates it, but does not eliminate duplication if the node commits the effect and then fails before completing. Check the selected runtime and configuration rather than treating all pause/resume features alike.

Return to the example: suppose an authorized attempt to attach v3 reaches the destination, but the connection ends before its result is stored. Now the question is whether the attachment occurred, not whether someone approved it.

The OpenAI SDK's crash-recovery guidance explicitly says approval does not guarantee exactly-once execution. It recommends a stable idempotency key for each logical action, passed to a destination that atomically prevents duplicate effects. Retries reuse that key and the same action parameters, within the destination's retention period and retry rules. A changed v4 is not a retry of v3, and an idempotency key supplies no release authority.

Where destination-enforced idempotency is unavailable or no longer valid, the guidance calls for authoritative reconciliation before retrying: establish that no earlier attempt performed the action or can still perform it. A missing result in an ordinary lookup is insufficient: reads may lag and an earlier request may still complete. If the outcome remains uncertain, record it as unknown and avoid automatic replay. Neither a local approval flag nor a local completion flag makes an external effect and saved run state one atomic operation.

Design the exception path before the happy path

ConditionQuestion the workflow must answer
Rejected or insufficient evidence Who receives the issue, and how is execution prevented pending a valid new decision?
No response or unavailable approver Which authorized backup or escalation applies? Silence must not silently become consent.
Evidence or permission changes while waiting Who decides whether the packet remains usable and which prior decisions need review?
Concurrent or replayed approval response How is one pending request consumed without creating a second action attempt?
Failure is reported but the effect is unconfirmed Is this an established no-effect failure or an unknown outcome, and who reconciles it?
External outcome is unknown Who reconciles it, how is uncertainty shown and what prevents automatic replay?
An effect cannot simply be undone Who can authorize a corrective action, and what evidence accompanies it?

Undoing an attachment and retracting a message are not interchangeable recovery options. A compensating action may itself need approval. Preserve the original attempt and correction trail rather than rewriting history to look successful.

Stop approvals from becoming rubber stamps

Give the reviewer enough context, time and ability to reject or stop. Show the reviewed version next to the proposed one, with changes visible. Look at rejection and clarification patterns alongside workload and case difficulty. An approver who never rejects is a reason to examine the process, not proof of either quality or failure: a well-prepared batch may also produce few rejections.

Also protect the reviewer and the sources. Display only material they may access; keep sensitive evidence in approved storage. An audit trail should be useful for reconstructing the decision without indiscriminately retaining confidential content.

Map the approvals in your agent workflow

For each external action, capture:

  • Case/task and permitted evidence versions.
  • Exact payload, operation and destination.
  • Logical action ID and pending request.
  • Domain reviewer; action authorizer and mandate.
  • Enforcement point; invalidation and expiry rules.
  • Attempt record and result: confirmed, failed or unknown.
  • Exception and recovery owner.

Keep the decision and execution result separate. Missing authority means the action remains unreleased; a missing result after an attempt means the outcome needs investigation.

In a separately authorized evaluation, take the changed-v4 case through the existing process and any proposed replacement—including a change immediately before dispatch. Also cover rejection, an absent approver, revoked authority, duplicate responses and an interruption after the destination may have acted. Retain the proposed payload, decision, attempted payload and destination evidence so the responsible owners can inspect where each boundary held or failed. Compare review effort and recovery burden as well as runtime behavior.

Your next decision is whether the existing process covers this action, a narrow gap needs repair or a different arrangement deserves evaluation. Map the approvals in your agent workflow with the responsible people first. If the unresolved boundary crosses several systems and owners, ask the Grand Rounds curator whether it fits a Grand Rounds session. This does not promise implementation or any CTO's availability.

Boundaries

Grand Rounds is an initiative of Dinarys, and a conversation may lead to cooperation with Dinarys.