When you build multi-agent systems where LLMs evaluate each other’s outputs, you assume bias stays local. One agent prefers structured responses, another favors evidence-heavy answers. The assumption breaks when those agents interact. Bias doesn’t stay isolated. It spreads through the network like a contagion, compounding errors at each hop.
ArXiv paper 2606.20493v1 introduces Contagion Networks, a formal framework for measuring how evaluator biases propagate across interacting LLM agents. The work uses controlled 3-agent experiments with DeepSeek-chat to quantify bias spread and identifies three propagation regimes based on network topology.
The Problem: Bias Amplification in Agent Networks
Most multi-agent eval frameworks treat each agent as an independent evaluator. You run LLM-as-judge on outputs, aggregate scores, and ship. The hidden assumption is that evaluation biases are stationary and don’t compound.
That assumption fails when:
- Agent A evaluates Agent B’s output with a preference for structured formatting
- Agent B uses Agent A’s feedback to refine its next response
- Agent C evaluates both, inheriting structural preferences from the network
- The cycle repeats, amplifying the initial bias
The paper formalizes this with a Cross-Agent Contagion Matrix (Gamma_N) that measures how much of Agent i’s bias transfers to Agent j during evaluation interactions.
Experimental Setup: 3-Agent Controlled Environment
The researchers used three DeepSeek-chat instances with distinct evaluator profiles:
- Agent 1 (Structured): Prefers organized, formatted responses
- Agent 2 (Balanced): No strong formatting preference
- Agent 3 (Evidence-based): Favors citation-heavy, data-driven answers
Each agent evaluated the others’ outputs across multiple rounds. The key measurement: how much does Agent 1’s structured bias show up in Agent 2’s evaluations after interaction?
Contagion Coefficients
The paper measures gamma values (contagion coefficients) between 0.157 and 0.352 for same-model agents. For context, prior work on cross-model contagion (MM-EPC) found gamma values of 0.85 to 1.3, indicating much stronger propagation.
The lower values for same-model agents place them in what the paper calls the “suppression regime,” where bias spreads but doesn’t compound exponentially.
Architecture: Measuring Bias Propagation
The framework introduces three components for tracking contagion:
1. Bias Profile Extraction
Before agents interact, establish baseline evaluation preferences:
def extract_bias_profile(agent, eval_samples):
"""
Run agent through standardized eval tasks.
Track preference signals: formatting, evidence density,
response length, citation count.
"""
profile = {
'structure_weight': 0.0,
'evidence_weight': 0.0,
'length_preference': 0.0
}
for sample in eval_samples:
eval_result = agent.evaluate(sample)
profile['structure_weight'] += score_structure_bias(eval_result)
profile['evidence_weight'] += score_evidence_bias(eval_result)
profile['length_preference'] += score_length_bias(eval_result)
return normalize(profile)2. Cross-Agent Contagion Matrix (Gamma_N)
After agents interact, re-measure bias profiles. The contagion matrix captures how much of Agent i’s bias appears in Agent j:
Gamma_3 = [
[1.0, 0.23, 0.18], # Agent 1's bias spread
[0.16, 1.0, 0.21], # Agent 2's bias spread
[0.19, 0.24, 1.0 ] # Agent 3's bias spread
]Diagonal values are 1.0 (self-bias). Off-diagonal values show cross-contamination. A gamma of 0.23 means Agent 2 now exhibits 23% of Agent 1’s structural bias after interaction.
3. Spectral Radius (rho) for Propagation Regimes
The spectral radius of Gamma_N determines whether bias:
- Suppresses (rho < 1): Bias decays over iterations
- Sustains (rho ≈ 1): Bias persists but doesn’t amplify
- Amplifies (rho > 1): Bias compounds exponentially
For the 3-agent DeepSeek experiment, rho stayed below 1, indicating suppression. Cross-model networks in prior work hit rho > 1, causing runaway bias amplification.
Mitigation: Evaluator Committee Size
The paper tests a practical mitigation: instead of one evaluator per interaction, use a committee of k evaluators and aggregate their scores.
| Committee Size (k) | Effective Contagion | Reduction |
|---|---|---|
| 1 | 0.29 (baseline) | 0% |
| 2 | 0.16 | 44.8% |
| 3 | 0.08 | 72.4% |
Increasing k from 1 to 3 reduces effective contagion by 72.4%. The trade-off: 3x the evaluation cost per interaction.
Instrumentation: Detecting Contagion in Production
To track bias propagation in a live multi-agent system:
Real-Time Bias Drift Monitoring
class ContagionMonitor:
def __init__(self, agents, baseline_profiles):
self.agents = agents
self.baseline = baseline_profiles
self.current_profiles = baseline_profiles.copy()
self.gamma_history = []
def measure_drift(self, agent_id, eval_samples):
"""
Compare current bias profile to baseline.
Flag if drift exceeds threshold.
"""
current = extract_bias_profile(self.agents[agent_id], eval_samples)
drift = cosine_distance(current, self.baseline[agent_id])
if drift > 0.15: # Threshold from paper's gamma range
self.log_contagion_event(agent_id, drift)
self.current_profiles[agent_id] = current
return drift
def compute_gamma_matrix(self):
"""
Compute cross-agent contagion coefficients.
"""
N = len(self.agents)
gamma = np.eye(N)
for i in range(N):
for j in range(N):
if i != j:
gamma[i][j] = self.measure_cross_bias(i, j)
self.gamma_history.append(gamma)
return gamma
def spectral_radius(self, gamma):
eigenvalues = np.linalg.eigvals(gamma)
return max(abs(eigenvalues))Network Topology Considerations
The paper doesn’t explicitly test different topologies, but the framework implies:
- Fully connected networks (every agent evaluates every other agent) maximize contagion surface area
- Hub-and-spoke (one central evaluator) concentrates bias at the hub
- Chain topologies (A evaluates B, B evaluates C) create directional bias flow
For production systems, consider:
- Limiting evaluation edges to reduce contagion paths
- Rotating evaluator assignments to prevent persistent bias channels
- Isolating high-stakes evaluations from the main agent network
Failure Modes
1. Silent Bias Compounding
If rho approaches 1.0, bias persists indefinitely without obvious degradation. You won’t see catastrophic failures, just slow drift toward homogeneous evaluation preferences.
Detection: Track spectral radius over time. Alert when rho > 0.9.
2. Cross-Model Contagion Explosions
The paper’s same-model experiments show suppression (rho < 1). Prior work on cross-model networks (GPT-4 evaluating Claude outputs) shows amplification (rho > 1).
Mitigation: If mixing model families, increase committee size and monitor gamma coefficients more aggressively.
3. Evaluation Cost Explosion
Using k=3 evaluator committees cuts contagion by 72% but triples eval costs. For high-frequency agent interactions, this becomes prohibitive.
Trade-off: Reserve committees for high-stakes evaluations. Use single evaluators for routine interactions, monitor drift, and trigger committee evals when drift exceeds thresholds.
Implementation Checklist
To instrument contagion detection in your multi-agent system:
- Establish baseline bias profiles for each agent before deployment
- Log all agent-to-agent evaluation calls with input/output pairs
- Re-measure bias profiles every N interactions (paper suggests N=100)
- Compute Gamma_N matrix and spectral radius weekly
- Set alerts for gamma > 0.3 (entering sustain regime)
- Set alerts for rho > 0.9 (approaching amplification)
- Implement evaluator committee fallback for high-drift agents
- Track evaluation cost vs. contagion reduction trade-offs
Technical Verdict
Use this framework when:
- You run multi-agent systems where agents evaluate each other’s outputs
- You need quantitative evidence of bias propagation, not just anecdotal drift
- You can afford the instrumentation overhead (logging all evals, periodic re-profiling)
- You’re mixing model families or using custom fine-tuned evaluators
Avoid or defer when:
- Your agents don’t evaluate each other (no contagion surface)
- You use a single external judge for all evaluations (no network effects)
- Evaluation volume is too high to log and re-profile economically
- You’re in early prototyping and bias drift isn’t a concern yet
The framework’s value is in making bias propagation measurable. If you’re already seeing unexplained eval drift in production, this gives you the math to quantify it and the mitigation levers (committee size, topology changes) to control it.