The Handoff Problem: Why Multi-Model AI Pipelines Quietly Corrupt Good Research

Consider a hypothetical but representative handoff. A research model returns a careful finding: an association observed in one dataset, in a controlled setting, with limited generalization beyond the domain tested. Correlation, not cause. A preprint, not a settled result.

Then a writing model receives a compressed summary and produces a clean sentence: Studies show that X causes Y.

Nothing threw an error. The JSON parsed. The next stage ran. The prose reads well. And yet the sentence is now wrong in a way the original was not. The handoff succeeded syntactically and failed epistemically.

That gap is the subject here. Not model selection, not prompt engineering, not which vendor has the smartest reasoner this quarter. The quieter problem is broken claim lineage: evidence crosses a model boundary as persuasive prose instead of as inspectable structure.

If you build multi-model pipelines, this is a reproducibility problem. So let me put the fix on the table before the diagnosis.

The transfer contract, up front

If the interface between stages is where value leaks, then the interface deserves a schema. The practical version is a claim-level record with five fields:

claim: "..."
evidence: "source URL + exact support"
scope: "population, task, model, jurisdiction, date"
uncertainty: "fact / estimate / interpretation / prediction"
citation: "canonical URL and metadata"

Add counterevidence, status, or requires_review where it helps. The point is a discipline, not this exact YAML: this five-field schema is my evidence-informed proposal, not a standardized or experimentally validated format. What the evidence supports is the underlying idea — that structured transfer preserves more than free-form prose in controlled settings — not this particular set of keys.

The rule that makes it work is a division of labor. The writing model may change language and structure freely, because rephrasing is the entire reason it exists. What it may not do is change the semantics of the evidence. Any new factual claim that appears in the draft but not in the ledger routes back to research before it can stay.

Why teams build these pipelines anyway

It would be easy, and wrong, to conclude that multi-model systems are a mistake. They are attractive for concrete reasons: you can run genuinely parallel exploration, assign specialist models to specialist tasks, give each stage its own context window and tools, and spend more total inference effort on a hard problem than any single pass would allow.

Anthropic's engineering team described a production research system built around a lead researcher delegating to subagents, each acting as an information filter that compresses findings back into the lead's context. They report internal gains on breadth-first research tasks, where multiple independent search directions can run at once. That is a real advantage, and worth naming before we start finding fault.

It comes with a bill. Anthropic reports that its multi-agent system used about 15× as many tokens as ordinary chats; it also found that tightly coupled tasks were a poor fit and that vague delegation produced coordination failures. These are Anthropic's internal results on its own system and data, not an industry benchmark. But the shape of the trade-off is instructive: specialization buys you parallelism and depth, and charges you in cost and coordination risk.

The question is not whether to specialize. It is how to specialize without letting the truth mutate at the seams.

The handoff is an information bottleneck

Here is a useful lens, drawn from a decision-theoretic analysis of delegated systems. In a technical preprint, Ao, Gao, and Simchi-Levi model multi-agent planning as a communication network and argue that, absent new exogenous signals, additional stages merely reorganize the same underlying evidence. A relay of models is bounded by what a single centralized decision maker with the same information could achieve. Adding stages does not add facts.

That reframing separates three things pipeline design tends to conflate:

• New evidence entering the system — a retrieval call, a tool result, a fresh source. This genuinely expands what the system knows.
• The same evidence being rewritten — a summary of a summary. This changes the wording, not the knowledge.
• Verification that actually checks against evidence — comparing a claim to its source, rather than to its own fluency.

Most "add another agent" instincts fall into the second bucket while feeling like the first. If every stage sees a transformed version of the same source material, the central design problem is not intelligence but preservation: what survives compression, and what quietly falls out.

The same authors report that free-form relay conditions in their controlled experiments lost decision-relevant information, while a more structured, posterior-style message format preserved more of it. These are controlled multiple-choice tasks, and the result rests on the paper's formal assumptions, so treat it as a design lens rather than a measured guarantee about deployed systems. As a lens, it holds up: the interface between stages does more work than the stages themselves. That is exactly why the YAML above is worth the trouble.

How research mutates without anyone lying

None of this requires a model to hallucinate. The failures are mostly ordinary transfer losses. Drawing on the edge-level categories proposed in AgentAsk, a preprint on inter-agent message errors, plus some editorial synthesis of my own, here is a working taxonomy you can audit:

1. Data gap. A necessary fact or caveat never crosses the boundary. (AgentAsk's term.)
2. Signal corruption. A number, qualifier, or citation changes during transfer. (AgentAsk's term.)
3. Referential drift. "This study" or "they" no longer points to the intended source. (AgentAsk's term.)
4. Scope inflation. A narrow observation becomes a general claim. (My synthesis, not AgentAsk's.)
5. Verification theater. A reviewer checks fluency or format instead of evidence alignment. (My synthesis.)

The first three are AgentAsk's; the last two are my editorial labels for patterns visible in writing pipelines. Scope inflation is the case that opened this article: a qualified finding becomes unqualified, and the prose gets cleaner as it becomes less faithful.

The prose can become cleaner while the claim becomes less faithful. A structured record makes the losses visible.

These transfer failures are not the whole story, but they are consistent with broader trace evidence. The MAST taxonomy of multi-agent failures, accepted to the NeurIPS 2025 Datasets and Benchmarks Track, analyzed 1,642 annotated execution traces across seven frameworks and identified fourteen failure modes spanning system design, inter-agent misalignment, and task verification. Among the inter-agent modes: failure to clarify, information withholding, ignored input, and reasoning-action mismatch. Among the verification modes: incomplete and incorrect verification.

Two honest caveats. Much of the large-scale annotation was produced by a calibrated LLM annotator (human inter-annotator agreement was κ=0.88, with the LLM annotator calibrated to κ=0.77 against humans), and the reported framework failure rates use different benchmarks and are explicitly not directly comparable. The percentages are dataset-specific, not universal failure probabilities. What matters is the recurrence of failures that a smarter base model alone cannot address because they are rooted in system design, coordination, and verification.

More reasoning is not monotonically safer

A tempting fix is to let models exchange more of their reasoning at each step, on the theory that more deliberation converges on truth. Sometimes it does; the effect is not reliable.

A preprint on runtime monitoring of error propagation measured what happens when models exchange reasoning traces on quiz subsets across cybersecurity, machine learning, and networking. Paired reasoning often improved accuracy, but not everywhere. In one networking condition, one model's accuracy decreased after the exchange, and in some settings the additional reasoning introduced more errors than it corrected. This is a six-page preprint on multiple-choice subsets, so don't extract a universal rate from it. The defensible point: extra reasoning is another input, not a truth guarantee.

What seems to matter more is how uncertainty travels. DebUnc, a preprint on communicating uncertainty in agent debate, found that an attention-based method for incorporating uncertainty was the only tested approach that consistently matched or exceeded standard debate across its benchmarks, and that the benefit grew as uncertainty estimates improved. The specific method requires open-source model access and code modification, which rules it out for many proprietary APIs. Still, the direction is worth keeping: uncertainty is not noise to be smoothed away before the next stage. It is data the next stage needs — and it belongs in the uncertainty field of the contract.

The machinery already exists

Structured transfer is a design choice you already have the machinery for, though that machinery alone proves nothing. The OpenAI Agents SDK handoff documentation (observed at v0.18.3) exposes an input_type for structured handoff arguments and input_filter/history controls for what the receiving agent sees, and it explicitly distinguishes model-generated metadata from application state. Those are mechanisms for controlling the handoff. They are not evidence that any particular handoff design improves factual accuracy. You still have to decide what crosses the boundary; the SDK just gives you the door.

Specialize the models, preserve claim lineage, and verify the public result anonymously.

Clarify at the edge, audit after the draft

Two control loops help, at different times.

The first is clarification at the boundary. AgentAsk added a learned clarifier at inter-agent message edges without redesigning the orchestration, and reported framework-level averages improving by roughly 3.29 to 3.45 percentage points across five benchmarks and four frameworks, with a GPT-5 clarifier reaching roughly 4.40 to 4.69 points. These are the authors' preprint results on benchmark tasks — math, QA, code — not open-ended research writing, and a clarifier cannot fix an intrinsic model error. The transferable habit is simple: when a handoff is ambiguous or incomplete, ask before assuming.

The second loop runs after the draft exists — a dedicated evidence audit that treats the finished prose as a suspect rather than a product:

• map every material sentence back to a ledger entry;
• flag any sentence with no supporting entry;
• verify that each citation points to the exact claim it is attached to;
• restore dropped caveats and scope;
• escalate anything unresolved to a human.

This is a production pattern, not a novel idea. Anthropic describes a dedicated CitationAgent that maps report claims to source locations, and an evaluation rubric that checks factual accuracy, citation accuracy, completeness, source quality, and tool efficiency — that is, whether claims align with sources, not merely whether the writing is good. Human testers also caught source-selection failures that the automated evaluation missed, a practical reason to keep a person in the loop even when the automated checks look thorough.

What not to do

• Do not hand the next model only a persuasive summary. Persuasiveness is exactly the property that hides missing evidence.
• Do not equate consensus with verification. Agreement between agents is not confirmation against a source.
• Do not treat an LLM judge as the sole source of truth. MAST itself relied on a calibrated LLM annotator only after establishing human agreement first.
• Do not add agents that only restate the same evidence. That is more cost for the same information.
• Do not publish from the drafting stage.

One dry note on the consensus point: adding a reviewer that reads only the summary is less defense in depth and more a second opinion from the same rumor.

Implementation checklist

• [ ] Pick one boundary between two models and inspect the artifact that actually crosses it.
• [ ] Replace that informal summary with a claim-level record carrying claim, evidence, scope, uncertainty, and citation.
• [ ] Let the writing model rephrase freely; block it from changing evidence semantics.
• [ ] Route any draft claim absent from the ledger back to research.
• [ ] Add a clarification step at ambiguous or incomplete handoffs.
• [ ] Run a post-draft evidence audit: map sentences to entries, flag unsupported ones, verify citation alignment, restore caveats and scope.
• [ ] Keep a human in the loop for source-selection failures automation misses.
• [ ] Never publish from the drafting stage.

References

• Cemri, M., Pan, M. Z., Yang, S., et al. Why Do Multi-Agent LLM Systems Fail? NeurIPS 2025 Datasets and Benchmarks Track; arXiv v3, 2025-10-26. https://arxiv.org/abs/2503.13657v3
• Anthropic Engineering. How we built our multi-agent research system. 2025-06-13. Vendor-authored engineering report; internal evaluations. https://www.anthropic.com/engineering/multi-agent-research-system
• OpenAI. Handoffs — OpenAI Agents SDK. openai-agents-python v0.18.3, accessed 2026-07-26. https://openai.github.io/openai-agents-python/handoffs/
• Lin, B., et al. AgentAsk: Multi-Agent Systems Need to Ask. arXiv preprint v2, 2026-01-19. https://arxiv.org/abs/2510.07593v2
• Ao, R., Gao, S., Simchi-Levi, D. On the Reliability Limits of LLM-Based Multi-Agent Planning. arXiv preprint v1, 2026-03-27. https://arxiv.org/abs/2603.26993v1
• Sakib, S. K., Das, A. B. Preventing Error Propagation in Multi-Agent AI through Runtime Monitoring. arXiv preprint v1, 2026-06-27. https://arxiv.org/abs/2606.29026v1
• Yoffe, L., Amayuelas, A., Wang, W. Y. DebUnc: Improving Large Language Model Agent Communication With Uncertainty Metrics. arXiv preprint v2, 2025-02-22. https://arxiv.org/abs/2407.06426v2