Pattern Matrix/White Paper/C4

Problem

When multi-agent systems fail, it is often not because any single agent is too weak, but because the handoff dropped the baton. A front-line agent holds all of the customer's information; when it transfers to the second tier, it passes only "the verbatim text of the customer's last sentence." The second tier picks up like a colleague who just walked in—with no idea who the customer is, why they are upset, or what has already been said—and so it asks again.

The Handoff Chain passes a task sequentially across multiple agents while preserving information, responsibility, and traceability. What moves between agents is the state completed by the previous leg, and that state needs an explicit schema. Human call centers use the same idea in a warm handoff: the outgoing representative briefs the incoming one before transferring responsibility.

Classification: Collaboration × Chain

• Vertical axis · Collaboration: the output of one agent is the input of the next—relay-style multi-agent collaboration. Each leg is a peer with a clearly scoped responsibility, with no supervisor as a stable anchor—this is its biggest difference from Hierarchical Delegation.
• Horizontal axis · Chain: N agents pass strictly in sequence, neither in parallel nor in a loop. This differs from Fan-Out/Aggregate, where N workers run at the same time, and from Adversarial Review, where there is back-and-forth debate. Order sensitivity is its defining trait.

Solution and mechanics

A single handoff keeps the baton from dropping through three things:

1. Responsibility splitting: the long process is split into N agents with clearly scoped responsibilities, where each leg is good at only one thing and need not understand the whole process.
2. Structured packaging: when the previous leg finishes, it packages the critical state into a HandoffPacket and passes it to the next leg—not a dump of conversation history, but a schema-driven structure. This is its biggest difference from a single agent chaining multiple prompts: in the latter, context carries forward naturally, whereas a Handoff Chain spans agents and sessions, so state must be made explicitly schema-driven.
3. Controlled handover: before the handoff, a permission gate judges whether this handoff is reasonable; a chain-length cap prevents endless passing; and each handoff writes to an audit log.

A HandoffPacket should carry at least a five-layer schema:

Applicability

• Tiered customer support: L1 triage, L2 technical, L3 engineering, Director escalation, where the model grows stronger, tool permissions open up, and the SLA escalates tier by tier.
• Approval workflows with professional division of labor: in healthcare, triage nurse to general practitioner to specialist to chief; in law, paralegal to associate to partner; in sales, SDR to AE to CSM to VP.
• Handing control back from an execution-type agent: when an agent finishes its own responsibility and needs to return control to a higher layer (see the enterprise example for one case).

Four conditions must hold at once: clear professional division of labor, a definable order, structurable state, and an SLA escalation mechanism that is central to the business.

Known failure modes

• Cold transfer: only "the user's last sentence" is passed to the next leg, which receives none of the preceding context. The signal to watch for is the customer being asked questions they have already answered immediately after the handoff, with the shift in mood from calm to frustrated coinciding with the handoff point. The fix is that the HandoffPacket must contain at least the five-layer schema.
• Loss of decision provenance: the Artifacts all get passed along, but the why behind the decisions does not—so the next leg sees a pile of outputs without knowing on what basis the predecessor took that path, and so reruns the process or overturns the predecessor's decisions. "Artifacts survive handoff, decisions don't," unless decisions are given a dedicated schema field.
• Oscillation loop: the same pair of agents hands back and forth repeatedly. Set a hard chain-length cap from the role graph and SLA, constrain can_handoff_to, record a visited set, and escalate when the cap is reached.
• Over-handoff: by default an LLM tends to over-hand off, wanting to kick anything slightly difficult to the next agent. You can add a classifier before the handoff to examine "is this handoff reasonable, or should I finish it myself."
• Misuse on short tasks or without clear roles: Directly completable tasks, general-assistant scenarios, and latency-sensitive conversations may not justify the handoff overhead. Scenarios with high loop risk should use Hierarchical Delegation, letting the supervisor be the anchor.

Verification and metrics

• Chain length in hops: Track handoff count and cap exhaustion. Configure the maximum from the role graph and business SLA, then escalate when reached.
• Post-handoff repeat-question rate: Measure how often the receiving agent asks for information already captured. This is the most direct symptom of a cold transfer.
• Decision retention rate: Check whether prior conclusions, reasons, and evidence arrive intact. A low value indicates that the HandoffPacket has degenerated into a raw history dump.
• SLA attainment rate (accounted by tier): the proportion of agents at each tier completing within their SLA window, combined with sentiment carry over to monitor changes in customer mood along the escalation path.

Reference implementation

HandoffChain.execute(request, initial_agent, max_hops):
                current, prev_packet = initial_agent, None
                for sequence in 1..max_hops:
                    output = run_agent(current, prev_packet)   # input is a structured packet, not raw history
                    packet = build_packet(prev_packet, output) # cumulatively inherit artifacts/decisions/rejected
                    audit(packet)
                    if output.complete: return result
                    next = output.handoff_to
                    if next not in current.can_handoff_to:      # permission gate: prevent skipping tiers + prevent oscillation
                        return escalate_to_human()
                    prev_packet, current = packet, next
                return escalate_to_human()                      # exceeding max_hops escalates to a human

            HandoffPacket: five-layer schema (Goal / Artifacts / Decisions / Rejected Paths / Next Required)
            

Production implementation tiers system prompts and tool permissions by role; can_handoff_to lists permitted receivers; max_hops follows the role graph and SLA; and the audit log records data and responsibility moving across agents.

Illustrative scenario

Consider a SaaS support system that passes cases through triage, technical, engineering, and supervisory roles. A first version forwards only the customer's last message, forcing each receiver to ask again for the problem and account context. A stronger HandoffPacket carries the customer's goal, checked knowledge and scripts, decisions with their rationale, rejected paths, and the next required action. Models and tool permissions vary by role, and cap exhaustion sends the case to a human. The same mechanism can return control from an execution agent to an orchestrator when the current decision requires replanning.

Related patterns

• Prompt Chaining (Action module): a same-origin dual. Prompt Chaining is a single agent chaining multiple prompts (context carries forward naturally); the Handoff Chain is multiple agents passing explicit state across sessions (which must be made schema-driven). The key difference is whether context needs to be made explicitly schema-driven.
• Hierarchical Delegation (C1): the Handoff Chain has no supervisor and every leg is a peer, whereas Hierarchical Delegation has a supervisor as a stable anchor. When loop risk is high, returning to Hierarchical Delegation and letting the supervisor be the anchor is more stable.
• Fan-Out/Aggregate (C2): the Handoff Chain has N agents working in sequence, whereas Fan-Out has N workers working at the same time.
• Sub-Agent Isolation (C5): the Handoff Chain focuses on explicit state passing across legs, while Sub-Agent Isolation focuses on the context boundary of a sub-agent; their concerns differ, but both bear on the design of information flow between agents.

Design conclusion

The Handoff Chain uses a structured contract to pass goals, state, evidence, decisions, and responsibility. A raw conversation dump does not guarantee that the receiver knows the next action or its acceptance condition.