What is an agent handover?
An agent handover (or agent transfer) is a permanent ownership shift in a multi-agent AI system, where a caller agent transfers total conversation control to a specialized target sub-agent. Once transferred, the target sub-agent becomes the sole active responder for all subsequent conversation turns.
- Relay Ownership Control: Unlike delegation (which returns results to the caller), a transfer shifts the conversation context permanently (e.g. from an intake triage agent to a billing specialist).
- Single-Transfer Guarantee: Runtime guardrails enforce that only one transfer wins per turn, preventing ownership thrash and routing ambiguity.
- Audited Target Routing: Allowed transfer targets are checked against validated routing graphs at both design time and execution time.
Transfer is the exception, not the default
Anter's authoring guidance is explicit: delegation is the default; transfer is the justified exception. If both would work for an edge, choose delegation unless you can articulate why permanent ownership must move.
Use transfer when the user should be talking only to the specialist from now on — a triage sub-agent handing off to the owner of that domain, or a terminal domain switch. Use delegation when the caller needs the result back to continue.
Rules the runtime enforces
- A sub-agent can only transfer to targets in its own allowed-targets list. This is validated when the design is saved and re-checked at run time.
- Only one transfer can win per turn. If a turn requests two transfers, or mixes a transfer with delegations, the runtime treats the routing intent as ambiguous and nudges before falling back to a deterministic choice.
- An externally-linked (cross-agent) sub-agent can never be a transfer target — only a delegation target. "Becoming" another organisation's agent has no coherent meaning. Attempting it produces a
route_forbiddentermination. - Transfers are capped by their own budget, tracked separately from the delegation cap.
The classic mistake
Transfer-first authoring. Wiring peer edges as transfers because it seems simpler produces ownership thrash: sub-agents bounce control back and forth, the runtime issues oscillation nudges, and runs terminate with transfer_limit_exceeded far more often than delegate-first graphs.
The decision test for any edge: does the caller need the result back to synthesize or continue? If yes, it is a delegation, no matter how it reads in prose. "Get data from X, then answer" is always a delegation.