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.
| Stage | What happens | Typical failure |
|---|---|---|
| Trigger | Agent or rule detects the task is out of scope | Handoff fires too early or never |
| Target selection | Correct specialist or human queue is chosen | Request routed to the wrong specialist |
| Context packaging | History, state and intent are bundled | Key facts lost or excessive tokens passed |
| Control transfer | Runtime activates the receiving agent | Two agents reply or none replies |
| Acceptance and return | Receiver confirms and may hand back | Endless loops between agents |
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 type | Recipient | Control after transfer | Typical use |
|---|---|---|---|
| Peer handoff | Another specialist agent | Receiver owns the conversation | Triage agent routing to billing support |
| Delegation | Subagent or worker agent | Returns to the delegating agent | Research subtask inside a larger plan |
| Human escalation | Human operator or reviewer | Human decides or resolves | Refunds above a limit, legal questions |
| Cross-system handoff | Agent in another framework or vendor | Remote agent owns the task | Interoperation through the Agent2Agent protocol |
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 compared with related coordination patterns
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.
| Pattern | Who keeps control | Context flow | Best fit |
|---|---|---|---|
| Agent handoff | Receiving agent | Shared history or summary moves forward | Customer-facing specialist routing |
| Tool calling | Calling agent | Structured arguments and a result | Deterministic actions and lookups |
| Orchestrator-worker | Central orchestrator | Tasks out, results back | Parallel research and synthesis |
| Agent swarm | Shifts dynamically among peers | Shared state or message board | Exploratory, loosely structured work |
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.
| Situation | Recommended approach | Reason |
|---|---|---|
| Short conversation, same trust level | Pass full history | Little cost and no information loss |
| Long session or many tool outputs | Pass structured summary | Avoids context window overflow |
| Receiver has narrower permissions | Filter sensitive fields | Enforces least privilege |
| High-impact or irreversible action | Escalate to a human | Keeps accountability with a person |
| Repeated back-and-forth transfers | Set a maximum handoff count | Prevents loops and runaway cost |
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.