💬 NLP

RCWT: Measuring Task-Budget Displacement from Coordination Content in LLM Calls

The paper introduces the Roundtable Context Window Test (RCWT) to demonstrate that performance degradation in LLMs under fixed context budgets is primarily caused by the displacement of task-critical evidence by coordination content, rather than by coordination volume alone, as evidenced by intact-task ablations where models maintain accuracy even with high coordination ratios.

Original authors: Brenda Lelis, Rodrigo Cabral-Carvalho

Published 2026-07-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Brenda Lelis, Rodrigo Cabral-Carvalho

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 you and your friends are trying to solve a tricky puzzle, but you only have one giant whiteboard with a strict limit of 4,096 sticky notes to write on. This whiteboard is your "context window," the space where an AI brain can see everything at once.

Usually, you'd just write the puzzle instructions and the clues on the board. But in the world of AI agents, things get crowded. Before you even get to the puzzle, you have to write down who everyone is, what the rules of the game are, what tools you have, and a summary of what you talked about five minutes ago. Let's call all that extra chatter "Coordination Content."

The paper introduces a game called RCWT (Roundtable Context Window Test) to see what happens when you fill up the whiteboard with too much chatter and not enough puzzle clues.

The Big Discovery: The "Crowded Board" Cliff

The researchers set up a test where they kept the whiteboard size fixed at 4,096 notes. They started by writing a tiny bit of coordination chatter and a huge pile of puzzle clues. The AI solved the puzzle perfectly.

Then, they slowly added more and more chatter—more role instructions, more fake meeting notes, more tool logs—while keeping the total board size the same. This meant they had to erase some of the puzzle clues to make room for the new chatter.

Here is the surprising part: The AI didn't get confused immediately. It kept solving the puzzle perfectly even when the board was half full of chatter. But then, they hit a sharp cliff.

Once the chatter grew so big that it squeezed the puzzle clues down to just a few hundred notes (around 376 notes of clues left), the AI's performance crashed. It went from getting almost everything right to getting almost everything wrong.

The paper suggests this isn't because the AI got "confused" by the noise. It's because the puzzle clues were physically pushed off the board. The AI literally couldn't see the answer anymore because the "coordination" took up the space.

What the Paper Says is NOT the Problem

You might think, "Maybe the AI just gets tired of reading too much text, even if the clues are still there?" The paper actually argues against this idea.

To test this, the researchers ran a special "ablation" (a fancy word for a control experiment). This time, they kept the entire puzzle and all the clues safe and sound on the board. They just made the whiteboard bigger to fit in the extra chatter. They added a massive amount of coordination text—up to 95% of the total text on the board!

The result? The AI still solved the puzzle perfectly. Even with a mountain of extra text, as long as the clues weren't erased, the AI didn't stumble.

This means the "cliff" we saw earlier wasn't caused by the AI getting overwhelmed by too much reading. It was purely a case of running out of space. The paper rules out the idea that coordination text itself breaks the AI's brain; it only breaks it when it steals the space needed for the actual task.

How Sure Are They?

The authors are very careful with their words. They didn't prove a universal law of physics here; they measured a specific behavior in specific models.

The Cliff: They measured this on three specific AI models (GPT-4.1-mini, Claude Haiku 4.5, and Gemini 2.5 Flash) using a technical software specification task. They found that for these models, accuracy stays high until the remaining task space drops below a certain point (around 568 to 665 tokens for the main task).
The "Law": They tried to fit a mathematical curve to this drop, but they admit this is just a "descriptive calibration." It's a good way to summarize what they saw, but they don't claim it will work exactly the same way for every single task or every single future model.
The "No Cliff" Finding: In the experiment where they kept the clues safe, the AI got 100% of the answers right across 150 different test calls. This is strong evidence that, in this specific setup, extra text doesn't hurt performance if the clues are safe.

The Takeaway for Builders

If you are building an AI system that uses multiple agents talking to each other, this paper gives you a simple rule of thumb: Don't just look at the total size of your whiteboard.

You have to count how much space your actual task needs. If your task needs 700 notes to work, and you have a 4,096 note board, you can only spend 3,396 notes on coordination chatter. If you spend more than that, you aren't just adding noise; you are deleting the instructions the AI needs to do its job.

The paper doesn't say coordination is bad. It just says it has a price tag, and that price is paid in the space available for the real work. As long as you budget for that space, the AI can handle a lot of chatter. But once you cross the line and start cutting into the task itself, the whole system falls off a cliff.

Technical Summary: RCWT – Measuring Task-Budget Displacement from Coordination Content in LLM Calls

1. Problem Statement

Modern multi-agent and memory-augmented Large Language Model (LLM) systems frequently consolidate diverse information types—including task instructions, retrieved documents, memory summaries, prior agent messages, tool outputs, and role definitions—into a single prompt. This creates a critical resource allocation problem: under a fixed context window budget ( $W$ ), every token allocated to "coordination content" ( $c$ ) physically reduces the tokens available for the "task block" ( $W - c$ ).

The central question is not merely whether a model supports a large context window, but how much of that window remains for the specific task evidence required to solve the problem. Prior research indicates that models do not utilize all positions uniformly and that performance can degrade as input length increases, even when relevant information is present. This paper isolates the specific operational effect of task-budget displacement: the phenomenon where increasing coordination content under a fixed budget truncates or reduces the residual task evidence, potentially causing performance cliffs.

2. Methodology: The Roundtable Context Window Test (RCWT)

The authors introduce RCWT, a controlled single-call benchmark protocol designed to measure the displacement effect while excluding confounding multi-agent dynamics (e.g., turn scheduling, retrieval policies, or agent topology).

2.1 Experimental Design

Fixed-Budget Experiment: The primary experiment uses a fixed context window ( $W = 4096$ $W = 4096$ ). The prompt is constructed from three deterministic blocks:
- $u$ : Fixed task-instruction block (337 tokens).
- $c$ : Coordination block (synthetic, structured like multi-agent shared context).
- $r$ : Technical-reference block (truncated to fit the remaining budget).
- Constraint: $c + u + r = W$ .
Variables: The protocol varies the coordination ratio $q = c / (W - u)$ across target values of 0% to 98%. This results in realized full-budget coordination shares ( $p = c/W$ ) ranging from 0% to ~90%.
Task: A context-dependent recall task requiring the model to extract 8 specific technical facts from a reference block regarding software specifications (e.g., encryption options, Redis latency, CRDT ramp-up times).
Models Tested: GPT-4.1-mini, Claude Haiku 4.5, and Gemini 2.0 Flash (later replaced by Gemini 2.5 Flash in ablation runs).
Scoring: Binary fact-checking over 10 items (8 effective items used for scoring).

2.2 Ablation Studies

To distinguish between truncation (loss of evidence) and semantic interference (coordination content confusing the model even when evidence is intact), the authors conducted two additional tests:

Intact-Task Ablation: The full task/reference block ( $t$ ) is kept intact. Coordination tokens are added around this block, increasing the total prompt length beyond the fixed $W$ . This tests if large coordination volumes cause degradation without evidence loss.
Boundary Tasks:
- Self-contained algorithmic task: Requires no external reference; coordination is irrelevant.
- External benchmark packs: GSM8K, MMLU-Pro, and DROP grouped into 10-item packs to test sensitivity under fixed budgets.

3. Key Results

3.1 Fixed-Budget Displacement (Main Task)

Stable Performance at Moderate Overhead: All three models maintained near-baseline accuracy when coordination content was moderate.
Sharp Performance Cliff: Accuracy degraded sharply only when the residual task/reference block ( $r$ $r$ ) was reduced to a few hundred tokens.
- At a target coordination ratio of 90% (realized $p \approx 82.6\%$ ), the reference block was reduced to ~376 tokens.
- Performance drops were significant: Gemini (-34.1 points), Haiku (-30.6 points), and GPT (-14.7 points).
Interpretation: The "cliff" is driven by the physical reduction of the task evidence, not merely the presence of coordination text.

3.2 Window Scaling

The transition point (where performance drops) did not occur at a fixed percentage of the context window across different window sizes ( $W=4096$ vs. $W=8192$ vs. $W=16384$ ).
Instead, the drop correlated with the residual task budget (the absolute number of tokens remaining for the task). For example, $W=8192$ could sustain a higher coordination share ( $p=86.3\%$ ) while leaving more reference tokens (786) than $W=4096$ did at a lower share, resulting in less degradation.
This supports a "task-specific residual-budget" interpretation rather than a fixed-percentage threshold.

3.3 Intact-Task Ablation

When the full task/reference block was kept intact and total prompt length was allowed to grow (removing the truncation effect), no cliff-sized degradation was observed across all tested models and coordination ratios (up to 95% coordination).
All models achieved 100% correct field extraction in this setup.
Implication: The main RCWT cliff is best interpreted as task-budget displacement (truncation of evidence), not as proof that coordination volume alone causes semantic interference in open-ended tasks.

3.4 Boundary Tasks

Self-contained tasks remained stable regardless of coordination overhead, confirming that extra text alone does not degrade performance in the tested range.
External packs showed sensitivity to truncation, though one exception (Claude Haiku 4.5 on GSM8K) showed degradation even before full truncation, suggesting task-specific nuances.

4. Contributions and Claims

The paper makes the following specific contributions and claims:

A Controlled Protocol: RCWT provides a method to isolate and measure the token-allocation cost of coordination in LLM calls, separating it from complex multi-agent dynamics.
Displacement vs. Interference: The primary finding is that performance cliffs in fixed-budget settings are largely due to the physical displacement/truncation of task evidence. The paper explicitly states that the intact-task ablation provides evidence against a large semantic-interference effect in extraction-style settings, narrowing the claim that "coordination hurts reasoning."
Residual Budget Interpretation: The transition point for performance degradation is better described by the absolute size of the residual task budget ( $\theta$ ) rather than a fixed percentage of the total context window.
Engineering Implication: The paper argues that practical systems should budget coordination content against task-specific residual needs. Engineers should not rely solely on nominal context window sizes or total prompt length but must ensure the task block retains sufficient tokens.
Scope Limitation: The authors explicitly state that RCWT measures the cost side of coordination (token displacement) and does not measure the net benefit (e.g., improved quality via decomposition or verification). The paper does not claim coordination is inherently bad, but that it consumes a finite resource that must be accounted for.

5. Limitations and Caveats

Task Specificity: The main results are derived from a technical-specification recall task. While boundary packs broaden coverage, the fitted curves are descriptive summaries, not universal laws.
Truncation Order: In the main task, facts are removed in a fixed order (prefix truncation), meaning the fitted midpoint partly reflects the reference layout rather than an intrinsic task constant.
Scoring Variance: The main task uses an LLM judge, which introduces potential strictness bias, though the intact-task ablation used deterministic JSON scoring to mitigate this.
Coordination Heterogeneity: The coordination content was synthetic and structured. Real-world coordination (dense tool outputs, contradictory claims, verbose transcripts) may behave differently.
Token Accounting: The study used a standard tokenizer ( $cl100k\_base$ ) for construction but relied on provider-reported counts for final verification, acknowledging potential discrepancies in native tokenization.

6. Conclusion

RCWT establishes that in multi-agent and memory-augmented LLM systems, coordination content is not cost-free under fixed context budgets. The primary risk is task-budget displacement, where coordination tokens physically truncate the evidence required for the task, leading to sharp performance degradation once the residual task block falls below a critical threshold. The paper concludes that the "cliff" observed in fixed-budget experiments is a result of evidence loss rather than a general semantic interference law. Practical system design should therefore prioritize tracking and preserving the residual task budget rather than focusing solely on total prompt length or nominal context window size.