Why do AI agents get less reliable the longer they run? The answer has a name that spread through engineering teams in 2026: context rot — the measurable way a large language model’s accuracy decays as its context window fills, even on tasks it aces when the input is short. The counterweight is equally simple. When a model can no longer trust its own memory, the truth about the work has to live somewhere the model can’t corrupt: outside the window, on a shared board.
That is where this connects to Lova, our chat-first AI project management product where AI agents work as teammates — claiming bounded tasks on a shared board, moving them through defined states, and leaving an audit trail every teammate, human or agent, can read. Context rot is the reason that board isn’t just a coordination convenience. It’s a correctness layer. An agent whose context has rotted can re-read the board and recover exactly what’s done, what’s claimed, and what’s next — ground truth it can no longer reconstruct from inside its own head.
Key takeaways
- A controlled study from the AI research lab Chroma tested 18 leading models and found accuracy falls as input length grows — even on simple retrieval and text-copying tasks, and well before the advertised context limit.
- The fix isn’t a bigger window. A model’s own engineers describe context as a finite “attention budget”, stretched thin because every token must attend to every other token.
- Agents now run long enough for rot to bite. Frontier models can sustain focus on a single build for more than 30 hours, and the length of task they can finish is doubling roughly every seven months.
- The prescribed answer is to keep durable state outside the window — structured notes the model writes down and reloads. A shared board is that idea built for a whole team instead of one agent talking to itself.
- It already matters at scale: the average enterprise runs 12 AI agents, half of them isolated from one another — each rotting privately, with no shared memory to fall back on.
What is context rot?
Context rot is the degradation in a language model’s output quality as the amount of text in its context window grows. The marketing implies the opposite: a million-token window is sold as a million tokens you can rely on. The research says otherwise. In a controlled evaluation, Chroma ran 18 state-of-the-art models through tasks as basic as finding a fact buried in a document and copying text verbatim, then watched accuracy slide as the input got longer — not at some far cliff-edge, but steadily, and long before the documented limit. The most counterintuitive result: a clean, coherent document degraded the model’s attention more than a shuffled one. The thing that looks easiest to read is, for the model, sometimes the hardest to hold.
The mechanism isn’t mysterious. As one frontier lab’s engineering team explains, context is a finite resource with a diminishing marginal return. Because every token in the window has to attend to every other token, the relationships to track grow with the square of the length, and the model’s “attention budget” stretches thinner the more you load in. They use the same phrase the community adopted: context rot. When the budget runs out, the symptoms are the ones anyone who has watched a long agent run will recognize — it forgets an early result, re-does a step it already finished, or contradicts a decision it made an hour ago, all while sounding perfectly confident.
Why do AI agents get dumber as they run longer?
Because an agent’s run is its context. Every tool call, every file it reads, every intermediate result gets appended to the same window, and the window is exactly the thing that rots. A short chat rarely triggers it. A multi-hour agent doing real work — dozens of tool calls, large files, back-and-forth with a codebase — fills the budget fast, and the back half of the task runs on a degraded version of the front half. This is the distinct cousin of the memory problem we wrote about in why your AI agents keep forgetting everything: that piece is about agents starting from zero between sessions; context rot is about an agent losing the thread within a single session, right when the stakes are highest.
And agents now run long enough for it to matter constantly. A frontier model can stay on one build for more than 30 hours unattended, shipping an app of roughly 11,000 lines without a human touching it. The trajectory is steep: METR finds the length of task an agent can complete is doubling about every seven months, yet the horizon at which an agent succeeds 80% of the time stays a fraction of the horizon at which it succeeds 50% of the time. The gap between “can run this long” and “can be trusted this long” is context rot showing up in the numbers. We traced the same tension in long-horizon AI agents and the end of the two-week sprint — the runs got longer; the reliable window didn’t keep pace.
Can a bigger context window fix context rot?
No — and this is the part most teams get backwards. A larger window is more room to rot, not less. The study’s whole point is that the failure scales with length, so buying a bigger context buys a bigger surface for the problem. That’s why the people closest to the models don’t prescribe “use more context.” They prescribe the opposite: keep the window small and the durable truth somewhere else. The recommended pattern is structured note-taking — the agent writes what matters to an external file, then reloads it when needed, holding long-horizon coherence without carrying the whole history in working memory. This is the same instinct behind context engineering: the skill isn’t stuffing the window, it’s deciding what earns a place in it.
Here is the original claim worth sitting with. A private NOTES file is a solo agent talking to itself — a patch that helps one model survive its own rot. But real work isn’t one agent. It’s several agents and several humans touching the same tasks, and a scratch file each one keeps privately is just coordination by rumor. The externalized memory that actually holds a team together has to be one surface, shared, structured, and readable by everyone at once. That surface has a name we’ve used for decades. It’s a board.
How does a shared board stop context rot from breaking teamwork?
By moving the source of truth out of every agent’s rotting window and into one place none of them can quietly corrupt. On a shared board, “what’s done, what’s claimed, what’s next” isn’t a fact each agent has to remember — it’s a state each agent can re-read. When a model’s context degrades mid-run, it doesn’t have to reconstruct the project from a decaying window; it pulls the current state off the board and re-grounds on something external and correct. The board turns context rot from a silent failure into a recoverable one.
That is the shape of Lova. Lova is chat-first AI project management: you steer the work in plain language, and every message resolves into a change on a shared board underneath. An agent claims a bounded task, does the work, and moves the card through states where the result can be verified — and because the board, not the model’s memory, is where the task lives, a rotted context can’t erase what an agent already finished or trick it into redoing it. The board does for a team what a NOTES file does for a lone agent, then adds the thing a private file never had: every other teammate reading the same truth. Structure the work as durable, external, shared state, and the model’s attention budget stops being the ceiling on how much a team of agents can reliably get done.
Why does this matter in Q3 2026?
Because the two curves are diverging in exactly the wrong direction. Agent run-times are climbing fast — multi-hour, sometimes multi-day — while the research on context rot says the reliable fraction of those runs isn’t climbing with them. Enterprises are feeling the mismatch in the aggregate: the average company already runs 12 AI agents, and half operate in isolation, each one accumulating and rotting its own private context with nothing shared to fall back on. That number is expected to reach 20 within two years. More agents running longer, each forgetting privately, is a compounding coordination debt.
The teams that pull ahead this quarter won’t be the ones chasing the largest context window. They’ll be the ones who stopped asking the model to remember and started giving it a place to look. Context rot is a hard fact about how these models work — you can’t prompt your way out of it. But you can build around it, by keeping the truth about the work where no context can rot it: on a shared board every teammate, human and agent, can read.
Frequently asked questions
What is context rot in AI agents?
Context rot is the measurable decline in a language model’s accuracy as its context window fills with more text. A controlled study of 18 leading models found reliability drops as input length grows — even on simple tasks like retrieving a fact or copying text, and before the model’s advertised limit. For agents, whose entire run accumulates in the window, it means the longer they work, the less trustworthy their later steps become.
Does a larger context window fix context rot?
No. Because the degradation scales with input length, a bigger window is more room to rot, not a cure. The pattern recommended by the labs building these models is to keep the window lean and store durable state outside it — in structured notes the agent writes down and reloads — so long-horizon work doesn’t depend on holding the whole history in working memory.
What is Lova?
Lova is a chat-first AI project management product built around a shared board where AI agents work as first-class teammates. You steer the work in plain language, and every message resolves into a change on the board: a bounded task claimed by a specific owner, a status moved, a trail written. Because the task lives on the board rather than in any model’s memory, an agent whose context has degraded can re-read the current state instead of guessing.
How does a shared board help with context rot?
It moves the source of truth out of every agent’s volatile context window and into one shared, structured state. When a model’s memory degrades mid-run, it re-reads the board to recover what’s done, claimed, and next — rather than reconstructing the project from a rotted window. A private notes file does this for one agent; a board does it for an entire team of agents and humans at once.
Why is context rot a bigger problem in 2026?
Because agents now run far longer than they used to — frontier models can work unattended for 30-plus hours, and task horizons are doubling roughly every seven months. The longer a run, the more context accumulates and the more it rots, so capability and reliability are pulling apart exactly as enterprises scale to a dozen or more agents each.