TL;DR for devs

  • Decide where review belongs based on impact, reversibility and who is affected.
  • External communication, financial or account changes and irreversible actions usually need approval.
  • Store the proposed action as pending and execute only after an authorized approval.
  • Too many requests cause approval fatigue; let reviewers edit, reject or take over.
  • Human approval does not replace ordinary security controls.

Approval requests, pausing workflows, avoiding approval fatigue and knowing when to escalate

An AI assistant drafts a reply to an upset customer. Should it send the message immediately, or show it to a support representative first? The answer depends on the message, the customer, and the consequences of getting it wrong.

“Human-in-the-loop” describes a design where a person participates in an AI workflow. They might provide missing information, approve an action, review an output, or take over when the agent reaches a boundary. It is a practical way to combine the speed of software with human judgment.

But adding an approval button to every action is not automatically good design. Too many interruptions can make users approve requests without reading them. Too little oversight can let an agent take actions people did not expect. This guide explains how to build human review into AI agent workflows in a way that is proportional, understandable, and useful.

What Does Human-in-the-Loop Mean?

A human-in-the-loop system involves a person at one or more points in an automated process. For an AI agent, human involvement might happen when:

  • The agent needs information only the user can provide.
  • A proposed action has meaningful consequences.
  • The system is uncertain or its tools disagree.
  • A policy requires approval by an authorized person.
  • The task is outside the agent’s defined scope.

This is not a failure of the agent. Asking for help at the right moment is often the correct behavior. An agent should not be expected to resolve every request on its own.

OpenAI’s agent orchestration guidance covers guardrails and ownership patterns; its guardrails documentation describes ways to control agent inputs and outputs. Human approval is one layer in a larger design that also includes authentication, authorization, validation, and monitoring.

Choose Where Human Review Belongs

Do not ask for approval just because the system can. Think through the action’s impact, reversibility, and confidence.

Low-impact, reversible actions

A read-only search or a draft that remains private may not need a separate approval step. The user can review the answer naturally.

External communication

Sending an email, posting publicly, or replying to a customer can affect other people and the organization’s reputation. A draft-and-review step may be appropriate, especially for sensitive cases.

Financial or account actions

Issuing refunds, making purchases, changing account access, or modifying billing information may require explicit confirmation or approval from a specific role. Enforce the rule in backend code.

Irreversible or high-impact actions

Deleting data, canceling services, or making decisions that affect eligibility may need stronger checks, a human approver, or a workflow that prevents the agent from executing the action directly.

Risk is not only about the action itself. Consider who is affected, how quickly errors can be corrected, and whether the user reasonably expects the agent to proceed.

Design a Clear Approval Request

An approval screen should make the decision understandable. Show the person:

  • What the agent proposes to do.
  • Which data or source informed the recommendation.
  • What will happen if they approve.
  • Whether the action can be undone.
  • What alternatives are available.

For example, instead of “Approve action?”, show: “Send this reply to customer A about order 4821. It offers a replacement under the delayed-shipment policy. The message will be sent from the support inbox.” The person should be able to inspect or edit the draft before approval.

Approval should be an informed choice, not a vague confirmation prompt.

A Python Pattern for Pausing Before an Action

A reliable workflow stores a proposed action as pending, then executes it only after an authorized approval is recorded. Here is a simplified example:

from dataclasses import dataclass from enum import Enum class ApprovalStatus(str, Enum): PENDING = "pending" APPROVED = "approved" REJECTED = "rejected" @dataclass class PendingEmail: recipient: str subject: str body: str status: ApprovalStatus = ApprovalStatus.PENDING def approve_and_send(draft: PendingEmail, approver_id: str, user_can_approve: bool) -> str: if not user_can_approve: raise PermissionError("This user cannot approve outgoing email") if draft.status is not ApprovalStatus.PENDING: raise ValueError("This draft is no longer pending") draft.status = ApprovalStatus.APPROVED # In production, persist the approval and send through an email service.  # Re-check permissions and use an idempotency key before sending.  return f"Approved by {approver_id}; email is ready to send." 

In a real application, the pending action should be stored in a database with an audit trail, user identity, timestamps, and a unique identifier. The approval endpoint must authenticate the approver, verify their role, check that the pending action has not expired or changed, and prevent duplicate execution. A model-generated statement that “the user approved” is not enough; approval must come from the application’s trusted interface.

Make Approval Part of the Workflow State

A human review is easier to manage when it is represented as an explicit state, not just a line in a conversation. For example:

DRAFTED → PENDING_REVIEW → APPROVED → EXECUTED ↘ REJECTED ↘ EXPIRED 

The agent should know which state the task is in. If it creates a draft, it should tell the user that the message has not been sent. If the review is rejected, it should not retry the same action under another tool call. If an approval expires, the system can ask for a fresh decision.

State also helps the product show pending tasks in a dashboard, notify the right reviewer, and recover after a server restart. Treat approval as part of the application’s workflow, not as a temporary memory in the model context.

Avoid Approval Fatigue

If people see too many approval requests, they may click through without careful review. Reduce unnecessary interruptions by distinguishing routine low-risk operations from actions that deserve attention.

You can route review based on clear rules: dollar amount, data sensitivity, recipient type, confidence threshold, or policy category. Avoid relying on a model’s confidence score alone to decide whether an action is safe. Combine model signals with deterministic rules and the actual consequences of the action.

Make approvals easy to review in batches only when each item is clearly summarized and the batch action is appropriate. A single “approve all” button can be risky if the items differ in recipients, amounts, or consequences.

Preserve the Human’s Ability to Correct the Agent

Reviewers should be able to edit drafts, reject an action with a reason, request more information, or take over the task. The agent can use that feedback to continue, but the application must preserve the distinction between what a human changed and what the model proposed.

For example, if a support agent edits a refund amount, the system should treat the edited amount as the approved value and validate it again. It should not silently overwrite the human’s correction when the model runs another step.

When an agent escalates a case, provide the human with a concise handoff: user request, relevant facts, tools already called, sources, unresolved questions, and why it escalated. Do not make the person reconstruct the entire interaction from a long chat history.

Security and Reliability Considerations

Human approval is useful, but it does not replace ordinary security controls.

  • Authenticate approvers: Know who approved the action.
  • Check authorization: Confirm the person is allowed to approve this category and amount.
  • Bind approval to exact content: If the draft changes after approval, require a new approval.
  • Prevent duplicate actions: Use idempotency keys or execution locks.
  • Keep an audit trail: Record who approved what and when.
  • Handle stale requests: Re-check relevant data before executing delayed actions.
  • Minimize sensitive context: Show reviewers the information needed for the decision, not every private detail available to the agent.

These checks should live in application code and trusted services. A prompt can explain the workflow to the model, but it cannot enforce a permission boundary.

When Should an Agent Escalate?

A good escalation policy should be concrete. Examples include:

  • The request is outside the agent’s supported capabilities.
  • Required information is missing after a clarification attempt.
  • Two authoritative sources conflict.
  • The action exceeds an allowed limit.
  • The user disputes a previous decision.
  • The tool fails repeatedly.
  • The agent cannot verify an important fact.

The agent should explain why it is asking for help in plain language. “I can’t verify the account owner from the available information, so I’m sending this to support” is more useful than “I am unable to complete your request.”

How to Evaluate Human Review

Measure whether the review process catches meaningful issues without delaying routine work unnecessarily. Track:

  • How often reviewers approve, edit, or reject drafts.
  • Which categories trigger the most escalations.
  • Whether people understand what they are approving.
  • How often actions are duplicated or changed after approval.
  • Time to resolution and user satisfaction.
  • The rate of errors that pass through review.

Review outcomes can reveal gaps in agent instructions, tool contracts, or business rules. Use them to improve the system, but do not treat every human edit as a preference to learn automatically; some edits are specific to one case.

Frequently Asked Questions

Does every AI agent need human approval?

No. The right level of review depends on impact, reversibility, user expectations, and policy. A read-only search may not need an approval gate, while sending a message or changing billing details may.

Can an agent approve its own action?

The agent can check deterministic rules or prepare an action, but it should not impersonate a human approver. Approval should be a trusted application event associated with an authorized person when policy requires human review.

What is the difference between human-in-the-loop and human-on-the-loop?

The terms are used in different ways, but broadly, human-in-the-loop means a person participates directly in the decision or action. Human-on-the-loop often refers to a person monitoring an automated process and stepping in when needed. Choose the level of oversight that fits the risk.

Should the agent show its full reasoning to the reviewer?

The reviewer needs a concise rationale, evidence, and proposed action—not necessarily a raw internal reasoning trace. Show sources and relevant facts so they can make an informed decision.

What if the reviewer rejects the action?

The system should record the rejection, stop that action, and either ask the user for a revised request or hand the task to a person. It should not keep trying the same action through another path.

Conclusion

Human-in-the-loop design helps AI agents work within appropriate boundaries. A person can provide missing context, review a consequential action, or take over when the system reaches its limits. The experience works best when the request for review is specific, the proposed action is visible, and the approver can edit or reject it.

Represent approvals as explicit workflow states, enforce identity and permissions in the backend, bind approval to the exact action, and prevent duplicate execution. Use human review where it changes the outcome—not as a ritual checkbox. That lets agents handle routine work while keeping people meaningfully involved in decisions that deserve their judgment.

References

I write about building AI agents and full-stack AI apps. Follow me for the next one, and tell me in the comments: Which actions in your product would you never let an agent take without approval?