Context rot is the measurable decline in an AI model's accuracy as its context window fills up. It affects every frontier model, including GPT-5.4, Claude, and Gemini, regardless of how large the advertised context window is. The fix is not a better prompt. The fix is feeding the model less, on purpose.
You have felt this even if you have never had a word for it.
The chat starts brilliantly. You paste in the brief, the model nails it, you go back and forth, and for about twenty minutes it feels like the smartest colleague you have ever had. Then something turns. It starts repeating a suggestion you already rejected. It forgets the constraint you set at the top. It gets weirdly agreeable. By message forty you are arguing with a very confident amnesiac, and you close the tab convinced the model got dumber.
It did. That is not a feeling, it is a measured effect, and in 2026 it has a name.
What is context rot?
Context rot is the degradation of a language model's performance as the number of tokens in its context window increases. The model does not forget in the human sense. Its attention spreads thinner across everything it has been given, so the signal you care about gets buried under everything else you pasted, and accuracy falls even on tasks the same model handles perfectly with a shorter input.
The term entered common use after a July 2025 technical report from Chroma, Context Rot: How Increasing Input Tokens Impacts LLM Performance by Kelly Hong, Anton Troynikov and Jeff Huber. They evaluated 18 large language models, including GPT-4.1, Claude 4 and Gemini 2.5, and found that performance degrades in what they described as surprising and non uniform ways as input length grows. Not gradually. Not predictably. And not only on hard tasks: they saw it on jobs as trivial as copying text back.
Anthropic's engineering team put it in plainer language in Effective context engineering for AI agents, published in September 2025. Models have an attention budget. Every token you add spends some of it. Context is a finite resource with diminishing marginal returns, which means the twentieth document you paste in is not free, and it is not neutral either. It is actively competing with the nineteen before it.
That is the whole idea. More is not more. More is often less.
Why did bigger context windows not fix this?
Bigger context windows did not fix context rot because the problem is attention, not capacity. A model with a one million token window can technically see everything you gave it. What it cannot do is attend to all of it equally. Capacity is how much fits in the room. Attention is how much the model can actually hold in its head at once, and that number has barely moved.
There was a genuinely reasonable argument circulating in late 2024 and early 2025 that went: windows are enormous now, retrieval is dead, just paste the whole thing in and let the model sort it out. It sounded clean. It did not survive contact with production.
Here is the number that should end the argument. Databricks Mosaic Research found that 11 out of 12 frontier models drop below 50 percent accuracy on reasoning tasks once context exceeds roughly 32,000 tokens. Thirty two thousand. Not one million. If you are pasting a long report plus a transcript plus three emails plus your notes into one chat, you have probably crossed that line before you asked your first real question.
There is an older finding underneath this that researchers call lost in the middle: models reliably retrieve information from the beginning and the end of a long input, and reliably miss things buried in the middle. Accuracy plots as a U shape. Put your most important constraint halfway down a long paste and there is a decent chance the model never really sees it.
And the strangest result of the lot, which I still find slightly unsettling: coherent, well structured input can degrade attention more than shuffled input does. Tidy your context beautifully and you may make it worse. Structure is not the same thing as signal.
What does the research actually say?
The research on context rot converges on one finding across independent labs: what matters is not whether the right information is in the window, but how much other stuff is in there with it. Chroma tested 18 models. Databricks tested 12. Anthropic observed it internally. Every study found the same shape of failure, and none found a model immune to it.
A few numbers worth keeping in your head:
- Chroma evaluated 18 models and found none that maintained consistent performance across input lengths, even on simple retrieval and text replication tasks.
- Databricks Mosaic Research: 11 of 12 frontier models fall below 50 percent reasoning accuracy past about 32,000 tokens.
- The Gemini 2.5 team, running an agent that played Pokemon, watched it stop making new plans and start replaying old ones once context passed roughly 100,000 tokens.
- A Microsoft and Salesforce study cited by Drew Breunig found a 39 percent quality drop when a single well formed prompt was broken up into a sequence of conversational turns. Same information. Worse answer. Purely because of how it was delivered.
- Average prompt length roughly quadrupled between 2024 and 2025, from about 1,500 tokens to about 6,000, driven by agentic workflows. We are all feeding the models more, faster, than the models got better at handling it.
That Microsoft and Salesforce result is the one I would tattoo on the inside of my eyelids. A 39 percent drop, not from bad information, but from drip feeding good information. Which is exactly how normal people use chat. You do not write a perfect brief. You have a conversation. And the conversation itself is the thing degrading the output.
What changed in 2026, and why this got worse rather than better
Context rot got more painful in 2026, not less, because the tools got more agentic. A chat has one input and one output. An agent runs a fifteen step task, reads files, calls tools, and appends every result to its own context as it goes. It can burn through 100,000 tokens before it has done any real thinking, and nobody is watching the window fill up.
The releases this year all pushed in the same direction. OpenAI shipped GPT-5.4 in March with native computer use and a context window over one million tokens. Google launched Gemini 3.5 and Gemini Omni at I/O in May, explicitly framed as the agentic era, with models built to execute multi step workflows across your apps. The Model Context Protocol, which Anthropic donated to the Agentic AI Foundation, passed 97 million installs in March and became the default way agents reach external tools.
Every one of those advances adds tokens. Native computer use means screenshots in the context. MCP means tool definitions and tool outputs in the context. Multi step agentic runs mean the results of step four are still sitting there at step fourteen, quietly competing for attention with the thing you actually asked for.
So the capability went up and the context discipline required to use it went up with it. That is the trade nobody puts on the launch slide. A 2026 survey found that 65 percent of developers now cite missing or rotted context as the leading cause of poor AI output, ahead of model capability, framework choice, and prompt phrasing. The model is rarely the bottleneck any more. What you fed it is.
The four ways context breaks
Drew Breunig, whose taxonomy has become the standard vocabulary for this, splits context failure into four distinct modes. They are worth learning to spot individually, because the fix for each one is different and applying the wrong fix wastes your time.
Context poisoning
Context poisoning happens when a hallucination or a wrong fact enters the context early, and every subsequent step builds on it. The model does not treat its own earlier output as a guess. It treats it as established. So one confident error at message three quietly contaminates messages four through forty, and by the end the model is reasoning impeccably from a false premise.
You spot it when the model keeps returning to a claim you never made and cannot remember agreeing to. Check the transcript. It probably said it once, you did not correct it, and it has been treating it as gospel ever since.
Context distraction
Context distraction is what happens when the window gets so full that the model starts leaning on the conversation history instead of its own trained knowledge. Rather than reasoning fresh, it pattern matches against what has already happened in the chat. It repeats itself. It reuses a structure it used earlier. It stops generating and starts echoing.
The Pokemon agent is the cleanest illustration anyone has produced. Past a certain volume of history, it stopped forming new plans and simply replayed old ones, over and over, with total confidence. If your model keeps giving you a variant of an answer you already told it was wrong, this is why.
Context confusion
Context confusion is the failure where irrelevant material in the window drags quality down because the model tries to use everything it was given. Models are obliging. If you hand them a document, they assume you handed it over for a reason. Paste in a spreadsheet you no longer care about and the model will keep trying to make it relevant to a question it has nothing to do with.
This is the one that punishes generosity. You were being helpful by including background. The model reads inclusion as instruction.
Context clash
Context clash occurs when parts of your accumulated context start contradicting each other. You said one thing on Tuesday, refined it on Wednesday, and both versions are still sitting in the window with equal weight. The model has no reliable way to know which one wins, so it either picks wrong or splits the difference and produces something that satisfies neither.
Long strategy chats are where this lives. You iterate, you change your mind, you never delete the old version, and the model faithfully carries every dead draft forward.
How do you know if your chat has rotted?
The fastest test for context rot takes about fifteen seconds. Somewhere around turn twenty to thirty, stop and ask the model to restate a decision you made early in the conversation. If it gets it wrong, softens it, or invents a version you never agreed to, the context has rotted and no amount of clever prompting will recover it.
Three other symptoms worth watching for, because they show up before the formal test does:
It gets agreeable. A model that has stopped reasoning and started pattern matching will agree with almost anything, because agreeing is the highest probability continuation of a long friendly conversation. If your AI has not pushed back on you in twenty messages, that is not a sign you are right. If you want to force it back into a critical posture, the five word trick that stops your AI agreeing with everything is the cheapest intervention there is, though it treats the symptom rather than the cause.
It gets vague. Specificity is expensive. As attention thins, the model drifts toward generic, safe, medium confidence output, because generic output is what you get when nothing in the window is loud enough to anchor on.
It ignores your format. You asked for bullets. You are getting essays. Formatting instructions are usually short and given early, which makes them the first casualty of a filling window.
Where context rot bites hardest
Context rot shows up worst in three specific situations, and each one has a different tell. Knowing which one you are in tells you which fix to reach for, rather than cycling through all nine and hoping.
The long research chat
You are exploring a topic. You paste an article, then another, then a report, then your own notes. Forty minutes in, the model starts producing bland summaries that could apply to any of the sources and say nothing specific about any of them.
This is context confusion. Everything you pasted is competing, so the model retreats to the safest common denominator. The fix is not to prompt harder. It is to close the chat, decide which two sources actually matter, and start again with only those. You will get a sharper answer in one message than you got in the previous forty.
The document you keep revising
You are drafting something with the model over several rounds. Version four is worse than version two. It has reintroduced a phrase you cut, and it keeps drifting back to a structure you explicitly abandoned.
This is context clash, and it is entirely predictable. Every rejected draft is still in the window with the same weight as the approved one. The model has no way to know which version is canonical unless you tell it. The fix: paste the current version fresh into a new chat and say "this is the only version that exists." The dead drafts stop voting.
The agent that goes quietly insane
You gave an agent a long task. It started well, then somewhere around step nine it began repeating actions, re reading files it had already read, and reporting progress on work it had already done.
This is context distraction, and it is the Pokemon failure exactly. The agent is now pattern matching against its own history rather than reasoning about the task. Long agentic runs need compaction built in, which is why sub agent architectures work: each sub agent explores with a clean window and returns only a condensed summary, typically one to two thousand tokens, instead of dumping its entire working context back into the parent.
Nine fixes that work in any model
None of these require a subscription upgrade, a plugin, or a single line of code. They are habits. The first six take seconds. The last three are structural, and they are the ones that actually compound.
1. Start a new chat far earlier than feels natural
This is the habit that pays for itself fastest, and the one almost nobody does, because starting over feels like losing progress. It is not. You are not losing the work, you are losing the sludge. Copy the three or four facts that still matter, open a fresh chat, paste them in, and carry on. You will get a noticeably sharper model on the other side.
My rule of thumb: if you have changed direction twice, the chat is done. Start again.
2. Restate the target every time you change direction
When you pivot mid conversation, do not just say "actually, make it shorter." Say what the goal is again, in full. One line. "Reminder of the target: a 200 word summary for a client who has not read the brief, no jargon, ends with a single recommendation."
This works because of the lost in the middle effect. Your original instruction is now buried in the geographic middle of the window, which is precisely where models stop looking. Restating it moves it back to the end, which is where they look hardest.
3. Prune before you add
Before you paste the next document in, ask whether the last one still earns its place. Most of the time it does not. If your interface lets you edit an earlier message, delete the dead weight rather than piling new material on top of it. Simon Willison calls this context pruning, and it is the least glamorous, most effective thing on this list.
4. Offload instead of pasting
Context offloading means keeping information outside the conversation and pulling it in only when the task actually calls for it. In practice: put the reference material in a file or a project rather than in the chat. Say "check the pricing table when you need a number" instead of pasting the pricing table into every message. The model reads it when it needs it. The rest of the time it costs you nothing.
5. Quarantine anything you have not verified
Context quarantine means treating new or uncertain information as suspect until you have confirmed it, rather than letting it flow straight into the model's reasoning. If the AI produces a figure you cannot immediately verify, say so out loud in the chat: "Treat that number as unconfirmed, do not build on it." Otherwise it becomes fact by message six, and you have poisoned your own well.
6. Number your inputs
When you paste a long thread, transcript, or document chain, number the sections before you paste. The model stops skimming and starts addressing each unit, which drags its attention off the top of the input and across the whole thing. I wrote this one up separately, because it is the highest return single line of setup I know: the numbering trick that makes AI read long email threads properly.
7. Put the instruction last
Material first, instruction after. Models weight the end of the input heavily, so an instruction that arrives after 4,000 words of context lands with far more force than the same instruction sitting on top of it. If you have ever pasted a long document with your question at the beginning and got an answer to a question you did not ask, this is why.
8. Compact and reboot
When a chat has become genuinely valuable but genuinely bloated, ask the model to write a handover note: the decisions made, the constraints agreed, the open questions, nothing else. Then open a new chat and paste the handover in as the only context. You have compressed forty messages into four hundred words, and you have thrown away the contradictions.
A warning, because this fix has a failure mode of its own. Researchers have documented context collapse, where a model asked to rewrite its accumulated context compresses it far too aggressively and loses the substance. In one benchmark run, a context of 18,282 tokens collapsed to 122 tokens in a single step, and accuracy fell below the baseline of not summarising at all. So read the handover note before you trust it. If it looks thin, it is thin.
9. Load a skill instead of a wall of context
Everything above is damage control. This one is the actual answer, and it is the reason the whole industry moved this way in 2026.
Why skills are the structural fix
Agent Skills solve context rot at the architectural level using progressive disclosure. Instead of loading your instructions into the window every session, a skill sits dormant at a cost of roughly 100 tokens of metadata, and loads its full body only when the model decides the task actually matches. Fifty skills installed costs you about 5,000 tokens. Fifty pasted instruction sets would cost you 100,000 and rot your context before you started.
The mechanics, from Anthropic's Agent Skills documentation, work in three tiers:
- Tier one, always loaded. Just the skill's name and a one line description, around 100 tokens. The model uses this to decide whether the skill is relevant.
- Tier two, loaded on trigger. The full body of the SKILL.md file, typically one to two thousand tokens. This only enters the window when the model matches your request to the description.
- Tier three, loaded on demand. Reference files, templates and scripts inside the skill folder. The model reads these only if the instructions tell it to. A skill can bundle a 200 page playbook and cost nothing until page 47 is genuinely needed.
That is the whole trick. It is not that skills are smarter than prompts. It is that skills are absent until they are needed, and absence is the scarcest resource in a context window.
The format is an open standard. Anthropic open sourced it in December 2025 and OpenAI adopted the same SKILL.md spec for Codex CLI and ChatGPT. It also works with Gemini CLI, Cursor and GitHub Copilot. Write a skill once and it runs across the tools you already use, which means the work you do to escape context rot is not locked to one vendor.
If you have not built one yet, start here: what is a SKILL.md file, and how to give any AI its own skill. If you would rather skip the build and install something that already works, the AI Skills library has 96 of them.
Prompt, project, skill or MCP: which one do you actually need?
Use a prompt for one off instructions, a project for reference material you want available across many chats, a skill for a repeatable procedure you want the model to run the same way every time, and MCP when the model needs live access to an external system. Choosing wrong is one of the main reasons people end up with rotted context: they use a prompt where a skill belonged, and pay for it in tokens every single session.
| Layer | What it is | Context cost at rest | Use it when |
|---|---|---|---|
| Prompt | Instructions typed into one conversation | Full cost, every time, forever | The task is genuinely one off |
| Project or custom GPT | Files and instructions attached to a workspace | Loaded per chat in that workspace | You need the same background across many chats |
| Skill (SKILL.md) | A procedure the model loads only when it matches | About 100 tokens until triggered | You repeat a process and want it run consistently |
| MCP server | A live connection to an external tool or data source | Tool definitions sit in context | The model needs to read or write real systems |
The distinction that matters most: skills teach the model how to do something, MCP gives it access to something. People reach for MCP when they needed a skill, then wonder why their context is full of tool definitions they never use. If your problem is that the model does the task inconsistently, that is a skill problem. If your problem is that the model cannot see your calendar, that is an MCP problem. They are not substitutes.
For a longer treatment of how these layers stack in practice, inside five Layer 3 workflows breaks down five real setups component by component.
What context rot is actually costing you
Context rot has two prices. The obvious one is quality: worse answers, more rework, decisions made on output you should not have trusted. The second one is money, and most people never look at it, because the cost is metered in tokens and tokens are invisible.
A poorly contexted agent that burns 50,000 tokens per turn when 5,000 would do is ten times more expensive than the well engineered version. On a personal subscription you notice this as hitting your usage limit halfway through a Tuesday. On an API bill you notice it as a number that makes your finance lead ask questions. Either way you are paying a premium for the privilege of getting a worse answer, which is a genuinely impressive way to lose twice.
There is a wider point here that took me a while to accept. The instinct that got you good results in 2023, which was to give the model as much as possible, is now the instinct actively working against you. The skill has inverted. The people getting the most out of these tools in 2026 are not the ones writing the longest prompts. They are the ones being ruthless about what they leave out.
If you want the token discipline packaged rather than learned the hard way, LEANBURN is a standalone skill built specifically to cut token waste and keep context lean across any model. It is 29.99 USD, and it pays for itself the first time it stops you pasting a 40 page PDF you did not need.
A twenty minute setup that mostly ends this
Rather than adopting nine habits at once, which nobody does, spend twenty minutes on the three that carry most of the weight.
Minutes one to five. Write down your three most repeated tasks. Not aspirational ones. The actual things you re explain to an AI every week. Drafting the weekly update. Rewriting emails in your voice. Turning meeting notes into actions.
Minutes six to fifteen. Turn the top one into a skill. A skill is a text file. Name it, describe when it should fire, and write out the steps the way you would explain them to a new hire. The description is the load bearing part: vague descriptions never trigger, specific ones fire reliably. Then upload it. In Claude, that is Settings, then Capabilities, then Skills.
Minutes sixteen to twenty. Set your reset rule. Decide now, while you are calm, at what point you start a new chat. Two direction changes. Or thirty messages. Or any time you catch it agreeing with you twice in a row. Write the rule down. You will not follow it otherwise, because in the moment starting over always feels like the expensive option.
If you want the diagnostic before the build, the AI workflow audit will tell you which layer you are actually stuck at, and the three layers of AI fluency explains why copy pasted prompts never compound the way skills do.
Six lines worth saving
These are the exact lines I use. They work in ChatGPT, Claude, Gemini and Grok, they need no setup, and each one targets a specific failure mode described above. Steal them.
To test whether a chat has rotted:
Before you answer, restate the goal and the constraints I gave you at the start of this conversation, in your own words. Do not look at anything else.
If what comes back is wrong or vague, stop. The chat is done. Everything after this point is guesswork dressed up as confidence.
To re anchor after changing direction:
Reset. Ignore every previous version. The only target is this: [one sentence]. The only constraints are: [two or three]. Confirm you have those before you write anything.
To quarantine an unverified fact:
Treat that figure as unconfirmed. Do not use it in any downstream reasoning until I verify it. Flag anywhere it would have changed your answer.
To force attention across a long input:
I am pasting [N] numbered items. Address each one by number before you synthesise anything. If an item contains no relevant information, say so explicitly rather than skipping it.
To compact a bloated chat before rebooting:
Write a handover note for a colleague picking this up cold. Include: decisions made and why, constraints agreed, open questions, anything explicitly ruled out. No preamble, no summary of the conversation itself. Facts only.
To stop the model reasoning from its own earlier mistake:
You made a claim earlier in this conversation that I never confirmed. Identify every assumption you are currently carrying that came from your own output rather than from me, and list them.
That last one is my favourite and the least used. It is remarkable how often the model turns around and says, essentially, "ah, I have been assuming your budget was 50,000 dollars, and you never said that." You did not tell it. It told itself, three messages ago, and has been building on it ever since.
Frequently asked questions
What is context rot in simple terms?
Context rot is when an AI gets worse at its job because you have given it too much to hold in mind at once. It is not forgetting. The information is still technically in the window. The model's attention is just spread too thin across it to use it properly, so accuracy falls even on tasks it would ace with a shorter input.
Does context rot affect ChatGPT, Claude and Gemini equally?
It affects all of them, though not identically. Chroma tested 18 models across the major families and found degradation in every one, with some declining more gently than others. No model on the market in 2026 is immune, and a larger advertised context window does not mean a more resistant model.
Does a one million token context window solve context rot?
No. Capacity and attention are different things. A one million token window means the model can hold that much. It does not mean it can attend to that much. Databricks Mosaic Research found most frontier models drop below 50 percent reasoning accuracy past around 32,000 tokens, which is a small fraction of the advertised limit.
How many messages before a chat goes bad?
There is no fixed number, because it depends on how much you paste rather than how many times you speak. As a working rule, test the chat at turn twenty to thirty by asking the model to restate an early decision. If it fumbles that, the rot has set in. In practice, two changes of direction is usually the point of no return.
Is context engineering the same as prompt engineering?
No. Prompt engineering is about how you word a single instruction. Context engineering is about what occupies the window at every moment: what to include, what to evict, what to compress, and what to keep outside the conversation entirely. Anthropic's Applied AI team formalised the term in September 2025, and for anything longer than a single exchange it is the more useful discipline.
Do AI skills actually reduce context rot?
Yes, structurally rather than as a workaround. Skills load through progressive disclosure: about 100 tokens of metadata sit in context permanently, and the full instructions load only when the model matches your task to the skill's description. Fifty installed skills cost roughly 5,000 tokens at rest. The same instructions pasted into the chat would cost twenty times that and rot the window before you asked anything.
Why does my AI start agreeing with everything I say?
Because agreement is the highest probability continuation of a long, friendly conversation. Once attention thins, the model leans on the shape of the conversation rather than the substance of the question, and the shape says "this person and I are getting along." It is a symptom of context distraction, not a personality flaw. Starting a fresh chat fixes it more reliably than telling it to be critical.
Should I just paste less into the chat?
Mostly yes, and that is genuinely the whole insight. But there is a real counterpoint worth holding: some tasks need the full document, and chopping it up will lose the cross references the model needs to reason across it. The current default in production systems is hybrid. Retrieve the relevant 50,000 to 200,000 tokens, then reason over that, rather than either pasting everything or retrieving tiny fragments. Pure long context rots. Pure retrieval misses connections. Judgement is still required.
Can I fix a chat that has already rotted?
Not really, and this is the part people resist. Once bad information or dead drafts are in the window, they keep voting. You can dilute their influence by restating the goal at the end, but you cannot remove them by asking nicely. The reliable move is to extract what still matters into a handover note, open a new chat, and paste only that. Treat a rotted chat as a first draft, not as something to rescue.
Sources
- Hong, K., Troynikov, A., and Huber, J. Context Rot: How Increasing Input Tokens Impacts LLM Performance. Chroma Research, July 2025.
- Anthropic. Effective context engineering for AI agents. Anthropic Engineering, September 2025.
- Breunig, D. How Long Contexts Fail. June 2025. Source of the four mode taxonomy used above.
- Anthropic. Agent Skills overview. Claude Platform documentation.
Last updated 14 July 2026.
Laisser un commentaire :