Why agents fail on long tasks
Long agent runs degrade because every step appends to the context, diluting the original goal among accumulated tool output. Compaction, restating the objective, and decomposing into shorter sub-runs address this far more effectively than a larger context window.
There is a characteristic shape to agent failure. The first several steps are sharp. Somewhere past ten the agent starts re-reading files it already read. By twenty it is working on something adjacent to the task, with total confidence.
It looks like the model getting worse. It is the context getting worse.
The goal gets quieter with every step
At step one the objective is most of the context. At step twenty it is one paragraph among twenty tool results, and it has not been repeated since.
Given that everything the model does is conditioned on the whole sequence, the practical weight of the original instruction falls steadily. Nothing failed; the signal was simply diluted.
Restate, cheaply
Re-injecting a one-line objective every few steps costs almost nothing and measurably improves long runs. It is the least sophisticated fix on this list and often the most effective.
Mistakes are inherited
A wrong conclusion at step four does not stay at step four. It is now part of the history that every later step reads as established fact, and the agent will build on it consistently.
This is why agent errors compound rather than average out. Checking intermediate results — cheaply, in code, not by asking the model whether it is sure — stops the propagation early.
Compact the history
Most accumulated context is exhausted. The full text of a file read eight steps ago has served its purpose; what matters is the two lines that were relevant.
Periodically replacing older history with a summary of decisions and findings, while keeping recent steps verbatim, both reclaims budget and raises the proportion of the context that is actually load-bearing.
Prefer several short runs
The most reliable structural fix is not to have long runs. Break the work into stages with defined inputs and outputs, and run each as its own short agent with a fresh context.
You lose some flexibility and gain a great deal of predictability — each stage is independently testable, independently debuggable and cannot inherit confusion from a stage it never saw.
Frequently asked questions
Does a larger context window fix this?
It delays it. The problem is dilution and error inheritance, not capacity — a goal stated once in step one is competing with forty steps of tool output regardless of how much room there is.
What is compaction?
Replacing a long stretch of history with a summary of what was learned and decided, keeping only the recent steps verbatim. It preserves the conclusions while reclaiming most of the tokens.
