arXiv:2608.16055 ★ 93 Aug 17, 2026

Fact Decay at the Seams: Why a Chain of AI Agents Loses Critical Details When Handing Off a Task

Key result

Between 56% and 85% of the facts found are lost when a task is handed off between AI agents, and that's not a bug but a systematic pattern. A structured handoff protocol lets you preserve risks and exculpatory details when a task is split across several chats or stages. The catch is that the model writing the summary decides on its own what matters, and decides wrong. The method replaces free-form retelling with a mandatory checklist of categories: risk, justification, uncertainty. The model no longer decides what to keep, it just lists, and losses drop from 85% to nearly zero.

TL;DR

When a task is split across several AI agents or stages (one gathers information, another makes the decision), an important fact found in the first step often never makes it to whoever is supposed to act on it. The model handing off the work writes a short summary, and that summary is exactly where details get lost: they seem minor to the model but are critical for the final decision.

The problem is systemic, not random. On a weak model (32B), passing through 1-2 "seams" lost 56% to 85% of the facts found; on a stronger model (gpt-4.1-mini), only 3-6%. And crucially, fact loss cuts both ways. If a risk signal got lost, the agent missed the problem (under-escalation). If an exculpatory fact got lost, the agent raised a false alarm (over-escalation). The model that found the fact isn't to blame; the model that wrote the summary and left it out is.

The authors' fix is a structured handoff protocol: don't let the model summarize freely; make it explicitly list facts under mandatory categories (risk / justification / uncertainty), without shortening or skipping anything.

How the Mechanism Works

STEP 1: An agent/stage gathers information → finds a fact (a risk or a justification)
STEP 2: The agent writes a summary for the next stage → the fact may get "filtered out" as minor
STEP 3: The next agent decides based only on the summary → an error (missed risk or false alarm)

The more "seams" (separate chats, stages, subagents) and the stricter the isolation between them, the stronger the effect. If a single agent does everything itself, with no handoff through a summary, there's no loss at all.

Example in Practice

Task: A real estate agency screens a prospective tenant through a chain of two prompts: the first searches for information (credit history, reviews from former landlords), the second uses the summary to decide whether to rent out the apartment.

Prompt (stage 1, the collector):

You are an analyst screening a tenant named {name} before renting out an apartment.
Review all available information (credit history, reviews from past landlords, 
income data).

After the analysis, write a HANDOFF REPORT using the structure below. Don't skip a single 
fact you found, even if it seems insignificant:

1. RISK FACTS — list each one separately; don't merge or summarize.
2. EXCULPATORY FACTS — list each one separately.
3. UNCERTAIN / needs verification.

Don't draw a conclusion yourself; just fill in the report.

Prompt (stage 2, the decision-maker, new chat):

You are deciding whether to rent the apartment to tenant {name}.
Your only information is the handoff report below. In your decision, explicitly 
reference EVERY item under "risk facts" and "exculpatory facts".

Report:
{paste the report from stage 1}

Result: At the first stage the model will produce a structured list of facts in three categories, with no free-form retelling. At the second stage the decision will rest on the full list rather than a trimmed summary in which a negative review ("didn't pay for two months") could have quietly vanished as an "unimportant detail".

Why It Works

When a model writes a free-form summary to pass along, it decides on its own what to include and what to toss. That decision is made on the fly and is often wrong: an important but not very prominent fact seems minor and doesn't make it into the text. The next stage sees only the summary, not the source data, and can't recover what was lost.

A strength of LLMs is that they follow an explicitly defined structure and checklists well. If you ask them to "list all facts in such-and-such category, without shortening", the model fills in the list more completely than in a free retelling, because it no longer gets to decide for itself what's "important".

Control levers: - Number of categories in the checklist → add your own categories for the task (for example, "legal risks" and "financial risks" separately) - The requirement "list each fact separately, don't summarize" → removes the model's temptation to compress the text - Length of the chain of stages/chats → the more intermediate handoffs, the higher the risk of loss; for critical decisions keep the chain as short as possible - Model at each stage → if you save money with a cheap model for the "collector", the risk of losing facts goes up; it's worth using a strong model specifically at the summary-writing stage

Prompt Template

You are an analyst gathering information for this task: {task}.
Review all available data.

After the analysis, write a HANDOFF REPORT for the next stage using this structure:
1. FACTS AGAINST / RISKS — list each one separately; don't merge them.
2. FACTS FOR / JUSTIFICATIONS — list each one separately.
3. UNCERTAIN — needs further verification.

Don't draw a final conclusion yourself, and don't shorten the list of facts for the sake of brevity.

---

[In a separate chat/message]

You are making a decision on this task: {task}.
Your only information is the handoff report below.
In your decision, explicitly reference EVERY item from the "risks" and "justifications" categories.

Report: {paste the report from the previous step}

Fill in: {task} is the specific check/decision (vetting a counterparty, selecting a candidate, analyzing a contract).

🚀 Quick start: paste this into the chat:

Here's a template for structured handoffs between stages of AI analysis. Adapt it to my task: {your task}.
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask which categories of facts matter for your specific task (risks, legal nuances, financial metrics), because that determines exactly what must not get lost in the handoff between stages.

Limitations

⚠️ Model strength changes the scale of the problem: weak models lose facts heavily (56-85%), strong ones lightly (3-6%). If the chain uses a cheap/weak model for the intermediate summary, the risk of loss is higher.

⚠️ The effect only appears when handing off through a compressed summary: if the next stage sees the source data in full (not just someone else's digest), there's no loss. This was confirmed on the "single-agent" variant with no handoffs.

⚠️ Tested in a narrow domain (banking compliance): the authors candidly admit they didn't show whether the effect holds on other task types or on top-tier GPT-4-class models, but the mechanism itself (isolation via summary) looks universal.

⚠️ Access to rules/instructions doesn't help: giving the model all the rules in context at once, or letting it search the rules, doesn't change the result. The problem isn't knowing the rules; it's passing specific facts between stages.

Resources

Fiducia-bench: an open benchmark with 100 tasks; the policy and the verifier are publicly available. Authors: Bowen Li, Guojun Wang (Uber).

Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.

Research digest

Key result

Principle

Simple rule: replace the free-form summary with an explicit checklist of facts by category. Each fact gets its own line, no merging or shortening. The model that found the risk at the first stage isn't to blame for losing it. The one that wrote the summary and tossed it as an "insignificant detail" is.

Why it works

LLMs hold their accuracy just fine at the fact-finding stage. They break at the compression stage, when they decide for themselves what to keep and what to cut. A weak model (32 billion parameters) throws out 56-85% of its findings. A strong model (gpt-4.1-mini), only 3-6%. A checklist takes away the model's right to decide what matters: it just fills in the items instead of filtering. And the loss cuts both ways: lose a risk and the problem goes unnoticed; lose a justification and you sound a false alarm.

When to apply

Multi-step prompt chains and multi-agent systems → specifically for vetting counterparties, selecting candidates, analyzing contracts, due diligence (checks before a deal), especially when one chat searches for information and another makes the decision based only on the summary. Not suitable for single-agent scenarios with no handoff between chats: there the model sees the source data in full, so there's nothing to lose.

Mini recipe

1. Give the collector a structure: ask it to list facts under three categories (risks, justifications, uncertain) with no generalizations. 2. Forbid shortening: explicitly write "don't summarize; each fact on its own line, even if it seems minor". 3. Pass the report in full: the next stage gets only this structured list, not a free retelling in the model's own words. 4. Check completeness: ask the final stage to explicitly reference every checklist item in its decision, so you can see nothing got lost.

Examples

[BAD]: `Screen the tenant Miller and briefly describe what you found` [GOOD]: `Screen the tenant Miller. Write a handoff report: 1) RISKS — each fact on its own line, don't merge, 2) JUSTIFICATIONS — each fact on its own line, 3) UNCERTAIN — needs verification. Don't draw a conclusion yourself, and don't shorten the list for brevity.`

In plain words

When you split a complex task across several AI agents, you're setting up a game of telephone. The problem is that the models make decisions not based on all the data, but on whatever the previous colleague "pre-chewed" for them. That's the moment compliance breaks: the first agent finds a critical detail but, while writing its summary, decides it's no big deal and throws it out. In the end the final boss gets a sanitized report and approves something that should never have been approved.

It's like sending an intern to inspect a house before you buy it, and he comes back and says: "The walls are painted, the windows are fine." You happily buy the place, and then it turns out the intern simply forgot to mention the huge crack in the foundation, because he considered it an "architectural quirk". You decide based on his digest rather than reality, and you end up losing a pile of money, even though the information about the problem was technically found.

The study calls this policy degradation through decomposition. It works like this: the first agent writes a summary, trying to save space or simplify the text, and that's exactly where things go sideways. It tosses out "inconvenient" facts that don't fit the overall narrative, and the second agent, the one making the decision, ends up in an information vacuum. If the source said the client is suspected of fraud, but the summary only kept "active user of financial services", the system will approve the loan without blinking.

This principle holds for any complex chain: from tenant screening to content moderation and legal analysis. Anywhere one AI "sets the stage" for another, there's a risk that important triggers get erased. The more stages in the chain, the higher the chance that the output is complete nonsense, because each subsequent agent works with scraps of meaning instead of the full picture.

The main takeaway: don't let agents write free-form summaries when safety or rules are on the line. Either pass along the full context without cuts, or force the model to use strict checklists instead of creative retellings. Otherwise your slick multi-agent system turns into an assembly line for laundering errors, where nobody is to blame for anything but everything has fallen apart.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on Fact Decay at the Seams: Why a Chain of AI Agents Loses Critical Details When Handing Off a Task arXiv:2608.16055