What is context pollution? (And how developers fix it)

The definition

Context pollution is what happens inside any linear AI chat that lives longer than a few prompts. Every message you send — every abandoned idea, every wrong turn, every “wait, actually never mind” — stays in the conversation's history. And because LLMs condition each new answer on the entire history, all of it keeps influencing the output.

It's not a bug in any specific model. It's a structural property of the interface: one thread, one history, no way to remove anything.

Why it happens

1. Attention dilution

LLMs don't read your history the way you do — they weight it. Long histories dilute attention across thousands of tokens, and the instructions you care about (your system prompt, your constraints) compete with everything that came after. Research on the “lost-in-the-middle” effect shows models recall information at the start and end of long contexts far better than what's buried in the middle.

2. Error compounding

When a model makes a mistake and you correct it, the mistake doesn't leave the context. It sits there as a plausible-looking pattern. Ten prompts later, the model re-derives the same wrong approach — because statistically, it's part of the conversation now.

3. Instruction collision

“Use TypeScript strict mode.” … twenty messages later … “just make it work, skip the types for now.” Both instructions remain in context. The model averages them, and you get output that satisfies neither.

4. Topic bleed

You spent an hour on auth, then asked a CSS question, then went back to backend work. The model now blends them — CSS variables showing up in your auth middleware, auth logic leaking into your layout discussion.

The symptoms (a checklist)

• The model re-proposes approaches you already rejected
• It contradicts constraints you set early in the chat
• Answers mix topics from different parts of the conversation
• Style and quality drift the longer the chat runs
• You find yourself writing “ignore everything above”

If two or more of these sound familiar, your chats are polluted. And you're paying for it — literally, since polluted context is re-billed as input tokens on every single request.

The common fixes — and their limits

Start a new chat. Works, but you lose the good context along with the bad, and you end up re-explaining your project five times a day.

Summarize and restart. Better, but summaries are lossy — the details you didn't think to include are exactly the ones the model needed.

Bigger context windows. Treats capacity, not relevance. A 1M-token window just gives pollution more room to grow.

“Ignore previous instructions” prompts. Unreliable — you're fighting the model's conditioning with more conditioning, inside the same polluted context.

The structural fix: branch isolation

The only fix that addresses the root cause is changing the conversation structure itself. Instead of one linear history, you work in branches: each new thread inherits only the context you explicitly choose — typically a clean root (your codebase, your constraints) plus its own prompts. Dead ends get deleted, not carried. Sibling threads never see each other.

This is the model Alyph is built on. Your codebase anchors a root node; every feature, experiment, or model comparison is a branch off it. Pollution has nowhere to accumulate because nothing irrelevant is ever sent. Read the full guide to context branching.