💬 NLP

Semantic Register Compression in Multi-Agent LLM Cascades

This paper identifies and quantifies "semantic register compression," a phenomenon where intermediate agents in multi-agent LLM cascades systematically reduce label separability in embedding space during semantic transformation, leading to measurable information loss across diverse high-stakes domains like fact-checking, sentiment analysis, and medical triage.

Original authors: Manuele Tele Junior Fernandez

Published 2026-07-17

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Manuele Tele Junior Fernandez

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 team of robots working together to solve a mystery. In the world of artificial intelligence, this is called a "multi-agent system." Instead of one giant robot doing everything, you have a small squad: one robot gathers clues, a second one analyzes them, and a third one makes the final verdict. It sounds like a perfect setup for a detective story, right? But here's the catch: when these robots talk to each other, they don't just pass notes; they rewrite the story.

Think of it like a game of "Telephone," but with a twist. In the classic game, a message gets garbled and silly as it passes from person to person. In this AI version, the message doesn't get silly; it gets smoothed out. The middle robot, the analyst, takes the messy, specific details and rewrites them into a neat, professional summary. The problem is that in making the story sound more logical and organized, the robot accidentally sands down the sharp edges that tell the difference between "definitely true" and "definitely false." It turns a jagged mountain range of facts into a gentle, rolling hill. This paper explores what happens when that smoothing process goes too far, causing the final robot to lose its ability to tell the truth from a lie because everything starts to look the same.

The Great Smoothing Effect

Meet Manuele Tele Junior Fernandez, an independent researcher who decided to peek behind the curtain of these AI detective teams. He wanted to see what happens when a "Collector" robot gathers information, passes it to an "Evaluator" robot to critique it, and then hands the result to a "Decider" robot to make a choice. The big question was: Does the middle robot, the Evaluator, accidentally erase the important differences between the clues?

Fernandez discovered a phenomenon he calls semantic register compression. That's a fancy way of saying the AI is squishing the meaning of words together. When the Evaluator rewrites a story to sound more analytical or critical, it makes different categories of truth look more similar to each other. It's like taking a box of distinct colored marbles—red, blue, green, yellow—and the Evaluator is a magical blender that turns them all into a single shade of muddy brown.

The Detective Story in Action

To test this, Fernandez set up a three-stage pipeline using a dataset of political claims (the LIAR dataset).

The Collector: Takes a raw claim and writes a neutral report.
The Evaluator: Takes that report and rewrites it as a critical analysis.
The Decider: Reads the analysis and decides if the claim is true, false, or somewhere in between.

The results were startling. When the input was a perfectly balanced mix of claims (20% "pants-fire" lies, 20% "false," 20% "half-true," etc.), the final output of the AI team collapsed. Instead of a balanced mix, the Decider almost always chose the middle options: "half-true" or "barely-true." In fact, in one test with 50 claims, the AI never chose "true" or "mostly-true" at all. It was as if the AI had lost its nerve to make strong judgments.

Where Did the Differences Go?

Fernandez didn't just guess; he measured the "distance" between the different types of claims in the AI's brain (using something called embedding space).

Before the Evaluator: The distance between "true" claims and "false" claims was 0.4345. They were clearly distinct.
After the Evaluator: That distance shrank to 0.2534.
The Result: This was a 41.7% compression. The Evaluator had squished the distinct categories so close together that they were barely distinguishable anymore.

Crucially, the paper rules out the idea that this is just because there are multiple robots. When Fernandez tested a version where the Evaluator just passed the text through without changing it (an "identity passthrough"), the distance stayed high at 0.44, and no compression happened. The problem wasn't the team; it was the rewriting.

The "Credibility" Twist

Here is where it gets really interesting. Fernandez tried a different kind of Evaluator. Instead of looking for lies, this robot looked for reasons to believe the claim (a "credibility-seeking" variant).

The Outcome: This robot didn't squish the categories together much (only 1% compression).
The Catch: Even though the categories stayed distinct, the robot still pushed the final answers toward "mostly-true."

This proves that "squishing the categories" (geometric compression) and "pushing the answer in one direction" (bias) are two different things. You can have a robot that keeps the differences clear but still biases the answer, or one that squishes the differences and biases the answer. The paper shows that the act of transforming the text into an evaluative style is the main driver of the squishing, regardless of whether the robot is being critical or supportive.

Does This Happen Everywhere?

Fernandez tested if this "smoothing" effect happened in other areas, not just politics.

Political Fact-Checking: 41.7% compression.
Movie Sentiment: 27.2% compression.
Medical Triage: 20.0% compression.

The effect happened in all three, but it was strongest in politics and weakest in medical triage. This suggests that some topics are just harder to keep distinct when you try to summarize them critically.

The Magic of the Prompt

Finally, the paper looked at how the Evaluator was told to do its job. Fernandez found that 78% of the compression could be predicted by the specific words in the Evaluator's instructions.

Vague prompts (like "Critique this") caused high compression.
Specific prompts with "operational constraints" (like "List specific evidence for and against, note missing context, and identify exactly what separates a 'half-true' from a 'mostly-true'") caused much lower compression.

It turns out that if you tell the AI robot to be very specific and follow a strict checklist, it's less likely to accidentally smooth away the important differences.

The Takeaway

This paper doesn't say AI is broken, but it does say that the way we build AI teams needs a safety check. Just because an AI team produces fluent, logical-sounding text doesn't mean it's preserving the truth. If the middle robot rewrites the story too much, the final robot might lose the ability to tell a dangerous lie from a safe truth. The solution? Don't just ask for a summary; ask for a specific, structured breakdown that keeps the sharp edges of the facts intact.

Technical Summary: Semantic Register Compression in Multi-Agent LLM Cascades

Problem Statement

Multi-agent Large Language Model (LLM) systems increasingly decompose complex tasks into specialized roles (e.g., Collector, Evaluator, Decider). While this modularity aims to improve reasoning and factuality, it introduces a representational risk: intermediate agents may rewrite inputs across linguistic and functional registers, systematically compressing the semantic distinctions necessary for accurate downstream decisions.

The paper identifies this phenomenon as Semantic Register Compression. It is defined as the loss of category distinguishability that occurs when an intermediate agent rewrites inputs in an evaluative or analytical style. Unlike traditional failure modes such as hallucinations or incoherent text, this failure is subtle; the system produces fluent intermediate reasoning that collapses distinctions between categories, causing final outputs to concentrate toward central or moderate labels. This is particularly critical in architectures where the final decision agent does not observe the original input, rendering the loss of semantic separability unrecoverable.

Methodology

The study employs a sequential three-agent pipeline implemented via LangGraph, consisting of:

Collector: Receives the original input and produces a neutral report.
Evaluator: Receives only the Collector's output and produces an analytical assessment.
Decider: Receives only the Evaluator's output and assigns a final classification label.

Datasets:

Primary: LIAR dataset (political fact-checking), using 50 balanced claims across five veracity labels (replicated on 500 claims).
Cross-Domain: SST-5 (sentiment analysis) and Triagegeist (synthetic medical triage), with 50 balanced examples each.

Measurement Metric:
The authors introduce Inter-Label Separation to quantify compression. Using all-MiniLM-L6-v2 (an external Sentence-Transformer independent of the pipeline LLMs), they encode texts at each stage.

Centroids: For each ground-truth label $y$ at stage $t$ , a centroid $c_{t,y}$ is computed by averaging the embeddings of texts in that group.
Separation ( $S_t$ ): The mean Euclidean distance between all pairs of label centroids.
Compression ( $C_t$ ): The percentage reduction in separation relative to the input stage: $C_t = \frac{S_{input} - S_t}{S_{input}} \times 100$ .

Experimental Variants:
To isolate causal drivers, the authors tested five Evaluator variants:

Original (Critical): Standard critical evaluation.
Balanced: Pro/contra analysis.
Credibility-Supporting: Searches for features supporting the claim's credibility.
Numerical: Converts evaluation to a 1–10 score.
Identity Passthrough: Passes the Collector's output unchanged.
Evaluator Removed: Direct Collector-to-Decider flow.

Additionally, a 20-level prompt gradient was tested to analyze the relationship between transformation intensity and compression.

Key Results

1. Localization of Compression

Collector Stage: Inter-label separation remained nearly unchanged (0.4345 to 0.4364, -0.4% compression), indicating the neutral collection step is transparent.
Evaluator Stage: Separation dropped significantly from 0.4345 to 0.2534, representing 41.7% compression. This localizes the failure mode specifically to the evaluative transformation.
Cosine Similarity: Post-evaluation, inter-label similarity (0.93–0.96) exceeded intra-label similarity (0.61–0.68), confirming that outputs from different categories became more similar to each other than to their own category members.

2. Causal Drivers

Transformation vs. Cascade: Identity passthrough and removing the Evaluator entirely resulted in no compression. This proves compression is not caused by the mere presence of an intermediate LLM stage, but by the oriented semantic transformation performed by the Evaluator.
Direction vs. Magnitude: The Credibility-Supporting variant produced minimal geometric compression (~1%) but shifted the output distribution toward "mostly-true" (42%). In contrast, the Critical variant produced high compression (41.7%) and shifted outputs toward "half-true" (60%). This demonstrates that geometric compression (loss of separability) and distributional bias (direction of collapse) are distinct phenomena controlled by the valence of the evaluation.

3. Predictors and Generalization

Prompt Predictors: A multiple regression model explained 78% of the variance in compression using three predictors:
1. Embedding distance from the identity prompt.
2. Number of evaluative words.
3. Number of operational constraints.
- Finding: Prompts with more operational constraints were associated with lower compression, suggesting specific instructions preserve distinctions better than generic evaluative prompts.
Cross-Domain Generalization: Compression occurred in all three domains but with varying intensity:
- Fact-checking (LIAR): 41.7%
- Sentiment (SST-5): 27.2%
- Triage (Triagegeist): 20.0%
- Observation: Domains with more operational categories or clearer input signals (like triage) appeared less vulnerable than nuanced evaluative domains (like fact-checking).

Significance and Claims

The paper claims to establish Semantic Register Compression as a measurable and generalizable failure mode in multi-agent LLM systems. Its primary contributions are:

Definition: It defines semantic register compression as a specific geometric failure where intermediate agents collapse category distinctions in embedding space.
Diagnostic Tool: It introduces inter-label separation as a stage-wise diagnostic to track information loss within a pipeline, moving beyond final-output accuracy.
Causal Isolation: It causally isolates evaluative semantic transformation as the driver of compression, distinguishing it from simple cascading or style normalization.
Mitigation Strategy: It identifies operational constraints in prompts as a practical mitigation, showing that specific, constraint-rich instructions can preserve decision-relevant distinctions better than broad evaluative requests.

Implications for Safety:
The authors argue that safety evaluation for multi-agent systems must extend beyond final accuracy, trace-level errors, or individual agent competence. In high-stakes domains (fact-checking, triage, governance), a fluent but standardized intermediate evaluation can act as a semantic bottleneck, reducing downstream sensitivity to extreme or high-risk cases. The paper posits that safety evaluation should explicitly test whether internal transformations preserve the distinctions required for downstream decisions.

Limitations:
The study acknowledges it is an initial empirical characterization. Limitations include the use of small sample sizes (50 examples per condition, though 500 were used for baseline replication), reliance on synthetic triage data, and the use of embedding metrics as proxies for semantic separability rather than absolute measures of meaning. The authors note that future work is needed to disentangle semantic compression from stylistic or surface-form factors.