Over the past two years the most common extra layer in agent products has been an orchestrator plus executors: one model breaks the task apart, hands out the pieces and assembles the final answer, while a set of sibling models run their own web searches. The rationale is straightforward. Context stays shorter, work runs in parallel, and when something goes wrong the blame has somewhere to land.
What has been missing is a clean controlled test of whether that arrangement actually pays for itself. A recent arXiv preprint (arXiv:2611.16526, from Ruhr University Bochum and its Center for Trustworthy AI) does exactly that, and the conclusion runs against the grain: delegating the work usually loses accuracy rather than gaining it.
Thirty-two controlled comparisons, and delegation usually loses money
The paper fixes four models (Claude Sonnet 4.5, GPT-5, gpt-oss-120b and Qwen3-30B-A3B-Thinking-2507, with reported knowledge cutoffs ranging from June 2024 to July 2025) and four factual datasets (book publication years, the ages of Nobel laureates, World Bank GDP growth rates, and iF Design Award product launch years). Each dataset is then split into a pre-cutoff and a post-cutoff half, aligned to the models' own knowledge boundaries. All retrieval goes through the same SerpAPI-backed Google search interface, and four configurations are compared: no tools at all, a single agent searching directly, forced delegation, and optional delegation.
The result: across all thirty-two model-by-dataset-by-cutoff combinations, optional delegation performs worse than a single agent with direct tool access in twenty-two of them (better in seven, tied in three), and forced delegation performs worse in twenty-one (better in ten, tied in one).
The gap widens once the questions sit beyond what the models already know. The single agent goes from 0.77 pre-cutoff to 0.75 post-cutoff, a three-point slide. Optional delegation falls from 0.74 to 0.64, down fourteen points, and forced delegation falls from 0.77 to 0.66, down thirteen. In other words, when the model already holds the answer in its parameters, delegation costs little; when the model is genuinely ignorant, delegation starts charging interest. Measured against direct tool use, the gap grows from one point to nine points for forced delegation and from three points to eleven for optional.
The widest single case is GPT-5 on the post-cutoff GDP task: the single agent reaches 0.89, optional delegation drops to 0.43, and forced delegation to 0.35.
Three places the accuracy leaks out
First, orchestrators inject their own assumptions into the queries they hand off, and those assumptions are frequently wrong. Under forced delegation, GPT-5 adds medium information to as many as 98% of its pre-cutoff queries. On post-cutoff books, only four to six percent of the medium information it adds under delegation turns out to be correct. The paper offers a concrete example: asked for the release year of a 2026 book called The Night We Met, GPT-5 rewrote the request as the release year of the song of the same name by Lord Huron. The executor duly returned 2015, which was correct for the question it was handed and wrong for the question the user asked.
Second, there is an information boundary. The executor returns only its final answer; the orchestrator never sees the tool traces in between. When a page refuses to open, 13% of open_url calls fail with a 403 under the single agent, and that climbs to 20% under optional delegation and 17% under forced; separately, 3%, 5% and 5% of calls return pages with no extractable content. Even when a 403 does occur, the single agent still answers roughly 73% of the affected items correctly, against 54% for forced delegation and 52% for optional. The gap is not about retrieval skill. It is that the orchestrator never learns the retrieval failed.
Third, tool use turns wasteful. Forty percent of item-level search trajectories contain multiple web_search calls, and across five thousand five hundred seventy-seven consecutive query pairs, nine percent were judged to be the same search asked twice. Redundant searching rises from 7% under direct tool use to 11% under delegation, and for GPT-5 alone it goes from 8% to 19%. The expensive part comes later: even when the executor answered correctly, the orchestrator would still challenge the answer or simply hand the task back out again. On pre-cutoff GDP, GPT-5 re-delegates up to 54% of tasks, and even for correct executor answers the re-delegation rate climbs from 6.4% to 8.8%.
Two prompt tweaks do not rescue it
The paper tried the two cheapest available interventions. Asking executors to explicitly report inaccessible pages and their URLs moved GPT-5 on the GDP task from 0.43 to 0.51 and from 0.35 to 0.44, still far below the single agent's 0.89; and for GPT-OSS the same instruction made things worse, dropping optional delegation from 0.70 to 0.62 and forced delegation from 0.73 to 0.64. The second intervention, forbidding semantically equivalent queries, barely moved anything: Qwen's redundancy fell only from 19.4% to 17.7%, while GPT-5's actually rose from 4.4% to 6.6%. The models neither searched less often nor became less repetitive.
Not an isolated result
At the mechanism level, a different team reached a similar conclusion in a different setting. A controlled evaluation from Amazon and the University of Washington (arXiv:2611.12953) holds the model, the tasks and the tools fixed and varies only the architecture, comparing four designs across eight arms - a function-calling single agent, a skill-augmented agent, centralized multi-agent orchestration and a triage swarm - over thirteen enterprise SOPs. Every coordinated arm spends 1.4 to 4.7 times the tokens and 2.6 to 5.8 times the latency of the single agent for gains that are usually small and rarely significant, which is why the paper calls the single agent the efficient default. Their third finding is the interesting one: implementation quality outweighs the single- versus multi-agent choice. A plausible multi-agent implementation loses to the single agent, but after a targeted redesign it becomes the only arm that significantly beats the baseline, 75.6% against 67.4%.
So what
Multi-agent is currently an architectural default rather than an argued-for decision. The value of this preprint is that it took the default apart and measured it: same tools, same budget, same hard questions, and adding one layer of delegation does not buy higher accuracy. It loses points precisely where the model knows nothing.
If your system already has an orchestrator, the practical recommendation is to treat the question of whether delegation pays as a hypothesis you test, not a premise you inherit. Measure the single-agent baseline on the same task set first, then look at per-task accuracy after delegation alongside the token and latency multiples. Track two specific signals: whether retrieval failures inside the executor ever reach the orchestrator, and how often the orchestrator re-delegates after the executor was already right. The paper is candid that the promising directions are not more prompt engineering but targeted training, search-progress tracking, and mechanisms for selectively passing evidence and failures across the boundary.
Multi-agent is not off the table. But the next time someone reviews an agent architecture, the question worth asking is what the orchestrator actually bought you, not whether you have one.