Human-in-the-Loop: When Should an Agent Ask for Permission?

Posted on Tue 17 November 2026 in Beginner Guide

The Autonomy Problem

An AI agent that asks for permission at every step isn't useful. An agent that never asks for permission is dangerous. The interesting design question is where to draw the line — and most people building agents today are drawing it too far in one direction or the other.

This post is about how to think about that line practically.

What "Human-in-the-Loop" Actually Means

Human-in-the-loop (HITL) means a human gets a chance to review or approve before the agent proceeds. The loop can be tight (approve every action) or loose (approve only certain categories of action). Most real systems sit somewhere in between.

The goal isn't to maximise or minimise human involvement. It's to put humans in the loop at exactly the points where the cost of a mistake is higher than the cost of the interruption.

A Simple Framework: Reversibility × Impact

The two dimensions that matter most are reversibility and impact.

Reversibility: Can this action be undone if it's wrong?

  • Sending an email: not reversible
  • Deleting a file: not reversible (unless there's a backup)
  • Drafting an email: reversible — it's just a draft
  • Querying a database: reversible — it's read-only
  • Writing to a database: depends on whether there's an audit log

Impact: How much damage does a mistake cause?

  • Posting to a social media account with 1 million followers: high impact
  • Adding a row to an internal test database: low impact
  • Transferring money: high impact
  • Summarising a document: low impact

Plot these two axes and you get a rough guide:

              High Impact
                   |
    ASK ALWAYS     |    ASK ALWAYS
  (even if         |    (especially
   reversible)     |     irreversible)
                   |
Reversible --------+-------- Irreversible
                   |
   PROCEED         |    LOG AND MONITOR
   AUTONOMOUSLY    |    (proceed, but
                   |     flag for review)
              Low Impact

Low impact + reversible → let the agent proceed. High impact or irreversible → ask first.

Concrete Examples

Let the agent proceed without asking: - Reading files, documents, or databases to gather information - Drafting text (email, code, report) for the human to review before sending - Searching the web or querying an API for data - Running read-only SQL queries - Creating a new file in a designated working directory

Ask before proceeding: - Sending any external communication (email, Slack message, SMS) - Posting to social media or any public-facing channel - Deleting files or records - Making purchases or financial transfers - Calling an external API that creates or modifies data - Deploying code to production - Granting or modifying permissions

Always ask, no exceptions: - Any action where a mistake could cause legal, financial, or reputational harm - Actions that affect people outside the system (customers, partners, the public) - Anything the agent itself flags as uncertain

The Confirmation Step in Practice

A HITL checkpoint doesn't have to be complicated. At its simplest it's just showing the user what the agent is about to do and waiting for a yes/no:

def confirm_action(description: str, details: dict) -> bool:
    print(f"\nAgent wants to: {description}")
    for key, value in details.items():
        print(f"  {key}: {value}")
    response = input("\nProceed? (yes/no): ").strip().lower()
    return response == "yes"

# Before sending an email
if confirm_action(
    "Send email",
    {
        "to": "client@example.com",
        "subject": "Project update",
        "preview": draft[:200],
    },
):
    send_email(draft)
else:
    print("Action cancelled.")

In a web UI, this becomes a modal or a review card. In a Slack bot, it becomes a message with approve/reject buttons. The pattern is the same regardless of the interface.

Confidence-Based Thresholds

Some agents can estimate their own confidence in a decision. When confidence is high, proceed. When it drops below a threshold, ask.

This requires the agent to actually have a reliable confidence signal — which not all do. LLMs don't produce well-calibrated confidence scores by default. If you use this pattern, test whether the model's self-reported confidence actually correlates with correctness before trusting it to gate actions.

A safer version: define explicit uncertainty signals. If the agent reaches a step where it needs to make an assumption, or where two valid approaches exist, that's a natural checkpoint — not because confidence is low in a numeric sense, but because the task has a fork the human should choose.

The Cost of Over-Asking

Asking for permission too often has real costs:

  • Users start approving without reading ("approval fatigue")
  • The agent feels like extra work rather than a time-saver
  • People route around the agent entirely and do things manually

Approval fatigue is particularly dangerous because it turns a safety mechanism into a rubber stamp. If your agent asks for confirmation 20 times per workflow, users will click yes without looking by step 5. You'd be better off with 3 well-chosen checkpoints that users actually engage with.

The rule: each confirmation request should be for something specific, consequential, and non-obvious. If the agent is asking permission to do something the user would always approve, automate it and remove the checkpoint.

The Cost of Under-Asking

The opposite failure is an agent that acts freely in areas where it shouldn't:

  • Sends a half-drafted email because it interpreted "send this" too literally
  • Deletes files matching a pattern that was broader than intended
  • Makes an API call that triggers billing on a third-party service
  • Posts a message to the wrong channel because it misread the recipient

These aren't hypothetical — they happen in production. The common thread is an irreversible action taken without the human realising it was about to happen.

Logging as a Fallback

For actions you decide to let proceed without asking, log them in enough detail that you can reconstruct what happened and why. This doesn't prevent the action, but it closes the feedback loop:

logger.info(
    "agent_action",
    extra={
        "action": "write_file",
        "path": file_path,
        "triggered_by": task_id,
        "agent_reasoning": reasoning_summary,
    },
)

A human reviewing logs after the fact can catch patterns of mistakes before they escalate. Combined with an undo mechanism where possible, this gives you a safety net without adding friction to every step.

Designing for Trust Over Time

The right level of autonomy isn't fixed — it should increase as the agent earns trust. A reasonable progression:

  1. Start tight. Require approval for all consequential actions while you're learning where the agent makes mistakes.
  2. Identify the safe patterns. After a few weeks, you'll see which confirmations always get approved without issue. Automate those.
  3. Keep humans in the loop for edge cases. The long tail of unusual situations is where agents fail. Keep checkpoints for anything outside the normal pattern.
  4. Review the logs regularly. Automated actions that never get reviewed are where silent mistakes accumulate.

This is how trust is earned with any system — human or AI. Start cautious, automate what's proven safe, and keep oversight where the risk is real.

Quick Checklist

  • Map every action your agent can take onto reversibility and impact
  • Require confirmation for irreversible or high-impact actions
  • Keep the number of confirmation steps small enough that users don't develop approval fatigue
  • Log all autonomous actions with enough detail to audit them later
  • Provide an undo path where the action allows it
  • Review which confirmations are always approved and automate those
  • Never automate actions that affect people outside the system without explicit sign-off