Agent Handoffs: Patterns for Agent-to-Agent and Agent-to-Human (2026)

A handoff is the moment control passes from one actor to another. Handoff primitives are documented as named operations in OpenAI Swarm, LangGraph, and the A2A protocol; consolidated nowhere. The reference below is the cross-framework view, with the BPMN-correct shape for each pattern and the common failure modes.

Agent-to-agent handoff

OpenAI Swarm handoff primitive

OpenAI Swarm (released October 2024 as an experimental orchestration library) defines handoff as a first-class operation: an agent returns a reference to another agent, and the runtime continues execution under the receiving agent. The Swarm pattern is documented in its repository, github.com/openai/swarm (accessed April 2026). The functionality has been carried into the OpenAI Agents SDK as the handoff abstraction documented at openai.github.io / openai-agents-python / handoffs.

LangGraph handoff and interrupt

LangGraph (LangChain's graph-based agent framework) models handoffs as edges between graph nodes. Subgraphs allow nested agent groups; the Send primitive supports parallel handoffs. The framework also ships an interrupt primitive used for human-in-the-loop gates. The documentation is at langchain-ai.github.io / langgraph / concepts / multi_agent (accessed April 2026).

A2A protocol

The A2A (Agent-to-Agent) protocol, announced by Google and a coalition of partners in April 2025, is an open specification for cross-vendor agent handoffs over HTTP. It defines a discovery and a task-delegation API. The spec is at google.github.io / A2A (accessed April 2026). Cross-vendor handoffs are BPMN message flows across pools; the A2A specification provides the wire format.

Agent-to-human handoff

Reviewer pattern

The agent acts; the human reviews the output before the action is final. LangGraph's interrupt primitive is the canonical implementation: the graph pauses, the human approves or modifies, the graph resumes. In BPMN, the reviewer pattern is the agent service-task followed by a downstream bpmn:userTask in the human lane.

Arbiter pattern

The agent attempts to resolve the case. On low confidence or out-of-scope input, the case escalates to a human arbiter. The most-cited public example is Klarna's AI assistant operator report (February 2024) which describes the assistant resolving roughly two thirds of customer chats with the remainder routed to human agents. The escalation is a BPMN bpmn:signalEvent thrown in the agent lane and caught in the human lane.

Fallback pattern

The agent gives up. After N attempts or on a hard error, the agent terminates its branch and the case is queued for a human. The fallback pattern is documented in the OpenAI Agents SDK as max_turns and in LangGraph as a recursion limit; both surface a terminal state that downstream code interprets as “ask a human”.

BPMN representation of handoffs

Three BPMN shapes carry the handoff semantics. The choice depends on where the receiving actor sits.

• Sequence flow (bpmn:sequenceFlow, spec §10.7.1) , the receiving actor is a different lane in the same pool. The default within a single organisation.
• Message flow (bpmn:messageFlow, spec §10.7.4) , the receiving actor is in a different pool. The default for cross-organisation handoffs (e.g. invoking an external scheduling agent).
• Signal event (bpmn:signalEvent, spec §10.7.6) , the receiving actor is one of several possible catchers. The default for escalation patterns where the human queue is the catcher and the agent does not name a specific human.

Common handoff failure modes

Loss of context

The receiving agent does not have the conversation history, the user context, or the in-progress state. The fix is explicit context payload on the handoff primitive (Swarm passes the conversation; LangGraph passes the state object); the BPMN-correct way to model the payload is a data object attached to the message flow.

Infinite handoff loops

Agent A hands to B, B hands back to A, repeat. The fix is bounded recursion (Swarm and LangGraph both surface a recursion limit) and a gateway with a counter on the BPMN diagram (an bpmn:exclusiveGateway guarding a retry).

Silent escalation drop

The escalation is thrown but no human queue is configured to catch it. The case sits in limbo. The fix is a catching event with a timer boundary (bpmn:boundaryEvent with a timer); if the human does not pick up within the SLA window, the case routes to a dead-letter queue or to a fallback supervisor.

Related pages

• Human vs agent swimlanes : when to add the human gate.
• BPMN with AI agents : the spec-correct element reference.
• Customer support intake : the canonical escalation pattern in production form.
• agenticorgchart.com / supervisor-pattern : the org-chart-shaped sister view.