The agents could work. The context couldn't travel.
Multi-agent systems often fail at the handoff, not the task. Our own runs show how duplicated, missing and made-up context ruins perfectly good work.
The pitch for multiple agents usually starts with division of labour. One researches, one builds, one reviews, one coordinates. Each gets a smaller problem and uses its context window better. Parallel work makes it faster, specialists make it better. Makes sense on a whiteboard.
In practice, the hard part often isn't the research or the building. It's the gap between them. The second worker gets a summary that leaves out the one constraint that mattered. The reviewer gets the producer's conclusion as if it were evidence. The lead passes along a folder name that never existed. Four identity documents arrive through four different prompt paths and disagree about which one's in charge.
These failures can make capable agents look dumb. The intelligence is there. The shared world isn't.
A handoff is a change in who's responsible
A lot of agent frameworks treat a handoff as sending a message. Agent A sends text to agent B, done. But useful work needs more than words to cross over. The recipient needs to know what outcome it now owns, which version is current, where the file actually lives, what evidence already exists, what got rejected, what it depends on and what it's allowed to do.
If responsibility doesn't move cleanly, both sides might assume the other one is finishing it. If the file reference is roughly right, the new worker might edit a copy. If evidence isn't tied to the exact attempt, a passing check can approve the wrong version. If permissions get copied over as prose instead of being enforced where they live, the recipient can get the wrong idea about what it's allowed to do.
Restless records these boundaries through actors, Work, Attempts, file references, dependencies and permissions held at their source. A message can explain the handoff, but it doesn't create a second version of the truth about who owns what.
The folder that didn't exist, and the two workers it cost
Here's a small failure that taught us a lot. In a test company called Harbour Ledger (an offline marine-maintenance business we keep separate for testing), a Restless lead hired a producer and a critic to make a piece of company identity work. It told them the output lived in a repository and folder called company. It didn't. The output belonged in the normal company workspace, and no such checkout existed.
The company computer correctly refused the made-up location. Both the producer and the critic were replaced and re-briefed without the fake repository. The corrected pair made a proper gallery, a fresh critic accepted the exact version, and the owner accepted the prepared result. None of Restless's own wording or visual style leaked into the test company.
The models didn't fail at designing the gallery. The handoff described a world that wasn't real. Because file locations were treated as exact facts rather than suggestive text, it failed early and obviously. We changed the rules for how work gets handed over so placeholder repository names aren't allowed for ordinary workspace output any more.
Duplicated context is a kind of disagreement
The same project originally fed the company's Truth, Voice, Visual Language and Culture to workers through four separately built sections. It looked nicely modular. In reality it made every team responsible for stitching them together and spent the context four times. Worse, each one could be there, missing or updated on its own, with no single record of what the work actually got.
We replaced those four prompt paths with one Company Constitution, built the same way every time and tied to the Work. Each pillar still keeps its own source and an explicit "not available" state, but the worker gets one compiled brief with one fingerprint. The relevant parts are chosen when the Work is handed out, before a worker can run off with half the company's identity.
It saved tokens, but that wasn't the main win. It made the claim checkable. An accepted result can name the exact identity version and evidence it used. A missing pillar shows up as missing instead of being quietly filled in with something generic and plausible.
More context can hide the missing fact
When a worker fails after getting an incomplete brief, the instinct is to attach everything next time. That fixes the gap by creating a new problem: now the worker has to work out which bits are authoritative, current and relevant. A long packet can contain the missing fact and still fail to get it across.
Good context isn't just about including things. It's about order and conflict. The current goal should be obvious. Old instructions should be labelled as old. Accepted facts should say where they came from. Exact file locations shouldn't have to compete with guesses from a chat. And the reason an earlier attempt failed should be visible without making the worker rebuild the whole attempt.
A manager doesn't brief a specialist by forwarding the company archive. They pick the facts that matter, say who decides what, and describe what a useful result looks like. Agent context needs the same discipline, because the recipient can't reliably work out what the company wants from sheer volume.
Sharing everything can ruin an independent review
Producer and critic setups often give the critic the output, the reasoning and the full transcript. It's efficient, because the reviewer understands every decision straight away. It's also a massive anchor. The critic starts inside the producer's way of seeing the problem, so it might check the execution and never question the framing.
A useful critic needs the shared facts and its own responsibility, not necessarily the shared reasoning. Give it the goal, the company context, the exact thing to review and what counts as evidence. The producer's reasoning can stay available if it needs to dig, without becoming the first thing it reads.
It's not always worth it. A fresh reviewer has to rebuild some context, and an obvious automatic check doesn't need a second brain. The point is to choose independence on purpose. If the critic inherits every assumption that made the work, adding it might just produce ceremonial disagreement rather than any new evidence.
We don't have the clean experiment yet
We've seen real failures and fixes that show context matters. What we don't have yet is a clean measurement of focused briefs versus full transcripts across a fair spread of tasks. Our evaluation plan names the hypothesis, but in the live runs the context changes are tangled up with fixes to the company computer, swapped critics and other changes.
A proper experiment would keep the model, tools, task, environment and judge the same. One group gets the full transcript with who said what. The other gets a compact shared picture plus what's specific to each job. Both keep exact file and permission references. Then you judge the results blind on correctness, rediscovered facts, contradictions, questions asked to the owner, cost and time.
The answer might be that full context wins for tightly coupled creative work and focused context wins for recovery or narrow specialist jobs. That'd be more useful than one big victory claim. How you handle context should follow the shape of the work, not a fondness for small prompts.
- Measure the quality of the accepted result, not whether the worker produced an answer.
- Count unnecessary questions and rediscovered facts as context failures.
- Keep things that were left out separate from contradictions and permission confusion.
- Keep the negative results when a compact brief does worse.
Handoffs have a break-even point
Every extra worker adds the cost of briefing them and merging their work back in. That cost can pay off through independent parallel work, specialist judgement, less context overload or better evidence. It doesn't pay off just because you can split the task on a diagram.
Our coordination experiments show that the number of agents and the department labels are bad predictors of useful parallel work. What matters is whether valuable, independent work is waiting while the current workers are busy. Same goes for context: a boundary is useful when the recipient can finish something meaningful without needing constant shared updates.
If two workers need to update each other all the time, or one has to rewrite everything the other produces, the parallelism is probably just a coordination tax. Put the whole outcome under one accountable worker, or redesign the pieces so each one can finish on its own.
A handoff should be smaller than the history and richer than a summary
A summary is prose picked by the sender. A full history is evidence with no priorities. A good handoff needs a third thing: structured responsibility plus a focused story. The system carries the exact identities, versions, files, dependencies and permissions automatically, and the lead explains the current framing, what's uncertain and what it wants back.
That mix keeps things flexible. The receiving model can push back on the plan and dig into the history when it needs to. It doesn't have to guess basic facts about the organisation from a persuasive paragraph. And the sender can't quietly hand over authority just by saying it did.
Multi-agent systems will get better as models get better, but the handoff problem won't go away, because it comes from splitting responsibility in the first place. The goal isn't to make several agents feel like one mind. It's to let several minds work together without losing the boundaries that make their work useful.