Why Agents Can't Handle Long Tasks
Trying to do too much at once, or quitting after one round — two classic failure modes
THE QUESTION THIS PAGE ANSWERS
ANSWER FIRSTWhy Agents Can't Handle Long Tasks?
Trying to do too much at once, or quitting after one round — two classic failure modes
Make the claim earn its place. Use this page as a decision aid, not a definition to memorize. Connect the idea to one real task, one observable result, and one failure that would change your mind.
Write one question you could answer with evidence after trying this idea.
A conclusion that sounds complete but leaves the key assumption untested.
This is no small task. A full chat app requires an authentication system, conversation management, streaming output, file uploads, Markdown rendering, multi-turn history… easily 200+ independent features. What goes wrong when you ask an Agent to build something like this from scratch?
The Agent tries to complete all features in a single session, resulting in:
- The context window gets exhausted halfway through implementation
- The next Agent inherits half-finished code and can only guess what the previous one did
- Vast amounts of time are wasted just getting basic functionality working again, leaving no time for new features
- Even Compaction (context compression) isn't enough — compressed instructions are too vague and the new Agent still gets lost
The Agent sees that some features are implemented and assumes the project is basically complete:
- Declares the project complete when in reality only 30% of core features are done
- No task checklist means the Agent doesn't know what's still missing
- No verification mechanism — thinks it's done but no end-to-end tests to prove it
Why “Problem Background” depends on the operation
“This is no small task.” makes the structure concrete. The useful comparison is not which name sounds more advanced, but how the data is arranged and how far the most common operation has to travel.
Read a structure through access and change
“The Agent tries to complete all features in a single session, resulting in” exposes a trade-off that is easy to miss: reading by position, looking up by key, adding at either end, inserting in the middle, and traversing relationships do not favor the same organization. A structure that is fast for one operation is not automatically fast for all of them.
- The context window gets exhausted halfway through implementation
- The next Agent inherits half-finished code and can only guess what the previous one did
- Vast amounts of time are wasted just getting basic functionality working again , leaving no time for new features
Count scale and update frequency together
Use “The Agent sees that some features are implemented and assumes the project is basically complete” as a boundary check. Write down the data size, the dominant operation, and the latency you can accept before deciding whether an AI-generated structure actually fits.
From “Problem Background” to “Failure Modes”
“Problem Background” grounds the problem in “This is no small task. A full chat app requires an authentication system, conversation management, streaming output, file uploads, Markdown rendering, multi-turn history… easily 200+ independent features. What…”. “Failure Modes” then moves it toward “The Agent tries to complete all features in a single session, resulting in”. Together, they show that the lesson is not just a conclusion to remember, but a claim with conditions.
Carry the judgment into the next situation
When you meet a new data structure, do not begin by memorizing its definition. Write down the most frequent operation, estimate scale and update behavior, and check whether the structure satisfies all three conditions.
- “Problem Background”: This is no small task. A full chat app requires an authentication system, conversation management, streaming output, file uploads, Markdown rendering, multi-turn history… easily 200+ independent features. What…
- “Failure Modes”: The Agent tries to complete all features in a single session, resulting in
- “The closing point”: Declares the project complete when in reality only 30% of core features are done
The final “The closing point” brings the discussion to “Declares the project complete when in reality only 30% of core features are done”. The useful thing to carry forward is knowing which judgments must be revisited when input, scale, or risk changes.
I turned one judgment from this article into a small experiment I could run today. Knowing what to observe next is more useful than simply remembering the conclusion.
After reading this, I first looked for the conditions behind the idea instead of copying the method into a project. That order made the later trade-offs much clearer.
When this judgment reaches real work, which constraint should be added first? I am curious which step matters most between reading and the first practical attempt.
No discussion on this article yet.