💬 NLP

Memory Contagion: Cross-Temporal Propagation of Evaluator Bias via Agent Memory

This paper identifies and formalizes "Memory Contagion," a phenomenon where evaluator bias propagates across time through agent memory systems, demonstrating that while length preference bias can infect future agents even with perfect consolidation, authority bias does not, revealing a model-generation-dependent vulnerability in current AI memory architectures.

Original authors: Zewen Liu

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zewen Liu

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

The Core Idea: The "Bad Habit" Virus

Imagine you are training a new employee (an AI Agent) to do a job. You give them a mentor (an Evaluator) who grades their work.

Now, imagine this mentor has a weird quirk: they love long answers. They don’t care if the answer is right; they just love it when the employee writes a huge, rambling essay.

The employee learns this quickly. To get good grades, they start writing massive, unnecessary essays. These essays are saved in the company’s "Shared Notebook" (the Agent’s Memory).

Later, you hire a new employee (a future Agent). This new employee has a perfectly normal boss who doesn’t care about length. However, the new employee is told: "Look at the Shared Notebook to see how we do things here."

The new employee reads the old, rambling essays in the notebook. Even though their own boss doesn’t ask for long answers, the new employee starts writing long answers too, just because that’s what they saw in the notebook.

This is "Memory Contagion." The bias (the love for long answers) didn’t come from the new boss; it came from the memory of the old employee. The bias "infected" the new agent through the shared notes.

The Four Key Discoveries

The researchers tested this idea using two types of "quirks" (biases):

Length Bias: Preferring long answers.
Authority Bias: Preferring answers that sound official (e.g., "Studies show...").

Here is what they found:

1. The Virus Spreads Even If You Clean the Notes Perfectly

Usually, when we save notes, we summarize them to save space. The researchers thought, "Maybe if we summarize the notes perfectly, the bias will disappear."

They created a "Magic Summarizer" (called an Oracle) that compresses notes without losing any information.

Result: The bias still spread.
Analogy: Imagine the old employee wrote a 10-page essay. The Magic Summarizer shrinks it to 1 page, but it’s still a long 1-page essay compared to a normal 3-sentence answer. The new employee reads it and thinks, "Wow, they wrote a whole page! I should write a whole page too."
Conclusion: The problem isn’t the summarizing; the problem is that the original input was biased. If you feed the system biased data, the bias stays, even with perfect memory.

2. Only Some "Viruses" Are Contagious

The researchers tested two different quirks:

Length Bias (The "Long Answer" Quirk): This spread easily. The new agents started writing longer answers.
Authority Bias (The "Official Sounding" Quirk): This did not spread. The new agents did not start using phrases like "Studies show" just because they saw it in the notes.
Analogy: Think of it like fashion trends. If everyone in the office starts wearing big, baggy shirts (Length Bias), the new hire sees this and buys baggy shirts too. But if everyone starts quoting ancient Latin proverbs (Authority Bias) in their emails, the new hire ignores it and writes normally. Some habits catch on; others don’t.

3. Newer AI Models Are "Immune"

The researchers tested this on different versions of AI models.

Older Model (DeepSeek V4-Chat): Got infected by the Length Bias.
Newer/Smarter Models (DeepSeek V4-Pro, Claude Sonnet 4.6): Did not get infected. They ignored the long answers in the memory and wrote normal-length answers.
Analogy: The older AI is like a gullible intern who copies everything they see. The newer AI is like a seasoned expert who says, "I see you wrote a long essay in the past, but that doesn’t mean I have to do the same. I’ll just answer the question directly."
Conclusion: Upgrading to a smarter AI model is a great way to stop this contagion.

4. There Is No "Safe Dose"

The researchers asked: "How many bad notes do we need before the new agent gets infected?"

Result: Even if only 20% of the notes in the memory were biased, the new agent still picked up the bad habit.
Analogy: If you walk into a room where 80% of people are speaking normally, but 20% are shouting, you might still start shouting just to fit in. There is no safe threshold; even a small amount of bias can change behavior.

Why Does This Happen? (The Mechanism)

The researchers broke down how the infection happens:

Content Contagion: The actual words in the memory are biased. (e.g., The note says "Write long.")
Retrieval Contagion: The way the AI finds the notes is biased. (e.g., The AI searches for "long answers" and finds them.)

They found that Content Contagion is the bigger problem. The bad habits are literally written in the notes.

Summary for Everyday Understanding

The Problem: AI agents learn from past experiences stored in memory. If those past experiences were shaped by a biased judge (like one who likes long answers), the bias gets saved in the memory.
The Danger: Future AI agents, even with unbiased judges, will read those memories and copy the bad habits. This is "Memory Contagion."
The Good News:
1. Newer, smarter AI models seem to be immune to this.
2. Summarizing memories helps reduce the bias (though it doesn’t eliminate it completely).
3. Not all biases spread. "Length bias" spreads easily; "Authority bias" did not spread in their tests.
The Takeaway: If you are building AI systems, don’t just worry about how the AI is graded today. You must also check if the past data it is reading is biased. And consider using the latest, most capable AI models, as they are better at ignoring bad examples from the past.

Technical Summary: Memory Contagion: Cross-Temporal Propagation of Evaluator Bias via Agent Memory

Problem Statement
Large Language Model (LLM) agents increasingly rely on external memory systems to maintain long-term coherence and autonomy. While prior research (e.g., Zhang et al. [2026]) has identified that memory degradation occurs during the consolidation process (summarization/merging of experiences), existing studies operate under the critical assumption that input experiences are unbiased. This paper identifies a novel vulnerability termed Memory Contagion: the cross-temporal propagation of evaluator bias through agent memory systems. Specifically, when an agent is trained or guided by a biased evaluator (e.g., one with length preference or authority bias), its resulting trajectories become biased. When these biased trajectories are stored and consolidated into a shared memory store, the bias propagates to future agents retrieving from that store, even if the consolidation mechanism is perfect. This phenomenon operates across episodes and agents, distinct from within-episode bias studied in prior RLHF or RAG literature.

Methodology
The authors formalize Memory Contagion and conduct a four-phase experimental study to validate and analyze the phenomenon.

Formalization: The paper defines a metric $\Gamma_{temporal}$ to measure cross-temporal bias propagation. It is calculated as the Wasserstein distance ( $W_1$ ) between the behavioral distributions of a target agent retrieving from a biased memory store ( $M_b$ ) versus a clean memory store ( $M_c$ ). A $\Gamma_{temporal} > 0$ indicates bias propagation.
Experimental Design:
- Bias Types: Two bias types are investigated: Length Bias (preference for longer responses) and Authority Bias (preference for responses citing authoritative sources).
- Agents and Models: Experiments primarily use DeepSeek-Chat (V4-Chat) as the base model, with validation on DeepSeek V4-Pro and Claude Sonnet 4.6.
- Phases:
  - Phase 1 (Bias Injection): Source agents generate trajectories using rejection sampling based on biased evaluators.
  - Phase 2 (Memory Construction): Trajectories are stored and consolidated using either "Oracle" (perfect, lossless merge) or "LLM" (summarization-based) consolidation.
  - Phase 2.5 (Oracle Ablation): Tests whether contagion persists under perfect consolidation to isolate input bias as a sufficient cause.
  - Phase 3 (Mechanism Decomposition): Decomposes $\Gamma_{total}$ into content-based ( $E_1$ ), retrieval-based ( $E_2$ ), and interaction ( $E_3$ ) components to identify the primary transmission vector.
  - Phase 4 (Dose-Response): Varies the contamination rate $p$ (fraction of biased memories) to determine if a safe threshold exists.

Key Contributions

Formal Definition: Introduces $\Gamma_{temporal}$ as a quantitative measure for cross-temporal bias propagation via memory.
Empirical Validation: Demonstrates that Memory Contagion occurs for length bias even under perfect (oracle) consolidation, proving that biased input is a sufficient primary cause, independent of consolidation errors.
Mechanism Analysis: Identifies that content-based contagion (biased content influencing generation) dominates over retrieval-based contagion, though both contribute.
Dose-Response Analysis: Shows that bias propagation is detectable at low contamination rates ( $p=0.2$ ), with no observed safe threshold.
Model-Dependence Discovery: Reveals that Memory Contagion is not universal; it is strongly dependent on model generation and capability, with newer models showing immunity to certain bias types.

Results

Oracle Consolidation (Phase 2.5): Length bias propagates robustly under oracle consolidation on DeepSeek V4-Chat ( $\Gamma_A = 13.18$ , $p < 0.01$ ). In contrast, authority bias fails to propagate in all 15 controlled multi-seed experiments ( $\Gamma_A = 0.00$ ), despite an initial non-replicable exploratory run suggesting otherwise.
Consolidation Effects: LLM-based consolidation attenuates length bias by 84% ( $\Gamma_B = 2.03$ vs. $\Gamma_A = 13.18$ ), likely because summarization compresses global length features. However, consolidation does not prevent contagion entirely.
Mechanism Decomposition (Phase 3): Content-based contagion ( $E_1$ ) and retrieval-based contagion ( $E_2$ ) are comparable in magnitude, with content slightly dominating. Interaction effects ( $E_3$ ) are negligible. Debiasing via LLM rewriting is challenging; while length bias debiasing is reasonably effective (efficacy ratio 0.90), authority bias debiasing is substantially incomplete (efficacy ratio 0.51).
Dose-Response (Phase 4): No safe threshold is observed; bias propagation is detected at $p=0.2$ . The dose-response curve for length bias is monotonic, whereas authority bias (in the single non-replicable run) showed a peak-and-decline pattern, attributed to LLM-level self-correction rather than retrieval dynamics.
Multi-Model Validation: Memory Contagion for length bias is model-generation-dependent. DeepSeek V4-Chat is susceptible ( $\Gamma_A = 13.18$ ), while newer models (DeepSeek V4-Pro) and higher-capability cross-family models (Claude Sonnet 4.6) are immune ( $\Gamma_A = 0.00$ ). This suggests that improvements in instruction following, context utilization, and alignment may naturally mitigate certain forms of bias propagation.

Significance and Implications
The paper argues that claims attributing memory degradation solely to consolidation mechanisms are incomplete. Memory system designers must address input bias, as biased experiences are a sufficient cause of contagion even with perfect consolidation. The findings highlight that Memory Contagion is not a universal property of LLM agent systems but is contingent on bias type, model generation, and task context. Practitioners are advised to audit evaluator biases in agent pipelines and consider model upgrades as a natural mitigation strategy, as newer, more capable models appear immune to specific forms of bias propagation like length preference. The work provides formal tools for measuring cross-temporal bias and exposes critical vulnerabilities in current agent memory designs.