A planner in agent architecture is the component that decomposes a high-level goal into an ordered sequence of steps before execution. Where a reactive agent decides each next action one at a time, a planner sketches the whole approach upfront. The planner can be the same LLM that executes (a "self-planning" agent), a separate dedicated planning model, or even hand-coded logic.
Why planning matters:
- Coordination across many steps — without a plan, agents wander or repeat themselves.
- Cost control — a plan lets you estimate API budget and stop runaway loops.
- Human review — a plan can be shown to a user for approval before execution.
- Parallelism — independent steps in the plan can run simultaneously.
- Recovery — when a step fails, the plan provides context for what to try next.
The patterns that have stabilised in 2026:
- Plan-and-execute — the agent writes a plan once, then executes each step. Re-plans only on major failure. Best for predictable workflows.
- Adaptive planning — the plan exists as a living document that the agent updates after each step based on what was learned. More expensive but more resilient.
- Hierarchical planning — top-level plan decomposes into sub-plans; sub-agents execute each. Good for complex projects.
- Explicit DAGs — for workflows where dependencies are known in advance, the "plan" is a directed acyclic graph executed by a workflow engine (Temporal, Inngest, Trigger.dev), with the LLM filling in the leaves.
Common planning failures:
- Over-planning — generating a 30-step plan for a 3-step problem; wastes tokens and time.
- Under-planning — jumping straight to action and discovering halfway through that the approach was wrong.
- Plan rigidity — sticking to the original plan even when reality has changed; lack of replanning.
- Hallucinated dependencies — the planner assumes data or tools exist that do not.
The frameworks that handle planning explicitly:
- LangGraph — explicit state graph; the "plan" is the graph topology.
- CrewAI — hierarchical mode where a manager agent plans and delegates to workers.
- OpenAI Assistants API — implicit planning via the LLM's reasoning loop.
- Anthropic Agents SDK — first-class support for plan-and-execute patterns.
- Inngest / Temporal / Trigger.dev — durable workflow engines where planning is hand-coded and the LLM fills in semantics.
For a US team in 2026, the practical advice is: do not build a planner unless single-step LLM calls have demonstrably failed. Most "agents" you see in production are simpler than they look — a single LLM call with tool use that happens to take a few iterations. Explicit planning is appropriate for genuinely multi-step workflows with dependencies, parallelism opportunities or human-approval checkpoints.
