AI Agent Handoff: When Your Product Should Ask, Act or Stop
Decide when an AI agent should ask, act within clear bounds, or stop and hand control to a person, with real data on how agents and users share control and a contract you can copy.
Share
An AI agent handoff is the moment an AI feature passes control back to a person: to ask for missing information, to get approval before a consequential action, or to stop and let someone take over. A handoff contract decides, before launch, when the product should ask, when it may act on its own, and when it must stop, and what the user sees in each case.
Key takeaways
Agents already stop themselves more often than people stop them. In Anthropic's study of about 500,000 Claude Code sessions, the agent asked for clarification more than twice as often on the hardest tasks as on simple ones, and more often than humans interrupted it (Anthropic, 2026).
The top reason the agent stopped was to present a choice between approaches (35%). The top reason humans interrupted was to supply missing context or corrections (32%). Both are product-context problems, not model problems.
OpenAI's agent guide names two triggers for human intervention: exceeding failure thresholds and high-risk actions that are sensitive, irreversible or high-stakes (OpenAI).
Model confidence is not permission. "90% sure" does not authorise sending an email or changing a customer record.
A human reviewer is not a safety net by default. In a pooled analysis, wrong advice from decision-support systems raised the risk of an incorrect decision by 26% (Goddard et al., 2012).
What is an AI agent handoff?
The term has two meanings, and it helps to separate them.
Agent-to-agent handoff. In OpenAI's Agents SDK, handoffs let one agent delegate a task to another, such as a triage agent passing a refund request to a refund agent. The model sees each handoff as a tool, for example transfer_to_refund_agent (OpenAI Agents SDK). OpenAI's guide describes it as a one-way transfer that carries the conversation state with it.
Agent-to-human handoff. The agent transfers control to a person because it cannot or should not continue. OpenAI's guide gives two examples: in customer service, escalating to a human agent; for a coding agent, handing control back to the user.
This article is about the second kind, which is a product decision rather than an orchestration detail. A product agent can recommend a next step, prepare it, or carry it out. Those are three different behaviours, even when the screen shows one friendly "Continue" button. The question a handoff contract answers is: what may this product decide on the user's behalf, with which information, and what happens when the answer is uncertain?
Users care about getting this right. In Stack Overflow's 2025 survey, 86.9% of developers were concerned about the accuracy of information from AI agents, and 81.4% had security and privacy concerns about their data when using them (Stack Overflow, 2025). A clear handoff policy addresses both: the agent does less on weak evidence, and it touches less without permission.
That is product work. The PM brings the domain judgement: what counts as a reasonable action, which trade-offs are acceptable, and which mistakes require the user to take over. Engineers turn that policy into production behaviour and make it reliable. The PM is not taking over code ownership.
Why is "human in the loop" too vague for an AI agent?
A brief that says "keep a human in the loop" leaves the hard questions open:
Which person reviews, and do they have the context to judge?
Are they reviewing a suggestion, a draft, or an action already taken?
Can they change the action, or only approve it?
What happens if nobody responds?
Which mistakes must never be delegated?
Frameworks ask teams to answer these, but they do not answer them for you. The NIST AI Risk Management Framework 1.0 asks organisations to define roles for human-AI configurations (GOVERN 3.2), to document processes for human oversight (MAP 3.5), and to have mechanisms to supersede, disengage or deactivate an AI system that behaves outside its intended use (MANAGE 2.4) (NIST).
The EU AI Act goes further for high-risk systems. Article 14 requires that the people overseeing them can stay aware of automation bias, disregard, override or reverse the output, and interrupt the system through a "stop" button or similar procedure (EUR-Lex). After the Digital Omnibus, those obligations apply to Annex III high-risk systems from 2 December 2027 (EUR-Lex, Regulation 2026/1744). Most product agents are not high-risk systems, but ask, override and stop are a good minimum for any of them.
The review itself also needs design. Goddard and colleagues reviewed 74 studies on automation bias and found that, when a decision-support system was wrong, it raised the risk of an incorrect human decision by 26%. A reviewer who sees a confident recommendation and an "Approve" button is not an independent check unless the product shows the evidence and makes disagreement easy.
When should an AI agent ask, act or stop?
Use three routes, and choose between them by consequence and authority, not by the model's confidence score.
Ask when the system lacks information or authority that could change the decision. Ask one concrete question, show why the answer matters, and let the user choose. If the missing detail is optional, offer a visible default.
Act when the task is well specified, the action is within what the user asked for, and the consequences are acceptable if the system is wrong. Keep the action visible and easy to inspect or undo.
Stop when the system cannot proceed responsibly: the request is outside the product's permitted scope, the evidence is too weak for the consequence, a required source is unavailable, a failure limit has been hit, or the next step would cross a boundary the user has not authorised. Explain why and offer a next step, such as editing the request or handing it to a person.
Route
Use when
What the user sees
Example
Ask
Missing or conflicting information would change the outcome
One question, why it matters, 2-4 choices
"Prioritise by account fit or by recent buying signal?"
Act
Request is clear, action is in scope and reversible
The result, what changed, an undo
Draft reply saved to the user's drafts
Act after confirmation
Action is in scope but consequential
A preview and an explicit confirm
Send the reply to the customer
Stop
Out of scope, too little evidence, failure limit hit, or unauthorised
The reason and a next step or human contact
"I can't change billing details. Here's who can."
Confidence is not permission. A model saying it is 90% sure does not create the right to send an email, change a customer record or commit a product decision. The route depends on the task, the evidence, the user's authority and the cost of being wrong. For decisions that return a fixed answer, such as classify, route or score, the AI decision-making framework covers how to set thresholds from the cost of errors. For deciding how reversible an action is, see one-way vs two-way door product decisions.
How do AI agents and people share control today?
Anthropic's February 2026 study is the best public data so far. It analysed about 500,000 interactive Claude Code sessions and 998,481 tool calls from its public API (Anthropic, 2026).
Why the agent stopped itself:
Reason Claude Code paused
Share
To present a choice between approaches
35%
To gather diagnostic information or test results
21%
To clarify a vague request
13%
To request credentials or access
12%
To seek approval before acting
11%
Why people interrupted: to provide missing context or corrections (32%), because the agent was slow, hanging or doing too much (17%), and to take the next step themselves (7%).
How trust changed with experience: new users (under 50 sessions) used full auto-approve in about 20% of sessions, rising to over 40% by 750 sessions. Experienced users also interrupted more, in about 9% of turns against about 5% for users with around 10 sessions. Anthropic reads that as active monitoring rather than abandoned oversight.
What the risk profile looked like on the API: 80% of tool calls came from agents with at least one safeguard, such as restricted permissions or approval requirements; up to 73% appeared to have a human in the loop (the authors call this an upper bound); and only 0.8% of actions appeared irreversible.
Three lessons for product teams follow:
Design the "ask" for choices, not just gaps. The single biggest reason an agent paused was to offer a choice between approaches. Make that a first-class screen with clear options.
Most interruptions are missing context. A third of human interruptions supplied context or corrections the agent did not have. Better product context up front reduces both asks and interruptions. The PRD template for AI coding agents shows one way to provide it.
Design for intervention, not approval of every step. Anthropic recommends giving users visibility and simple ways to redirect an agent, rather than requiring sign-off on each action. Users who trust the agent more still want a fast way to step in.
How do real products implement ask, act and stop?
Claude Code's permission modes are a useful shipped example, because each mode is a different handoff policy (Claude Code docs):
Claude Code mode
What it does without asking
Handoff route it encodes
Manual (default)
Reads only; asks before edits, shell commands and network access
Ask before every write
acceptEdits
Reads, file edits and common file commands inside the working directory
Act on low-risk, reversible changes; ask for the rest
plan
Reads and explores; edits blocked until you approve a plan
Ask once, up front, with a plan
auto
Everything, with a classifier reviewing each action
Act, with a reviewer model that can stop
dontAsk
Pre-approved tools only; anything else is denied
Act inside a fixed envelope; stop outside it
Two details are worth copying. First, auto mode blocks a list of high-consequence actions by default, including production deploys and migrations, force pushes, mass deletion on cloud storage and merging a pull request no human has approved. That is a stop list. Second, if the classifier blocks an action 3 times in a row or 20 times in total, auto mode pauses and Claude Code goes back to asking. That is a failure threshold, exactly the first trigger in OpenAI's guide. Deny rules apply in every mode, which is the hard boundary.
OpenAI's guide adds a way to decide which actions need which route: give each tool a low, medium or high risk rating based on read-only versus write access, reversibility, required permissions and financial impact, then pause for checks or escalate to a person before high-risk calls. Its examples of actions that should trigger human oversight are cancelling orders, authorising large refunds and making payments.
Anthropic's own guidance on agents makes the same point from the engineering side: agents can pause for human feedback at checkpoints or when they hit blockers, should get ground truth from the environment at each step, and need stopping conditions such as a maximum number of iterations (Anthropic, 2024).
How do you write an AI agent handoff contract?
For each AI-assisted workflow, write an action envelope in plain language, short enough that product, design, engineering and support can all review it.
Contract field
Question to answer
User and job
Who is trying to finish what?
Allowed actions
What may the product prepare or do, and with what risk rating?
Required context
Which facts, permissions or sources must be present?
Ask condition
What missing or conflicting detail goes back to the user?
Stop condition
What makes proceeding unacceptable?
Failure threshold
After how many failed attempts does it hand off?
Confirmation
Which actions need explicit review or approval?
Recovery
How can the user correct, undo or hand off the result?
Review trigger
What signal or date reopens the contract?
The envelope describes behaviour, not implementation. It does not prescribe a model, prompt, API or architecture; those belong in the engineering plan once the team agrees what the product should do.
Copy this into a product brief:
## Handoff contract: [workflow]
For [user] trying to [job], the product may [allowed action]
when [required context] is present.
Ask when: [decision-changing information is missing or conflicting]
Stop when: [boundary, weak evidence, unavailable source or unauthorised step]
Failure threshold: hand off after [n] failed attempts at [step]
Confirm before: [consequential action] (risk: low / medium / high)
Recovery: the user can [undo / edit / reassign] by [mechanism]
Owner: [PM] for policy, [engineer] for implementation
Review when: [signal, incident or date]
Then walk through real examples with a PM, an engineer, a designer and someone close to the work. Change the contract until each example has an understandable route and the user can tell what happened.
Keep a decision record
When the team approves a contract, record what is allowed, which users or situations it covers, the evidence behind it, who owns it, which test cases check it, and what would trigger a review. If the product later asks too often, acts on weak evidence or stops without a useful next step, the team can trace the behaviour back to the policy. A product decision log is enough. It also prevents ownership blur: PMs define intended behaviour and trade-offs; engineers own implementation, permissions, reliability and operational safety.
Worked example: prioritising sales prospects
This is an illustrative example. Imagine an AI feature that helps a sales team sort prospects. A large company with a strong funding profile may look attractive. A smaller company with a buying signal from last week may be more timely. Both facts can be true; the product still needs a policy for which matters more.
The contract might say:
Allowed action: suggest a priority tier (risk: low, because it is a suggestion) and explain the evidence behind it.
Required context: the team's account-fit criteria, and the date and source of each buying signal.
Ask: request the team's priority rule if "best prospect" has not been defined.
Stop: do not infer a buying signal from company size, and do not claim an account is ready to buy without a source.
Failure threshold: if the enrichment lookup fails twice for an account, mark it "needs manual review" rather than guessing.
Confirmation: a salesperson reviews the tier before it changes the shared pipeline (risk: medium, because others act on it).
Recovery: the reviewer can change the tier and record why.
The contract exposes a decision the model cannot settle: should this team prioritise fit, timing or an explicit balance of the two? The PM brings the domain expertise, or convenes whoever has it, and makes the trade-off inspectable. The model applies the chosen rule; it should not invent one.
How do you test a handoff contract before launch?
Build a small set of representative cases and check whether the product picks the right route and explains it clearly. Include cases where:
The request is complete and the action is reversible (expected: act).
A required fact is missing and different answers would change the outcome (expected: ask).
Two sources disagree (expected: ask, showing both).
The user asks for something outside the stated permission (expected: stop).
The evidence is too thin for the consequence (expected: stop or ask).
A dependency fails or a source cannot be reached (expected: retry up to the threshold, then hand off).
For each case, record the expected route, the reason and what the user should see: "Ask because the buying-signal date is missing; show the account source and let the salesperson add or skip it." That is testable. "Be careful" is not.
Review real outputs with people who know the domain. When reviewers disagree, do not average their scores and move on; find the hidden policy choice. One reviewer may optimise for fit and another for urgency. Resolve it, write it into the contract and add a case that makes the distinction testable. The loop is: observe a case, identify the judgement, agree the policy, update the cases, review the behaviour again. The AI evaluation framework for product teams covers how to grow these cases into an eval set.
These cases do not replace production monitoring or engineering safeguards. They make sure the team agrees what the product is meant to do.
How do you make "ask" a useful product state?
Asking is not automatically safer. Too many interruptions push the work back onto the user and make the feature feel unfinished. A question should appear only when the answer could change the result. Microsoft's 18 Guidelines for Human-AI Interaction, which synthesise more than 20 years of research, treat how a system behaves when it is wrong as a design phase of its own, separate from regular interaction (Microsoft Research, 2019).
A useful handoff screen shows:
what the system has worked out so far
the missing or conflicting information
why it changes the next action
two to four clear choices, including "decide later" where that is safe
If the user can safely correct the result after seeing a preview, a confirmation step may beat a question. If the product can take a reversible action and show a clear undo, it may not need to interrupt at all.
Common mistakes with AI agent handoffs
Using confidence as permission. A probability tells you how sure the model is, not whether the user authorised the action.
Asking for everything. Constant approval prompts train users to click "Approve" without reading, which is automation bias by design.
Stopping with no next step. "I can't help with that" without a reason or route to a person is a dead end.
No failure threshold. Without a retry limit, an agent can loop on a failing step. Pick a number and hand off when it is reached.
One contract for every action. Read-only lookups and payments need different routes. Rate each action.
Hidden policy. If reviewers disagree on the right answer, the contract is missing a rule, not the model.
No review trigger. Agents and users change. Name the signal or date that reopens the contract.
Where Specky fits
Specky's own MCP server follows this pattern for agents that work in a product workspace: agents create PRDs, insights, decisions and tickets in a draft or proposed state, the PM Inbox is the review queue, and auto-publishing happens only when the user explicitly asks in the same turn. You can record each handoff contract in the Decision Log next to the evidence that shaped it. See Specky for technical PMs for the wider workflow.
Frequently asked questions
What is an AI agent handoff?
An AI agent handoff is when an AI feature transfers control, either to another agent or to a person. In product design it usually means the agent-to-human case: the agent asks for missing information, requests approval before a consequential action, or stops and lets someone take over. A handoff contract defines those triggers before launch.
When should an AI agent ask for confirmation?
Before actions that are consequential but within scope: sending messages to customers, changing shared records, spending money or anything hard to reverse. Rate each action low, medium or high by write access, reversibility, permissions and financial impact, and require confirmation at medium or high. Low-risk, reversible actions can run with a visible undo instead.
What is the difference between agent-to-agent and agent-to-human handoff?
Agent-to-agent handoff is delegation inside a system: in OpenAI's Agents SDK, a triage agent hands a refund request to a refund agent through a tool call. Agent-to-human handoff returns control to a person because the agent cannot or should not continue. The first is an orchestration choice; the second is a product decision about authority and risk.
Is "human in the loop" enough to make an AI agent safe?
No. A reviewer only helps if they have the evidence, the time and an easy way to disagree. A review of 74 studies found that wrong decision-support advice raised the risk of an incorrect decision by 26%. Specify who reviews what, what they see, what they can change and what happens if nobody responds.
How often should an AI agent interrupt the user?
Only when the answer could change the outcome or the action needs authority the agent lacks. In Anthropic's 2026 data, Claude Code asked for clarification more on complex tasks than simple ones, and experienced users interrupted in about 9% of turns. Measure your own ask rate and the share of asks users answer meaningfully.
Does the EU AI Act require a human handoff for AI agents?
For high-risk systems, Article 14 requires that overseers can understand limits, stay aware of automation bias, override or reverse output, and stop the system. After the Digital Omnibus, those obligations apply to Annex III high-risk systems from 2 December 2027. Most product agents are not high-risk, but the same ask, override and stop pattern is good practice.