AI agents that work flawlessly for quick tasks often fall apart when asked to handle anything longer than roughly 35 minutes of continuous work. This isn't a minor glitch; it's a fundamental architectural problem that production teams are now designing around, reshaping how the entire field thinks about planning systems for autonomous AI.

What Causes the 35-Minute Degradation Problem?

The "35-minute degradation problem," as practitioners have come to call it, isn't caused by a single failure point. Instead, multiple issues compound together as an agent works through longer sequences of tasks. Understanding what goes wrong helps explain why this has become such a critical focus in 2026 agent development.

• Context Window Saturation: As an agent calls tools and receives results, those outputs accumulate in its working memory. Over time, the context window (the amount of information an AI model can hold at once) fills up with old tool outputs, leaving less room for the agent to reason about new problems.
• Compounding Errors: Small mistakes early in a task don't just disappear; they cascade. A minor error in step three can lead to incorrect assumptions in step ten, which then propagates further down the chain, making recovery increasingly difficult.
• Lack of Checkpointing: Without robust checkpointing (saving the agent's state at key moments), there's no clean way to recover from a mistake deep into a long session. An agent that could easily bounce back from a single error early on has no graceful recovery path after dozens of steps.

How Are Teams Actually Solving This?

The emerging solution isn't a single technical trick or a new algorithm. Instead, it's an architectural shift: breaking long jobs into smaller chunks that each fit comfortably within the window where agents are known to perform reliably, with explicit checkpointing between chunks rather than treating a multi-hour task as one continuous session. This approach acknowledges the limitation rather than trying to overcome it directly.

This strategy has practical implications for how teams design their agent systems. Instead of asking an agent to "research this topic and write a comprehensive report" as a single continuous task, teams now break it into discrete phases: research phase one, checkpoint and save, research phase two, checkpoint and save, and so on. Each phase stays within the reliable execution window, and if something goes wrong, the agent can restart from the last checkpoint rather than from the beginning.

How to Design AI Planning Systems That Handle Long Tasks

For teams building AI agents that need to work on complex, multi-hour projects, there are several practical approaches to consider when choosing a planning strategy:

• Decompose Tasks Upfront When Possible: If you know the task's structure in advance, use a Plan-and-Execute approach where the agent generates a complete plan before starting. This gives more predictable, cheaper execution than constantly re-planning after every step.
• Use ReAct for Exploratory Work: When subtasks only reveal themselves as the agent works (like research or debugging), the ReAct pattern (Reasoning plus Acting in a tight loop) lets the agent adjust course immediately based on what it observes, even though it costs more in reasoning cycles.
• Implement Explicit Checkpointing: Save the agent's state at logical breakpoints in the task, not just at the end. This transforms a long-running job from a single fragile session into a series of shorter, more reliable phases.
• Consider Hierarchical Planning for Complex Work: Break tasks into high-level skills first (like "search," "code," "write"), then refine each into concrete tool calls only when that skill is being executed. This keeps the overall plan coherent while allowing detailed execution underneath.

Why Does Planning Matter More Than Tool Access?

An AI agent with access to many tools but no coherent planning system is like a person with a full toolbox but no blueprint. The real challenge in 2026 isn't giving agents more capabilities; it's helping them decide what to do, in what order, and when to change course. Planning systems are the layer that transforms a language model with tool access into something that can actually complete multi-step work reliably.

The distinction between different planning approaches matters because each one trades off computational cost against flexibility. ReAct is cheaper per step but requires more total reasoning. Plan-and-Execute is more efficient for well-defined tasks but struggles when the path forward isn't knowable in advance. Tree of Thoughts (a search-based approach that explores multiple candidate paths) earns its extra computational cost only on problems where a single chain of reasoning is prone to getting stuck, like complex puzzles or open-ended creative planning.

What Does This Mean for the Future of AI Agents?

The 35-minute problem reveals something important about where AI agent development stands in 2026: the field has moved past the question of whether agents can handle individual tasks and is now grappling with how to make them reliable over longer, more complex jobs. This shift from single-step capability to sustained, multi-hour execution is reshaping how teams architect their systems from the ground up.

For enterprises and developers building production agents, the practical takeaway is clear: don't assume that an agent framework that works well on a 10-minute task will scale gracefully to an hour-long job. Instead, design with checkpointing and task decomposition in mind from the start, and test your agents explicitly on the time horizons you actually need them to handle.