What a Microsoft study on information loss in agent-based systems reveals—and why companies shouldn’t ignore it.

Everyone knows the game “Chinese Whispers”: A message is passed from person to person, and even though everyone tries their best, what ends up being communicated is often different from what was originally said. In agent-based AI, this pattern repeats itself, only unnoticed: An agent takes information from another, builds on it, and passes it on. With each handoff, the information drifts a little further from the original.

Yet agent-based AI systems actually promise the opposite. The idea is to automatically process information across entire process chains: one agent analyzes data, another makes decisions, and a third generates responses or triggers the next step in the process. For companies, this sounds like the logical next step toward greater efficiency and automation.

A recent study by Microsoft Research has systematically examined this effect. Even the three most powerful language models distort, on average, a quarter of the original document’s content after 20 consecutive processing steps on the same document; across all 19 models tested, the loss rises to about half. The damage isn’t caused by spectacular malfunctions or obvious hallucinations, but rather occurs gradually and often goes unnoticed. The result remains plausible—but it becomes increasingly inaccurate.

What does this mean for companies that are using AI agents precisely to speed up processes?

The widespread assumption: More delegation means greater efficiency

Expectations for AI agents are high. Many companies treat them like digital colleagues: a task is described once, and the process then runs largely autonomously. Because modern language models often perform well on individual tasks, it’s natural to assume that this quality will hold up across longer process chains involving multiple agents, in which each agent builds on the work of the previous one.

Researchers at Microsoft Research therefore investigated whether information is reliably preserved when a language model processes the same document over many steps. Each step builds on the result of the previous one. Does the content gradually deviate from the original, similar to what happens with human participants in a game of “Chinese Whispers”?

In the classic game of “Chinese Whispers,” people usually laugh at the end because the message is obviously distorted. In agent systems, however, such deviations often remain hidden because the results still appear consistent, logical, and professionally worded. That is precisely why they are rarely questioned.

What the study shows

The study “LLMs Corrupt Your Documents When You Delegate” by Philippe Laban, Tobias Schnabel, and Jennifer Neville (Microsoft Research) was published in April 2026 as a preprint on arXiv. For the benchmark DELEGATE-52 The researchers created 310 work environments spanning 52 professional domains, ranging from accounting to program code to musical notation. Nineteen language models were tasked with repeatedly processing the same documents: first executing one instruction, then the opposite instruction, with the original output expected at the end. After 20 such iterations, the researchers compared the result with the original. Each processing step builds on the result of the previous one, similar to an agent chain in which each agent takes over the output of its predecessor. The results are alarming: In more than 80 percent of the tested combinations of model and subject area, the researchers observed what they call “catastrophic corruption”—a term they use when at least 20 percent of the original content is distorted. Even the best model tested performed reliably—that is, with at least 98 percent agreement with the original—in only 11 out of 52 subject areas.

More important than the exact percentage is the fact that this loss usually remains invisible. The most powerful models, in particular, rarely delete content but instead modify it—errors that are only noticeable upon close inspection. It’s not obvious where the information has changed. Instead, the altered information travels through the entire chain and is used by every subsequent agent as the basis for the next decision. The end result is an answer that appears complete and sounds correct, even though the underlying knowledge base has already been eroded.

Why Greater Autonomy Doesn’t Solve the Problem

A key finding of the study contradicts a widespread assumption: Greater autonomy does not automatically lead to better results. When the researchers equipped the models with additional tools such as file access and code execution, the quality of the results did not improve—on average, it actually deteriorated by another six percentage points.

A second effect exacerbates the problem: The larger the documents being processed and the longer the chain of delegation, the faster the loss of information grows. These two factors do not simply add up; they reinforce each other. According to the study, the damage is not caused by many small inaccuracies, but by rare yet serious errors: Individual breakdowns account for about 80 percent of the total loss. The longer the chain, the more likely such a breakdown becomes, and each additional step builds upon the compromised result.

This turns a technical detail into a business risk: The answers remain convincing, logically structured, and linguistically sound. The problem isn’t their plausibility, but their origin. After all, plausibility isn’t the same as evidence. From our perspective, this is one of the biggest challenges for companies that want to use AI agents productively. When no one can trace how a result was generated, it becomes increasingly difficult to determine whether an answer is actually correct or just sounds correct.

What agent chains need: checkpoints and human-in-the-loop

Agents can orchestrate workflows and coordinate tasks, but they do not automatically guarantee that information remains accurate, complete, and consistent throughout the process. The Microsoft study notes that users must continue to closely monitor such systems. That does not mean automating less. However, an architecture is needed with checkpoints where information loss and errors are detected before they propagate through the chain of agents.

Three building blocks are crucial here:

• Traceability at every stage of processing: If you only see the final result, it’s hard to tell where information was lost or where misinterpretations occurred. That’s why each step should document the information and sources on which it is based.
• Control points at the right places: Not every intermediate step needs to be checked manually. However, where technical, regulatory, or economic risks arise, results should be verifiable and, if necessary, approved by humans (human-in-the-loop).
• Targeted access to reliable sources: Each processing step should retrieve only the information it actually needs, from defined sources rather than from the output of the previous step. Otherwise, errors and omissions will be passed along from one step to the next.

This vulnerability is highlighted by the Microsoft study: When each agent simply adopts the result of its predecessor, there is no point at which an error might be detected. The researchers themselves point out that systems in production can mitigate these effects through verification loops, for example. That is precisely what matters: an architecture that checks every step instead of passing results along unchecked.

Plausibility and Evidence: How DAPHY^® Implements This Architecture

Traditional agent systems often lack this architecture: They pass information directly to language models, which generate responses based on statistical probabilities that may seem convincing, without it being clear whether the underlying information is actually reliable. Added to this is a structural problem. The knowledge needed for a well-founded answer is rarely found in a single document, nor is it exclusively contained within the model itself; rather, it is distributed across many data sources, specialized systems, and documents. Retrieval approaches such as RAG (Retrieval-Augmented Generation: the model specifically searches its own documents before providing a response) can provide relevant information, but they do not automatically prevent hallucinations.

DAPHY^®, moresophy’s Reasoning Orchestrator, controls the individual steps of a query rather than leaving them to a single model, and therefore begins the process earlier. Before the actual reasoning begins, data and documents are semantically analyzed: terms are clearly defined, entities and relationships are resolved, and domain-specific connections are linked across systems. Only on this basis does the actual processing begin. To achieve this, DAPHY^® breaks down a query into traceable reasoning steps and assembles an execution plan from individual skills (defined, testable capabilities for subtasks). It retrieves the data required for each step specifically from the defined sources.

Every processing step remains traceable and can be derived from the logic of the data. This derivation is systematically logged, along with the sources used, the rules applied, the skills employed, and the confidence values (how certain the system is about a conclusion). The degree of autonomy with which the system operates can be determined based on the specific use case, and the control points are defined directly within the skills: Where technical or regulatory requirements demand it, a human reviews and makes decisions at these points using a human-in-the-loop process.

The key difference, therefore, lies not in a larger model or a better prompt, but in the architecture. While traditional agent systems often pass on errors unnoticed, DAPHY^® detects unclear or contradictory information, flags open issues, and documents every step: If it is not clearly defined which version of a source applies, the system asks for clarification. This makes discrepancies visible before they propagate through the agent chain. Existing agent platforms do not need to be replaced for this: Using agent-to-agent protocols (A2A, an interface through which AI agents directly exchange requests and responses), DAPHY^® can be integrated as a specialized knowledge agent and handles the quality assurance that has been lacking in many agent systems to date.

Where Agent Chains Fail in Practice

The relevance of this problem becomes evident in knowledge-intensive processes.

In an insurer’s claims management department A claims adjuster wants to know whether water damage is covered. The relevant information isn’t all in one place: insurance terms and conditions are in the document management system, policy endorsements are in the policy management system, and previous claims are in the claims history. One agent compiles the relevant clauses from these sources, a second assesses the coverage, and a third drafts the response. If even the first agent omits a restriction from an amendment or summarizes it too briefly, the entire chain carries this error forward. The response appears technically correct, even though its basis is no longer entirely accurate. An architecture with end-to-end traceability can cross-reference every clause it processes with its source, highlight any discrepancies, and return the assessment to the specialist.

The same pattern is evident among small and medium-sized businesses, in this case when repeatedly editing the same file. A wholesaler wants to submit a bid for a request for proposals within a few minutes. To do so, a predefined bid file must be filled out: Several agents retrieve product data, prices, and availability information from various systems, link them together, calculate the item prices, and enter everything sequentially into the same file. Each agent takes over the file exactly as their predecessor left it. If a subsequent agent accidentally overwrites a quantity that had already been entered correctly while entering the item prices, rounds a value, or omits an item, all subsequent steps continue to calculate based on this state. The finished file appears consistent and complete, and in the worst-case scenario, the discrepancy is not noticed until the customer reviews it. With end-to-end traceability, every value in the bid file can be traced back to its source and calculation. Subsequent changes to values that have already been entered become visible and can be reviewed by a specialist at defined checkpoints (human-in-the-loop).

In both cases, the problem does not lie primarily with the individual model. What matters is whether anomalies are detected before they reach the next agent in the chain.

More agents do not make chains more reliable

The Microsoft study shows that the more processing steps build on one another, the more content is lost along the way. The result remains plausible and sounds convincing, even if it is incorrect. Agent chains do not function identically, but they follow the same basic principle of information transfer—and thus potentially the same mechanisms of information loss.

Agent systems only become reliable when every transfer of information is secured, all steps remain traceable, and discrepancies are detected before they propagate. As with the game of “Chinese Whispers,” it is not the last person in the chain who determines the quality of the message, but rather whether the original information is preserved along the way. Otherwise, companies are not only automating processes but also errors, and the chain becomes a technical version of “Chinese Whispers”—except that, in the end, no one is laughing.

Having more agents doesn’t automatically make an information chain more reliable. But having an entity that verifies, validates, and transparently documents knowledge does. With DAPH^Y®, you can integrate precisely this layer into existing agent platforms without replacing them.

Curious about how to secure agent chains in your company without sacrificing speed? Talk to us.