Agent handoff

Also known as: agent handover

On this page 7

Agent handoff is the explicit transfer of control and task ownership from one AI agent to another agent, or to a human, together with the context needed to continue the work. In AI agents and multi-agent systems within artificial intelligence, a handoff lets a general triage agent pass a conversation to a specialist, or lets an automated agent escalate a risky decision to a person, without the user starting over.

A handoff differs from an ordinary tool call because the receiving agent takes over the conversation rather than returning a result to the caller. The quality of a handoff depends on what context travels with it, who is allowed to trigger it, and whether control can return to the original agent afterward. It is also called agent handover.

How an agent handoff works

An agent handoff follows a short, repeatable sequence: detect the need, select a target, package context, transfer control and confirm acceptance. In many agent frameworks the handoff is exposed to the language model as a special tool, for example transfer_to_billing_agent, so the model decides when to hand off with the same tool calling mechanism it uses for other actions.

When the model calls that tool, the runtime does not execute an external function. Instead, the agent harness switches the active agent, loads the receiving agent’s instructions, tools and permissions, and passes along the conversation history or a curated summary. From that point, the receiving agent produces the replies.

The table below breaks the process into stages and shows what can go wrong at each one.

StageWhat happensTypical failure
TriggerAgent or rule detects the task is out of scopeHandoff fires too early or never
Target selectionCorrect specialist or human queue is chosenRequest routed to the wrong specialist
Context packagingHistory, state and intent are bundledKey facts lost or excessive tokens passed
Control transferRuntime activates the receiving agentTwo agents reply or none replies
Acceptance and returnReceiver confirms and may hand backEndless loops between agents
Stages of an agent handoff

Types of agent handoff

Agent handoffs vary by direction, recipient and reversibility. A peer handoff moves a conversation sideways between specialists, a delegation hands a bounded subtask down to a subagent, and an escalation moves a decision up to a human reviewer as part of a human-in-the-loop design.

The following table compares the main handoff types and when each one fits.

Handoff typeRecipientControl after transferTypical use
Peer handoffAnother specialist agentReceiver owns the conversationTriage agent routing to billing support
DelegationSubagent or worker agentReturns to the delegating agentResearch subtask inside a larger plan
Human escalationHuman operator or reviewerHuman decides or resolvesRefunds above a limit, legal questions
Cross-system handoffAgent in another framework or vendorRemote agent owns the taskInteroperation through the Agent2Agent protocol
Common handoff types

Cross-system handoffs rely on shared protocols and agent cards that describe what a remote agent can do, how to reach it and what input it expects. Without such a contract, a receiving agent cannot know whether it is able to accept the task.

Agent handoff is one of several ways to coordinate agents, and the distinguishing feature is transfer of conversational ownership. In the orchestrator-worker pattern, a central orchestrator keeps control and only collects results from workers; in a handoff, the original agent typically steps out of the loop until control returns.

The table below contrasts handoff with neighboring patterns in agent orchestration.

PatternWho keeps controlContext flowBest fit
Agent handoffReceiving agentShared history or summary moves forwardCustomer-facing specialist routing
Tool callingCalling agentStructured arguments and a resultDeterministic actions and lookups
Orchestrator-workerCentral orchestratorTasks out, results backParallel research and synthesis
Agent swarmShifts dynamically among peersShared state or message boardExploratory, loosely structured work
Handoff and neighboring coordination patterns

Designing reliable handoffs

A reliable handoff requires explicit criteria, a defined context contract and observable transitions. Each agent’s instructions should state precisely which requests it owns and which it must hand off, because vague scopes cause the model to answer outside its competence instead of transferring.

Context packaging is the most delicate decision. Passing the full conversation history preserves nuance but increases token cost and can expose data the receiver should not see; passing a structured summary is cheaper and safer but may drop details. Many teams pass a summary plus key fields such as customer identifier, intent and actions already taken.

The decision table below summarizes common design choices.

SituationRecommended approachReason
Short conversation, same trust levelPass full historyLittle cost and no information loss
Long session or many tool outputsPass structured summaryAvoids context window overflow
Receiver has narrower permissionsFilter sensitive fieldsEnforces least privilege
High-impact or irreversible actionEscalate to a humanKeeps accountability with a person
Repeated back-and-forth transfersSet a maximum handoff countPrevents loops and runaway cost
Handoff design decisions

Every handoff should also be logged as a distinct event in agent observability tooling, recording the source, the target, the reason and the context passed. These traces make it possible to evaluate routing accuracy and to find the exact point where a task went wrong.

Risks and common mistakes

Most handoff failures come from lost context, unclear ownership or excessive permissions. Users notice them immediately, because a poorly designed transfer forces them to repeat information or receive contradictory answers.

  • Context amnesia: the receiving agent lacks earlier facts and asks the user to repeat them.
  • Handoff loops: two agents keep transferring a request that neither considers its own.
  • Privilege leakage: a handoff passes data or tool access the receiver should not have, which violates agent permissions policy.
  • Silent escalation failure: a human queue is unstaffed, so the user waits with no answer and no status.
  • Prompt injection across agents: untrusted text in the handed-off context instructs the receiver to take unintended actions.

The short version

An agent handoff is like being transferred to the right department on a phone call. The first person listens, realizes someone else should help, and passes the call along with a note explaining the problem, so the caller does not have to start again.

With AI agents, the note is the context that travels with the request. A good handoff sends the right agent, or a human, everything needed to continue, and nothing that agent should not see.

Where it makes a difference

An online retailer runs a support assistant built from three agents: a triage agent, an order-status agent and a returns agent. A customer writes that a package arrived damaged and asks for a replacement. The triage agent recognizes a return request and hands off to the returns agent, passing a summary with the order number, the item and the reported damage.

The returns agent checks the order and offers a replacement. When the customer asks for a refund of more than 500 dollars, a policy rule triggers a human escalation, and a support specialist receives the full summary and approves the refund in a few minutes. Because each transfer carried the necessary context, the customer never repeated the order details, and the logged handoff events showed the team that routing was correct in that conversation.