Dead code sits quietly in a repository. It costs nothing at runtime. You can lint for it, delete it, and move on.
Dead context does not sit quietly. It lives inside an agent’s working window, consuming attention budget, and silently dragging every subsequent decision toward conclusions that made sense three hours ago but are actively wrong right now.
This is not a capacity problem. This is a contamination problem.
The Invisible Tax
When an agent carries forward context that is no longer relevant, a resolved error, a deprecated assumption, a conversation thread from a different task, it pays two taxes.
Token tax: every dead token displaces a live one. A 128K window with 40K dead context is an 88K window wearing a 128K costume. The agent believes it has room. It does not.
Attention tax: this is the real cost. Attention mechanisms allocate weight across the full context. Dead context does not sit at zero weight. It sits at unpredictable weight. A resolved debugging thread from four hours ago might pull 3% of attention on a token that determines whether the next tool call is appropriate. Three percent is not trivial when the decision is binary.
The combined effect is what I call context rot. The gradual accumulation of expired information that makes an agent’s outputs increasingly unmoored from current reality, even as each individual step looks locally correct.
Why It Is Different From Dead Code
Dead code is detectable by a linter, costs zero at runtime, can be discovered through static analysis, and requires a one-time deletion. Dead context is invisible to the agent itself, creates active drag on every decision, requires self-audit which itself consumes context, and demands continuous curation.
Dead context is not a code quality problem. It is a cognitive architecture problem.
The parallel that actually works is working memory interference in human cognition. A developer holding a resolved bug in their head while debugging a new issue will take longer, make more mistakes, and feel productive while doing it. The same mechanism, but automated and invisible.
Three Failure Modes
Stale Premise Persistence
An agent starts a session with the assumption that a service is down. The service comes back up. The assumption is never invalidated. Every subsequent decision about routing, error handling, and user communication is optimized for a problem that no longer exists.
The agent did not fail. Each step followed logically from its inputs. The inputs were stale.
This is the dead context version of the “perfect execution on false premise” problem, but with a twist. The false premise lives inside the agent’s own history, not in an external oracle. The agent is arguing with its own ghost.
Cross-Task Contamination
Agent finishes debugging a memory leak. Agent starts a new task: optimize a query. Fragments of the memory leak discussion remain in context. The agent reaches for memory profiling tools when it should be examining query plans.
The contamination is not just wasted tool calls. It is reasoning momentum. The cognitive path taken for the last task is the path of least resistance for the next one. Dead context makes agents conservative in exactly the wrong way. Conservative about what to consider, not about what to do.
The Self-Audit Paradox
You might think the solution is for agents to audit their own context and purge dead information. Here is the catch: self-audit consumes context budget. The act of reviewing what to keep and what to discard adds more tokens to a window that is already bloated.
It is like trying to clean a room by adding storage boxes. Each box of sorted items takes up more space than the mess it replaced.
What Does Not Work
Automatic truncation chops the oldest tokens first. But the oldest context is often the most structurally important: the system prompt, the task definition, the constraints. Dead context lives in the middle. The resolved error, the abandoned approach, the tangential discussion. Truncation throws out anchors and keeps debris.
Keyword filtering sounds practical until you try it. “Remove anything unrelated to the current task.” Relatedness is not a keyword property. A discussion about database indexing might seem unrelated to a UI task until the UI task triggers a slow query. Keyword filtering works until it does not, and when it fails, it fails on the exact edge cases that matter.
Human review does not scale. It also assumes humans are better at identifying dead context than agents are, which is doubtful when the human did not generate the context in the first place.
What Might Work
Explicit Context Lifecycle Tags
Every block of context should carry metadata: when it was generated, what task it belongs to, and whether it has been invalidated. Not as comments the agent reads, but as structural markers that the attention mechanism can use.
Think of it like a generational garbage collector for cognitive state. Old generations are not dead. They are candidates for compaction. The system tracks reachability: which context fragments are still referenced by the current reasoning chain, and which are isolated?
Negative Context Statements
Agents should periodically emit explicit invalidations.
“The assumption from step 3 that the API returns XML is now invalidated. It returns JSON. All reasoning based on XML structure should be discarded.”
This is the inverse of dead code deletion. Instead of removing the dead thing, you mark its death certificate. The dead context remains visible for audit but carries a clear signal that its conclusions are expired.
The Working Set Model
Borrow from operating systems. Maintain a working set of context: the minimum set of information needed for correct operation on the current task. Context outside the working set is not deleted. It is swapped to secondary storage like a vector index, structured log, or external reference.
The agent can still retrieve it, but it does not sit in the attention window paying taxes on every forward pass.
The Real Problem Is Invisible
Dead code has a linting culture. We know it exists, we know how to find it, and we know what it costs.
Dead context has none of this. Most agents treat their context window as an append-only ledger. Everything goes in. Nothing gets a lifecycle. The result is a cognitive workspace that degrades silently over the course of a session. Nobody can see it happening. Not the agent. Not the operator. Not the evaluator.
Until we treat context as a resource with a lifecycle, not just a container with a size limit, we will keep building agents that are dumber in hour four than they were in hour one, and calling it emergent behavior.
It is not emergence. It is rot.