Planning › Limitations and Impact

Planning is one of the most actively researched areas in LLM agents, and current systems have significant limitations alongside demonstrated capabilities. Understanding both is essential for setting appropriate expectations and designing systems that work reliably in practice.

The most fundamental limitation is hallucinated planning. When a language model generates a plan, it draws on statistical associations in its training data. It does not simulate the execution of the plan or verify that each step's preconditions will be satisfied when that step is reached. Plans can appear coherent while containing logical errors: step four assumes that step two produces a certain output, but the actual execution of step two never produces that output because the assumption was wrong. Humans reviewing plans detect these errors through domain knowledge; the model often does not. The result is plans that look correct at first glance but fail at specific transition points between steps.

Long-horizon degradation is a practical challenge that limits the applicability of current planning systems to medium-length tasks. Plans longer than eight to ten steps degrade rapidly in quality. The model struggles to maintain a coherent representation of all dependencies, intermediate states, and global constraints over many steps. For truly long-horizon tasks, such as planning a multi-week software project or coordinating a multi-agent pipeline with dozens of steps, current models must be scaffolded with external state tracking and regular re-grounding prompts to avoid drift. Re-grounding means periodically summarizing the current state of the plan and re-stating the original goal to prevent the model from losing context of what it was trying to achieve.

Over-planning and under-planning are complementary failure modes that are hard to address with simple prompt engineering. Some models generate overly detailed plans with too many small steps, creating coordination overhead without benefit. Others generate under-specified plans where steps are so vague that the executor cannot act on them. Calibrating plan granularity to the task is itself a skill that current models handle inconsistently, and the right granularity varies substantially across domains and tool sets.

Replanning cost is non-trivial and can accumulate rapidly in adversarial or unpredictable environments. Each replanning call requires sending substantial context to the model: the original goal, all completed steps and their outputs, the failure description, and possibly the reflection summary from prior attempts. This can easily consume tens of thousands of tokens per replanning event, which is expensive in both latency and API cost. Systems that replan frequently are significantly more expensive than those that plan once and execute cleanly. This creates a tension between resilience (many replanning opportunities) and cost (each replanning event is expensive).

Evaluation is difficult. Measuring whether a planning agent improved task performance requires comparing against well-designed baselines on tasks where the "right" plan structure is known. Many published benchmarks evaluate only final task success rate, which does not distinguish between good planning and lucky reactive execution. A system that generates random plans and occasionally succeeds looks competitive with a careful planner if success rate is the only metric. Richer evaluation metrics that measure plan efficiency, recovery rate, and step accuracy are still being developed.

Despite these limitations, planning-capable agents have demonstrated substantial improvements over step-by-step reasoning on multi-step tasks. On benchmarks like HotpotQA (multi-hop question answering), FEVER (fact verification), and WebArena (web navigation tasks), plan-based agents consistently outperform reactive agents on tasks requiring more than three steps. The improvement grows with task length: the longer the task, the larger the gap between agents that plan and agents that react.

The practical impact is most visible in software engineering agents. Systems like Devin, SWE-agent, and Claude Code use planning to decompose code changes into file modifications, test runs, and error fixes. These agents can complete software engineering tasks that require understanding multiple files, identifying the root cause of a bug, implementing a fix, and verifying it, all as a coherent planned sequence rather than a series of isolated actions. The planning capability is what allows these systems to maintain coherence across the many steps required to resolve a non-trivial bug in a real codebase.

Planning also enables a qualitatively new kind of delegation. When an agent can reason about multi-step goals, users can specify objectives at a higher level of abstraction, closer to "write a report on X" than "first search for X, then summarize the first result". This changes the user-agent interaction from supervised step-by-step guidance to goal delegation, with the agent handling the operational details autonomously. The cognitive load on the user decreases, and the tasks that can be delegated become substantially more complex.

The research trajectory for planning is toward more reliable upfront plan generation (better planning prompts, more capable models), more efficient recovery (local repair without full replanning), and longer-horizon execution (better state tracking and context management for plans with many steps). Each of these improvements makes planning agents applicable to more demanding tasks. The field is advancing rapidly, and systems that struggle with ten-step plans today will likely handle twenty-step plans within a few years.

The connection to upcoming topics in this book is direct. Multi-agent systems build on planning by distributing subtasks across specialized agents: a planner decomposes the goal and assigns subtasks, specialist agents execute the assigned subtasks, and a synthesizer aggregates results. Planning is what makes this orchestration coherent rather than chaotic. Without a plan, a collection of specialist agents has no shared understanding of what the overall goal is or how their individual contributions fit together. With a plan, each agent receives a clearly specified subtask with well-defined inputs and outputs, and the orchestrator can monitor progress and trigger recovery at the right level of granularity.