How a Mission Hands Off Between Specialist Agents

Everyone building multi-agent systems obsesses over how capable each agent is. The thing that actually decides whether the work gets done is quieter and harder: what survives the moment one specialist hands the job to the next.

Watch a single request move through a system built out of several agents, and the interesting failures never happen inside an agent. They happen in the gaps between them. A customer escalation comes in that needs four different competencies to resolve: someone to read the account history and understand what the customer is actually complaining about, someone to pull the billing and usage records from three internal systems, someone to check the contract and the compliance constraints on what can be offered, and someone to draft and send the resolution. Each of those is a well-defined job that a focused agent can do genuinely well. And yet the escalation goes sideways — the resolution contradicts the contract, or it answers a question the customer didn't ask, or it quietly drops the one detail that made the case urgent — and when you trace it back, no agent was wrong. The research agent understood the problem perfectly. The drafting agent wrote a clean, well-reasoned message. What failed was the pass between them: the urgency, the specific constraint, the piece of context that mattered got thinned out or lost somewhere in the seam, and each agent downstream did excellent work on a slightly corrupted version of the task.

This is the part of multi-agent work that almost nobody sells and almost everybody underestimates. The demos are about how smart the individual agents are, because a smart agent is easy to show. The real engineering problem is the handoff — passing context, state, and intent from one specialist to the next without loss — and it is hard for the same reason that it is hard to relay a complicated message through five people at a party. Every pass is a chance to drop something, and the things most likely to get dropped are exactly the ones that were implicit, situational, or hard to put into words: precisely the details that separated this case from the generic version of itself.

The single agent never hands off, and that is its ceiling

The obvious way to avoid a bad handoff is to avoid the handoff entirely. Give the whole job to one agent, let it hold the account history and the billing records and the contract and the draft all in a single context, and there is no seam to lose anything in. For simple tasks this is genuinely the right answer, and it is why a lot of early agent work looked deceptively easy — a single capable model, handed a bounded problem, does not have a coordination problem because there is nothing to coordinate. The context lives in one place, the reasoning happens in one place, and nothing has to be transferred anywhere.

The trouble is that this approach has a ceiling, and you hit it faster than you expect. A single agent asked to do everything has to hold every tool, every system's access, every domain's rules, and every step's intermediate state in one working memory at once, and both the model's attention and its reliability degrade as that load grows. It starts to confuse which system it was querying, to lose track of a constraint it established twenty steps ago, to blur two subtasks that should have stayed distinct. The competence that made it good at any one of the jobs gets diluted across all of them. You can push the ceiling up with a larger context window and a stronger model, but you cannot remove it, because the fundamental issue is that expertise is not free to stack — a generalist juggling six specialties is worse at each than a specialist would be, and the work that enterprises actually need done is made of specialties. The single agent avoids the handoff by refusing to divide the labor, and refusing to divide the labor is exactly what caps how hard a problem it can take on.

A script hands off perfectly and carries nothing

If one agent won't scale, the other familiar instinct is to script the coordination — decompose the process into fixed steps, define exactly what each step passes to the next, and wire them together in a pipeline. This is how integration software has always worked, and its handoffs are, in a narrow sense, flawless: the payload from step three to step four is a typed, predictable structure, and it arrives intact every time. There is no ambiguity and no loss, because a script only ever passes the fields its author decided in advance to pass. That determinism is the whole appeal, and for processes that never vary it is entirely sufficient.

The problem is that a script can only carry what its author anticipated, and it carries data, not intent. It moves the account ID and the balance and the ticket status from one stage to the next with perfect fidelity, and it has no way to move the thing that actually mattered about this particular case — that the customer is a strategic account three days from renewal, that the billing discrepancy is the second one this quarter, that the constraint in the contract makes the obvious resolution impossible. Those are judgments about meaning, and they live in the gaps between the fields, in the reasoning about the situation rather than the situation's data. When a case arrives that doesn't fit the shape the author drew — and in real operations most of the hard ones don't — the script either drops the exception on the floor or routes it, unresolved, to a human, because a fixed pipeline can only hand off along the paths it was built with. It never loses the data and it never once transfers the intent, which is why scripted automation has always been able to move work between systems and never able to move understanding between them. This is also why so much of what now gets sold as autonomous coordination disappoints: Gartner has predicted that over forty percent of agentic AI projects will be canceled by the end of 2027, pointing among other things to "agent washing," and a great deal of what wears the agent label underneath is a scripted pipeline with a language model bolted to one end — a system whose handoffs are still fixed, still lossy about meaning, still incapable of passing anything its designer did not foresee.

The reasoning core is what carries intent across the seam

What makes coordinated specialist agents work where both the single agent and the script fail is that the handoff stops being either an accident of one big context or a rigid transfer of fixed fields, and becomes something deliberately managed. In a well-built system there is a Reasoning Core that holds the mission — not the individual steps, but the intent behind them and the state of the whole so far — and it is the core, not the specialists, that owns the coordination. When it hands a subtask to a specialist agent, it passes not just the raw data but a framing of what this agent needs to accomplish and why it matters in the context of the larger goal, drawn from the Enterprise Knowledge the organization has made available and from the Observations the mission has already gathered. When the specialist returns, the core does not simply forward the output to the next stage; it interprets what came back against everything it already knows, updates its understanding of the mission, and decides what should happen next in light of it. The seam is still there — the labor is still divided among specialists who are each good at one thing — but the intent survives the crossing, because something with judgment is standing at the seam reconstituting it rather than a pipe passing bytes.

This is what an AI Mission actually is when it is built properly: not a chain of agents each triggering the next, but a set of Autonomous AI Workers coordinated by a core that carries the thread of purpose through every handoff and keeps the specialists working on the real task rather than a degraded copy of it. The plumbing underneath matters too — a shared substrate like the Model Context Protocol is what lets a specialist reach the specific system it needs without every agent having to hold every integration — but the plumbing is not the hard part. The hard part is that passing intent, unlike passing data, requires something on both sides of the handoff that can understand meaning, and it is why a reasoning core distributing work to specialists succeeds at coordination that a rules engine distributing work to microservices never could. It is also why the Human-in-the-Loop, in these systems, sits at the genuine decision points rather than at every mechanical seam: the core can carry the routine handoffs itself and knows to stop and surface the case where the judgment genuinely belongs to a person, because it is reasoning about the mission rather than executing a fixed route through it. This orientation — dividing work among specialists without losing the thread that binds it — is the quiet center of what a growing number of organizations mean by the move toward an autonomous enterprise: not a smarter individual assistant, but coordination that finally holds.

The reframing worth carrying out of all this is that you have been evaluating multi-agent systems by the wrong measure. The instinct is to ask how capable each agent is, because capability is visible and demoable and easy to be impressed by. The question that actually predicts whether the work gets done is how much survives the handoff — whether the intent, and not just the data, makes it from one specialist to the next intact. A system of brilliant agents connected by lossy seams will underperform a system of ordinary agents coordinated by a core that never drops the thread, every time, because the mission was never the sum of what each agent knew. It was the thing being passed between them, and the only systems that finish it are the ones built to keep that thing whole.