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 October 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 navigation between agent nodes: a handoff tool returns a Command naming the node to execute next, with graph: Command.PARENT to route out of the current agent. Subgraphs allow nested agent groups (a subgraph is a graph used as a node in another graph); the Send primitive, returned from a conditional edge, fans one step out to many node invocations. The framework also ships an interrupt primitive used for human-in-the-loop gates, resumed with Command(resume=...). The documentation is at docs.langchain.com / multi-agent / handoffs (accessed October 2026); the graph-level primitives are documented under langgraph / graph-api and langgraph / use-subgraphs.

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. In June 2025 Google donated A2A to the Linux Foundation, which now governs it as a vendor-neutral project. The spec is at a2a-protocol.org (accessed July 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 press release (February 2024), which describes the assistant handling roughly two thirds of customer chats while leaving customers the option of asking for a live agent. Klarna widened that human path considerably in May 2025; the customer support intake page carries the sequence. 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.