🤖 AI

Faithful, Not Corrective: Message-Format Effects in Multi-Hop Agent Relays Are Tier-Dependent

This paper demonstrates that the impact of message formats on multi-hop LLM agent relays is tier-dependent, revealing that while strong agents maintain near-lossless fidelity across formats, weak agents suffer significant format-driven performance divergence where rigid structures incur encoding costs but fixed-key JSON offers superior drift resistance, ultimately establishing that structure provides error-localizing fidelity rather than error correction.

Original authors: Zayx Shawn

Published 2026-07-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zayx Shawn

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a game of "Telephone," but instead of kids whispering secrets, you have a chain of AI robots passing a list of twelve important facts down the line. The big question researchers asked was: Does the way the robots write down the message matter? Should they write in messy, free-flowing sentences, or should they force the facts into a strict, rigid box like a JSON spreadsheet or a list of key-value pairs?

For a long time, experts argued about this. Some said, "Structure is great! It saves money and keeps things accurate." Others said, "No way! Forcing robots into boxes makes them stupid and ruins their reasoning."

This paper decided to settle the score by building a giant, controlled relay race. They created 12 fake facts (like "The budget is $500" or "The deadline is Tuesday") and sent them through a chain of six handoffs. They tested this with two types of robots: a Super-Brain (a powerful, expensive AI) and a Tiny-Brain (a small, cheap 1.5B model). They tried five different writing styles, from free-form text to rigid code.

Here is what they found, and it changes how we should think about AI teamwork.

1. The "Telephone" Game Doesn't Always Break

If you use the Super-Brain, the game is surprisingly boring. After six handoffs, the message is almost perfect. The famous "Telephone" effect—where the message gets garbled and turns into nonsense—simply does not happen with a strong robot. Whether the robot writes in a fancy JSON box or a free-flowing paragraph, the facts stay intact. The only tiny bit of information lost happens right at the very first step, when the robot first tries to write the message down. After that, the message just travels along without changing.

2. The "Busy Robot" Myth

You might think, "What if the robot is doing other work while passing the message? Like, what if it has to solve a math problem first?" The researchers tested this by making the Super-Brain do extra thinking work at every step.
The result? The robot got tired and the messages got longer (costing 24% to 53% more "tokens," which is like paying more for the message), but the accuracy didn't drop. Being busy didn't make the Super-Brain mess up the facts. The format of the message didn't matter much here either; the robot was just too good to fail.

3. The Real Drama: The Tiny-Brain Relay

Things get interesting when you switch to the Tiny-Brain. This is where the "Telephone" game actually breaks, but in a weird way.

The Encoding Toll: When the Tiny-Brain tries to write the message in a rigid format (like JSON or Key-Value), it struggles right at the start. It's hard for a small brain to force facts into a strict box, so it loses about 20% of the facts immediately.
The Drift Defense: BUT, once the Tiny-Brain does get the message into that rigid JSON box, something magical happens. The strict box acts like a safety harness. Even as the message passes through five more hands, the facts inside the JSON box barely drift. They stay stuck in their places.
The Free-Form Disaster: In contrast, if the Tiny-Brain writes in free-flowing text, it starts strong but then slowly forgets things. By the sixth handoff, the free-text message is a disaster, with facts drifting all over the place.

The Twist: The rigid formats (JSON) start off looking worse because the small robot struggles to write them, but they end up winning because they stop the message from rotting over time. The free text starts strong but falls apart. The paper found that the difference in accuracy between the best and worst formats grew 8.7 times larger when using the weak robot compared to the strong one.

4. Structure is a "Faithful Messenger," Not a "Magic Fixer"

This is the most important rule the paper discovered. Many people hope that if you put a mistake in a rigid format, the format will magically fix it. The paper explicitly rules this out.
They tested this by secretly swapping one correct name for a fake one in the middle of the chain.

The Result: Once the fake name appeared, every single format (JSON, free text, triples) carried that fake name all the way to the end. The rigid box did not correct the error. It just carried the error faithfully.
No Chain Reaction: Also, the fake name didn't cause other facts to break. The error stayed isolated.

So, structure is like a faithful courier. If you give the courier a correct package, it delivers it perfectly. If you give the courier a broken package, it delivers the broken package perfectly. It does not act like a repair shop that fixes the package while it's moving.

The Bottom Line for Your AI Team

If you are building a system where AI agents pass messages to each other:

Don't worry about the format if your AI is super smart. It will get the job done either way.
If you are using a smaller, cheaper AI, you MUST use a rigid format (like JSON) for long chains. Even though it's harder for the small AI to start, the rigid box will stop the message from rotting as it travels.
Never expect the format to fix mistakes. If a robot makes an error, the format won't save you. You need to check the work yourself.

In short: Structure doesn't make the robot smarter, and it doesn't fix its mistakes. But if you have a small robot doing a long relay race, the rigid box is the only thing keeping the message from falling apart.

Technical Summary: Faithful, Not Corrective: Message-Format Effects in Multi-Hop Agent Relays Are Tier-Dependent

1. Problem Statement

Multi-agent Large Language Model (LLM) systems function fundamentally as relay systems where information is re-encoded by one model for consumption by another. While existing literature offers contradictory guidance on message formats—some suggesting structured formats reduce cost without sacrificing accuracy, while others claim rigid schemas degrade reasoning—neither line of inquiry has addressed the specific dynamics of multi-hop relays. In single-hop exchanges, the primary challenge is generation quality; in multi-hop chains, the dominant challenge is copy fidelity (preventing cumulative drift). The sign of the format effect in a relay regime remains unknown, particularly as pipelines increasingly deploy smaller, cost-effective models at relay boundaries where inter-agent misalignment is a leading cause of failure.

2. Methodology

The authors introduce a controlled relay testbed designed to isolate format effects from model capability and task complexity.

Ground Truth: The study uses a programmatic ground truth derived from twelve synthetic atomic facts (owners, quantities, deadlines, constraints, dependencies, prohibitions) across three domains. Fidelity is measured against the generator's output, not another model's generation.
Relay Protocol: Task briefs are re-encoded hop-by-hop over six hops. Each agent receives only the previous hop's message and must re-issue the complete handoff in the assigned format.
Formats: Five formats spanning the structure spectrum were tested:
1. FREE: Free natural language.
2. CONSTR: Natural language with precision instructions (verbatim numbers/names).
3. JSON: A fixed six-key schema.
4. TRIPLES: Subject | Predicate | Object lines.
5. KV: Flat snake_case key–value lines.
Capability Tiers: Experiments were run across two distinct relay tiers:
- Strong Tier: DeepSeek-v4-flash (API model).
- Weak Tier: Qwen2.5-1.5B-Instruct (4-bit quantized, local).
- Crucially, a single fixed strong model served as the grader for all conditions to ensure that observed distortions were not artifacts of a weak evaluator.
Metrics:
- QA Recall (Primary): A fixed strong grader answers 12 closed-form questions based on the hop message, with exact token matching against ground truth.
- String Recall (Secondary): Verbatim containment of fact surface forms (judge-free).
Experimental Conditions:
- Pure Relay: Standard re-encoding.
- Cognitive Load (Strong Tier): Agents must perform an analysis step before re-encoding to simulate real-world processing.
- Paired-Fork Injection (Weak Tier): A specific error (an owner name) is programmatically injected at Hop 3. The chain splits into a "clean" arm and an "injected" arm to measure error persistence and collateral damage.

3. Key Results

A. Strong Tier: Near-Lossless Relaying

Under the strong relay model, the "telephone game" collapse (progressive accuracy degradation) does not occur.

After six hops, all formats retained QA recall $\ge 0.973$ .
Residual loss is concentrated almost entirely in the first encoding step (Hop 1) rather than accumulating over subsequent hops.
Cognitive Load: Adding per-hop analysis duties increased generation costs by 24–53% but had negligible impact on fidelity (bounded within $\pm 1.8$ points).
Format Efficiency: Precision-instructed natural language (CONSTR) achieved perfect recall at 26% fewer tokens than JSON, suggesting structured schemas are not strictly necessary for strong models.

B. Weak Tier: Tier-Dependent Format Effects

When the relay capability drops (1.5B model), the dynamics change drastically. The across-format dispersion of recall at Hop 6 grows by a factor of 8.7 (SD ratio).

Two Opposing Mechanisms:
1. Encoding Toll: Rigid formats (JSON, KV) impose a high initial cost on weak models, resulting in lower Hop 1 recall compared to natural language formats.
2. Drift Resistance: Once encoded, the fixed-key JSON schema acts as a strong anchor, resisting cumulative drift. JSON lost only 4.7 raw points over hops 1–6, whereas free prose and triples lost 20+ points.
Ranking Flip: Due to these opposing forces, the format ranking flips during transit. JSON starts in 4th place at Hop 1 (due to the encoding toll) but finishes in 2nd place at Hop 6 (due to drift resistance).
Conclusion: Structure preserves content but does not repair it. The "best" format depends on the weakest relay in the pipeline.

C. Causal Adjudication: Faithful, Not Corrective

Using the paired-fork injection, the study tested whether schemas prevent drift or repair errors.

Persistence: Once an error is injected, it propagates faithfully to the final hop in 83–100% of chains across all formats.
No Correction: No format exhibited an ability to "correct" the injected error.
No Cascade: Injecting a single error caused no detectable collateral damage to neighboring facts.
Implication: Structure provides a faithful, error-localizing channel, not an error-correcting code.

4. Contributions

First Format-Controlled Relay Study: The authors complete the "format $\times$ hops $\times$ capability" design space, demonstrating that the "telephone game" collapse is not intrinsic to multi-hop text relay but is contingent on relay capability and task transformation.
Capability Regime Identification: The study establishes that format effects are tier-dependent. At the frontier (strong models), format choice is nearly free; below the ceiling (weak models), the choice is decisive and driven by a trade-off between encoding costs and drift resistance.
Mechanism Decomposition: The paper isolates two opposing mechanisms in weak relays: the "encoding toll" of rigid schemas versus the "drift resistance" of fixed-key schemas, explaining why JSON rankings flip over time.
Causal Adjudication of "Schema Prevention": The study refutes the idea that schemas act as error-correcting codes. Instead, they are shown to be faithful channels that localize errors without amplifying or repairing them.

5. Significance and Practical Guidance

The paper argues that as pipelines increasingly rely on small, cost-effective models for relay tasks, message format shifts from a style choice to a critical reliability parameter.

For Strong Relays: Precision-instructed natural language is optimal, offering schema-grade fidelity at significantly lower token costs.
For Weak Relays (Long Chains): A fixed-key schema (JSON) is recommended despite the initial encoding toll, as its drift resistance preserves content over multiple hops better than natural language.
General Rule: Format choice should be dictated by the weakest relay in the pipeline.
Design Implication: Structure localizes damage but does not fix it. Systems requiring error correction must implement explicit validation and re-grounding mechanisms, as the message format itself will not repair corrupted data.

The authors conclude that the "telephone game" is not a law of LLM pipelines but a capability-dependent phenomenon, and that the specific mechanism of multi-hop degradation varies significantly based on the design choice of message format.