Definition: Context rot is the steady decline in the quality of an AI model's answers as a conversation grows longer, because every extra token inside the context window competes for the same fixed pool of attention, so the part that actually matters gets read less carefully even though the model, the question, and the instructions never changed.
TL;DR: Context rot is the accuracy loss that creeps into a long AI conversation well before the context window is technically full. A 2025 Chroma study of 18 leading models found reliability falling as input grew, even on tasks as simple as copying a repeated word. The fix is fewer, better-chosen tokens, not a bigger window. Build one free →
You already know the feeling from a long email thread. By message forty, the one decision that actually matters is buried in the middle somewhere, and the newest person on the thread answers the wrong question because they skimmed. Nobody on the thread got less capable. The thread just stopped being readable. Context rot is that same thing happening to a model, at speed, inside a single session.
Why Context Rot Matters in 2026
Bigger context windows did not solve long conversations, and by 2025 there was evidence to prove it. In the Chroma technical report "Context Rot: How Increasing Input Tokens Impacts LLM Performance", published July 2025, Kelly Hong and colleagues ran 18 state-of-the-art models through controlled tests and found that performance degrades as input length grows even on trivially easy tasks. The Adobe-led NoLiMa benchmark found the same shape from a different angle: of 13 models that all advertise support for at least 128,000 tokens, 11 scored below half their short-input baseline once the input reached 32,000 tokens.
This matters because the entire industry sells window size as a capability number. A window is a ceiling, not a promise. Treating a million-token window as a million tokens of usable working memory is the single most expensive mistake teams make when they move from demos to production, and it is why context engineering became a named discipline rather than a footnote inside prompt engineering.
How Context Rot Works
A large language model does not read a conversation the way you read a page, one line after another with the earlier lines safely filed away. On every request it looks at all of it at once and decides how much weight to give each piece. That weighing is the attention mechanism inside the transformer, and its capacity per request is finite. Attention behaves like a budget: whatever the model spends noticing an abandoned tool result from twenty turns ago is not available for the sentence that carries your actual constraint.
- The window refills from scratch every turn. The model is stateless and remembers nothing on its own, so the software around it, the agent harness, re-sends the entire transcript on every single request. Nothing is filed away. Everything is re-read.
- The transcript only grows. Each turn adds your message, the model's reply, and every tool call it made along the way, successes and failures alike. A run of the agent loop that took eight steps leaves eight steps behind.
- Attention divides across all of it. Weight given to one part is weight taken from another. Ten thousand tokens of relevant material inside a hundred thousand tokens of transcript is a one-in-ten signal, not a strong one.
- Position decides who wins. In the Stanford paper "Lost in the Middle", Nelson Liu and colleagues showed accuracy tracing a U across a long input: material at the beginning and the end is used reliably, material in the middle is frequently missed. Your instruction from turn three is now sitting in the weakest position in the window.
- Near-duplicates actively mislead. Four slightly different versions of the same figure, three of them stale, make the model's job harder than one clean version would. This is a common route to hallucinations in a conversation that started out accurate.
- The decline is quiet. Nothing errors. The token count is still under the limit. The answers just get vaguer, and by the time you notice, several turns have been built on the vague ones.
How to Spot Context Rot
Context rot has a recognizable signature, and it is not the signature of a bad model. Quality is fine early and degrades with length, which means the same agent that handled turn three well starts missing things by turn thirty. Here is what that looks like inside one long run:
TURN 3 you: "Always answer in bullets, never prose."
agent: clean bullets [rule held]
TURN 19 agent: three paragraphs of prose [rule slipped]
TURN 24 you: "The client is Riverside. I said that at the start."
agent: "Thanks, noted." [asked again]
TURN 31 agent: cites a figure that is in no document [invented]
TURN 38 agent: re-runs a search it already ran in T12 [lost its place]
TURN 44 you: open a fresh session, paste the 5 facts that matter
agent: sharp again [reset worked]
The tell is turn 44. If a clean session with a short, well-chosen brief immediately outperforms the long one, the problem was never the model's ability. It was the volume of text the ability had to be spread across.
Context Rot vs Running Out of Context Window
These two get treated as the same problem and they are not. Running out of window is a hard, visible limit with an error attached. Context rot is a soft decline that produces confident, plausible, worse answers with no warning at all.
| Trait | Running out of context window | Context rot |
|---|---|---|
| What happens | A hard ceiling: the request is refused, or the oldest turns are dropped | Nothing breaks, the answers just get worse |
| When it starts | At the model's stated token limit | Long before it, often at a fraction of the limit |
| How you notice | An explicit error or visibly truncated history | Ignored rules, repeated questions, invented details |
| Root cause | A fixed budget is full | Attention spread thin across too many competing items |
| Does a bigger window fix it | Yes, mechanically | Barely, it usually just delays the decline |
| What actually fixes it | More room, or fewer tokens | Fewer and better-chosen tokens |
| Where to read more | Context window | Context engineering |
The practical consequence is that "we upgraded to a bigger window" is rarely a fix. It raises the ceiling that was not the constraint, and it makes the middle of the window, the weakest position, considerably larger.
What to Do About Context Rot
There are four moves, and picking the right one takes about five seconds once you know what you are choosing between. All four do the same thing in different ways: raise the share of the window that is actually about the task in front of you.
1. Start fresh. The cheapest and most underused move. Open a new agent session and hand it only the handful of facts the next stretch of work depends on. Practitioners call this clearing. It feels wasteful and almost never is, because the previous session's value was five sentences, not five hundred. Write those five sentences into a project or into agent memory first, and the reset costs you nothing.
2. Compact. When the task genuinely has to continue, replace the older turns with a summary of what was decided and why, then keep going in the same run. This is context compaction, and good agent software does it automatically as the window fills. A compacted transcript keeps the decisions and drops the deliberation, which is usually a ten-to-one reduction with almost no loss of what matters.
3. Trim. Compaction summarizes; trimming deletes. Failed tool calls, superseded drafts, three near-identical copies of the same document, a detour you abandoned: none of it earns its place, and all of it is competing for attention. Deciding what to cut before the model ever sees it is the core of context engineering, and it usually beats any amount of rewording in the system prompt.
4. Split the work. When one run is really four jobs, stop making one window hold all four. Hand each job to a subagent that starts clean, does its piece, and returns a short result instead of its whole transcript. The orchestrator keeps a compact plan and never inherits the detail. This is the main structural reason multi-agent teams outperform one long-running agent on large tasks, and it pairs naturally with parallelization.
One habit is worth more than all four: put the durable facts somewhere durable. A constraint that lives only in turn three of a chat will rot. The same constraint written into a project, an agent's knowledge, or persistent memory gets re-supplied fresh on every request, at the top of the window where it is read most reliably.
Connection to Taskade
Taskade is built so the durable version of your context lives outside the chat by default. That is what Workspace DNA describes: Memory feeds Intelligence, Intelligence triggers Execution, and Execution writes new Memory back. Your projects are the Memory, so decisions, records, and notes are kept as structured work rather than as transcript, and the memory graph assembles the relevant slice for each request instead of pasting everything in. Sessions stay short because they do not have to carry the history.
Every Taskade AI Agent works this way. It reads the projects you point it at, calls any of built-in tools, reaches live records through 100+ bidirectional integrations so it reads current data rather than a stale paste, and routes each step to the right model from 15+ frontier models from OpenAI, Anthropic, Google, and open-weight providers. When work outgrows one run, you split it across a team of agents instead of one endless thread. Every automation opens its own fresh session on trigger, does the job, and writes the outcome back into a project, which means a scheduled job starting on day ninety is exactly as sharp as it was on day one.
What You Would Build in Taskade
Think about the long-running thing you keep re-explaining: an account you have been managing for a year, a product spec that changed four times, a hiring pipeline where the decision from March matters in September. Right now that history lives in a chat log or in your head, and both of them rot.
In Taskade you would describe an account brief that maintains itself. One project per account holds the current state: what was agreed, what changed, what is outstanding, who owns it. An agent updates that page after every meeting note or connected email, keeping it to a page rather than a transcript. When you ask a question, the agent reads the page, not the year. When the quarter turns, you start a new run and lose nothing, because nothing important was ever only in the conversation. Your team reads the same record in whichever of the 7 project views they think in, a list, a board, or a table.
Describe yours and build it free →
Related Concepts
- Context Window: the ceiling everything competes inside
- Context Engineering: choosing what the model sees each request
- Context Compaction: summarizing history so a run can continue
- Attention Mechanism: the finite budget that rot spreads thin
- Agent Session: the bounded run rot accumulates inside
- Subagents: splitting a job so each window stays small
- Agent Memory: what survives after you start fresh
- Token: the unit every window is measured in
- Agent Knowledge (Learn Taskade): attaching durable sources to an agent
Frequently Asked Questions About Context Rot
Why does AI get worse in long conversations?
Because the model re-reads the entire conversation on every reply and divides a fixed pool of attention across all of it. As the transcript grows, the share of that attention landing on the part you care about shrinks. Nothing errors, so the decline is easy to miss until several answers have been built on it.
What is context rot in AI?
Context rot is the gradual loss of accuracy as an AI conversation or input grows long, even while the token count stays under the model's limit. Typical symptoms are ignored instructions, questions you already answered being asked again, facts from early on quietly dropping out, and invented details presented confidently.
Is context rot the same as running out of context window?
No. Running out of context window is a hard limit with a visible failure: the request is refused or old turns get dropped. Context rot happens well below that limit and produces no error at all. One is a capacity problem, the other is a signal-to-noise problem, and they need different fixes.
Does a bigger context window fix context rot?
Rarely. The 2025 Chroma report found that reliability drops with input length across 18 leading models regardless of the advertised ceiling, and Stanford's Lost in the Middle work showed material buried mid-input is read least reliably. A bigger window mostly enlarges that weak middle. Selection beats volume.
When should I start a new chat with an AI agent?
Whenever you switch topics, and whenever answers start slipping on a task you have been on for a while. Write the handful of facts that matter into a project or agent memory first, then open a fresh session. A short, well-chosen brief usually beats a long transcript immediately.
What is compaction, and does it lose information?
Compaction replaces older turns with a summary of what was decided, so a long run can continue without carrying every word. It does drop detail on purpose: the deliberation goes, the decisions stay. That trade is almost always favorable, because the dropped material was the part competing hardest for attention.
How do I stop context rot in an AI agent?
Four moves. Start a fresh session when the topic changes, compact when the task must continue, trim dead ends and duplicates before the model ever sees them, and split large jobs across subagents so no single window holds everything. Then keep durable facts in a project rather than in a chat.
Do Taskade agents avoid context rot?
Taskade keeps the durable half of your context out of the transcript. Projects hold the decisions, the memory graph supplies only the relevant slice per request, and automations open a fresh session on every trigger. Long-running work is split across a team of agents rather than one thread that keeps growing.
Further Reading
- Context Engineering: The Complete 2026 Field Guide: production patterns for keeping windows clean
- Agent Harness: the software that assembles the window every turn
- The Agent Loop: where a transcript grows one step at a time
- Thinking Modes (Learn Taskade): matching reasoning depth to the task