Why I am replacing supervisor patterns with handoffs

I taught the supervisor pattern in our 2025 trainings. It is the right starting point for multi-agent systems: clean separation, clear orchestration, easy to draw on a whiteboard. After shipping two production systems with it, I am switching most new work to handoffs. This is one of the patterns I walk through in three patterns I broke in 2025, and the recruiting atelier reference implementation shows handoffs in a full system.

What goes wrong with supervisors

The supervisor becomes a bottleneck both for throughput and for context. Every sub-agent result has to round-trip through the supervisor, which then re-plans. That serial choke point caps how fast the system can move, and it concentrates all the context pressure in one place.

The deeper problem is recovery. When a sub-agent fails or returns ambiguous output, the supervisor often does not have the local context to fix it. The sub-agent knew exactly where it got stuck; the supervisor only sees a summary. So it loops, re-plans from a worse vantage point, or escalates. The failure happens far from the information needed to handle it, which is the worst possible arrangement.

Handoffs in practice

Each agent owns its task and decides who to hand off to next. The "supervisor" is implicit: it is the routing logic embedded in each agent's prompt. The code looks messier because there is no clean tree diagram, but the runtime behaviour is more graceful. An agent that hits trouble can hand back to the previous one with full context, not to a supervisor that has already moved on. Recovery happens where the information lives.

The trade you are making is legibility for resilience. The supervisor tree is easier to explain in a design review; the handoff mesh is easier to keep running at 2am. For most of the exploratory work I do now, that trade is worth it.

Where supervisors still win

• Workflows with strict, known-in-advance ordering, such as compliance and billing.
• Cases where you need a single audit log per request and distributed tracing is not enough.
• Systems where sub-agents must not see each other's context for security or data-isolation reasons.

How to choose, and why not to mix

Choose by the shape of the work, not by which diagram looks tidier. If the ordering is fixed and you need one clean audit trail, supervise. If the path is exploratory and recovery matters more than a clean trace, hand off. What you should not do is mix both in one system, where some steps are centrally supervised and others hand off peer to peer. That hybrid is where reliability dies, because failures can originate in either model and the recovery logic for one does not understand the other. It also makes the exit-condition design from why your agent keeps failing after 3 steps much harder to reason about. For the one-glance version of when to run agents in sequence versus in parallel, see the visual note sequential or parallel? draw the flow. For a fixed-order supervisor pipeline with read-only evaluators and a single write agent, see agentic AI content quality: 5 agents, one pipeline.

One more lever that interacts with this choice: the model you put in the routing role. I cover the cost and accuracy trade-offs of a cheaper dispatcher in Haiku 4.5 made our router 5x cheaper.

For exploratory or recovery-heavy workflows, handoffs are the new default. For deterministic pipelines, supervisors still have it. If you are designing a multi-agent system and want a second opinion on which way to lean, that is squarely the work I do in consulting and training.