Agent Planning Explained: How AI Breaks Big Goals into Small Steps
Planning is what turns a goal into a sequence of actions an AI agent can execute. How agents plan, the plan-as-you-go vs plan-then-execute approaches, why plans fail, and what good planning looks like in practice.
Give a capable person a goal ("sort out the venue for the Christmas party") and something quietly impressive happens before any action: they decompose it. Budget first, then dates, then shortlist, then calls, then booking, with a mental note that if the first-choice venue is gone, the plan changes. Nobody taught them this explicitly. It is just what competence looks like.
Planning is exactly this ability in AI agents, and it is the component that most separates "agentic" from "responsive." A chatbot answers the message in front of it. An agent looks at a goal, works out the steps, sequences them, and revises when reality disagrees, which reality reliably does. This article covers how that actually works: the two planning styles that dominate real deployments, what plans look like under the bonnet, the characteristic ways planning fails, and what buyers should look for.
(Series context: planning is the brain's first job in the [agent anatomy]; the concept overview is What Is Agentic AI?
What Is Planning, in Agent Terms?
Planning is the translation of an outcome into an executable sequence: goal in, ordered steps out, with dependencies noted ("cannot email the quote before calculating it") and revision expected ("supplier B has no stock; reroute through supplier C").
The analogy that carries the article: a satnav. You give it a destination, not directions. It computes a route (planning), starts navigating (execution), and, crucially, recalculates when you miss a turn or traffic appears (replanning). Nobody wants a satnav that prints one route and goes silent at the first closed road; nobody should want an agent that plans once and marches on regardless. The recalculation IS the intelligence.
Under the bonnet, the reasoning engine produces plans as structured text: a numbered decomposition of the goal, generated by the same capability that lets language models reason through problems step by step. That simplicity is worth knowing: plans are legible. Ask a well-built agent what it intends before it acts, and it can show you, which has pleasant consequences for oversight that we will get to.
The Two Planning Styles That Ship
The field has produced dozens of planning schemes; two dominate production systems, and the trade-off between them is genuinely useful for buyers to understand.
Style 1: Plan-as-you-go (think, act, look, think again). The agent reasons one step at a time: consider the situation, take the single next action, observe the result, decide the next step in light of it. (The research name is ReAct, for reason-plus-act, and it is the default rhythm of most single agents.)
Its strength is adaptability: every step is chosen with fresh information, so surprises get absorbed naturally. Its weakness is short-sightedness: without a bigger picture, the agent can wander, take locally sensible steps that add up to a detour, or burn budget circling. Satnav equivalent: navigating junction by junction with no overview of the city.
Style 2: Plan-then-execute. The agent first drafts the whole route (steps one to eight, dependencies marked), then executes it, checking progress against the plan and replanning when a step fails or the world changes.
Its strength is coherence and inspectability: the full plan exists before actions start, which means it can be reviewed, by a checker agent or a human, before anything touches your systems. Its weakness is staleness risk: the world moves while the plan executes, so the replanning discipline is what keeps it honest. Satnav equivalent: the actual satnav, full route plus recalculation.
What production systems actually do: blend them. A route-level plan for coherence, step-level reasoning for adaptation, and explicit replan triggers ("if a step fails twice, if new information contradicts an assumption, if budget passes X, stop and replan"). In [multi-agent systems], planning also becomes a role: the orchestrator plans, specialists execute, which is the general-contractor pattern from that article.
Why Should a Business Care How Its Agent Plans?
Because plans are your inspection window. A legible plan is the cheapest oversight mechanism in all of agentic AI: "show me what you intend to do" before execution, on consequential tasks, catches wrong directions when they cost nothing. Approval gates on plans (not just on actions) are an underused pattern; the [Human Approval] article covers where they fit.
Because planning quality is cost control. Every step burns tokens and time. A wandering plan-as-you-go agent on a hard task can spend multiples of what a well-routed one spends, invisibly. When running costs surprise people (a theme of our [pricing guide]), meandering plans are a usual suspect.
Because failure modes follow planning style. "It went in circles" is plan-as-you-go without route discipline. "It executed a stale plan into a wall" is plan-then-execute without replan triggers. "It did steps in the wrong order" is missing dependency tracking. Knowing the styles turns baffling behaviour into a specific fix, exactly as anatomy literacy did in [the agent anatomy].
What Does Good Planning Look Like? A Worked Example
The task: "Chase our five most overdue invoices appropriately."
A poorly planned run: the agent looks up overdue invoices, emails all five customers the same firm reminder, marks the task done. Locally sensible steps, globally wrong: one customer is on an agreed payment plan, another is a VIP with a dispute open, a third paid yesterday.
A well-planned run: the plan drafts first: (1) fetch overdue invoices; (2) for each, gather context: payment history, open disputes, notes ([memory] doing its job); (3) classify each: standard chase, gentle chase, do-not-chase; (4) draft per classification; (5) queue drafts over $1,000 for human approval; (6) send, log, schedule follow-ups. Dependencies explicit (context before classification, classification before drafting), a gate where the money justifies it, and a replan trigger ("if a payment landed since the data pull, reclassify").
Same goal, same tools, same model. The difference is entirely the plan, which is the point: planning is where an agent's judgment becomes visible and correctable, before it becomes an email a customer reads.
How Planning Meets the Rest of the Anatomy
Planning never works alone; its quality is set as much by its neighbours as by itself, and knowing the couplings turns "improve the planning" from a wish into levers.
Planning and memory. A plan is only as good as what the planner knows: the agent that plans an invoice chase without retrieving the customer's payment-plan note ([memory]'s job) plans confidently into a mistake. The lever: make context-gathering an explicit early step in every plan template, so the notepad is stocked before the route is drawn. Most "bad plans" we diagnose are actually good plans over missing facts.
Planning and tools. Plans can only route through the toolbox that exists: an agent without a "check stock" tool will plan around stock, badly. The lever: when plans keep contorting, the fix is often a missing tool, not better prompting; the plan is telling you what hands it needs ([tool calling] covers the stocking decisions).
Planning and reflection. The draft plan is itself an output worth checking: a plan-review pass ("does this sequence achieve the goal? what assumption could break it?") catches wrong directions at the cheapest possible moment, before any step executes. This is reflection applied upstream, and it is the highest-leverage place to put it.
Planning and the gates. Consequential plans deserve human eyes before execution, not just consequential actions after planning: "here is what I intend, approve?" costs one glance and converts oversight from damage control to direction-setting. The [human approval] article maps where these plan-level gates belong.
The compact version: stock the notepad before planning, let contorted plans reveal missing tools, review routes before driving them, and show humans the itinerary rather than the accident report. Four couplings, four levers, most of planning quality.
What Are the Limitations?
Plans are plausible, not proven. The reasoning engine drafts plans the way it drafts everything: convincingly, and occasionally wrong. A confident plan can embed a false assumption ("the customer file will contain X") that unravels at step four. This is why plans get checked, by reflection, by checker agents, or by humans at the gates, rather than trusted on fluency.
Long horizons still strain. The further a plan reaches, the more the world changes under it and the more errors compound across steps. Practical builds keep plans short and replan often rather than pretending to foresight: many small routes beat one grand itinerary. Tasks needing genuinely long coherent campaigns remain the frontier, and vendors claiming otherwise are selling the demo.
Over-planning is real. Ten minutes of elaborate decomposition for a task that needed two steps: token cost, latency, no benefit. Good builds match planning depth to task complexity, the way people do: nobody writes a project plan for making tea.
Dependencies are easy to state and easy to fumble. "Do B after A" is trivial until A half-succeeds, returns partial data, or succeeds with a caveat. The difference between demo agents and production agents is disproportionately in this unglamorous middle: handling the partial, the ambiguous and the almost.
The Buyer's Planning Questions
Four questions for any agent vendor or builder:
- Show me a plan. Before execution, on a real task: can the agent articulate what it intends? Legible plans mean inspectable behaviour.
- What triggers a replan? Specific answers (failure counts, contradiction detection, budget thresholds) mean the recalculation was designed; "it adapts" means it was not.
- What stops it wandering? Step budgets, loop detection, cost caps per task: the disciplines that keep plan-as-you-go from circling.
- Where can a human see or approve the plan on consequential tasks? Plan-level gates are cheap and catch wrong directions before wrong actions.
Frequently Asked Questions
-
The reasoning engine decomposes a goal into ordered steps with dependencies, either one step at a time with observation between (plan-as-you-go, the ReAct pattern) or by drafting a full route first and revising during execution (plan-then-execute). Production systems typically blend both with explicit replan triggers.
-
Reason-plus-act: the loop where an agent thinks about the situation, takes one action, observes the result, and thinks again. Adaptable and simple, at the cost of short-sightedness on complex tasks, which is why bigger jobs add route-level planning on top.
-
Step-by-step planning without route discipline: each step looks locally sensible while the path circles. Fixes are standard: an upfront plan for direction, loop detection, step and cost budgets, and replan triggers that force a rethink instead of a repeat.
-
With a well-built agent, yes: plans are generated as legible text and can be surfaced for review or approval before execution. Plan-level visibility is one of the cheapest and most underused oversight mechanisms in agentic AI; ask any vendor to demonstrate it.
-
Partly the reverse: better planning usually costs LESS to run, because wandering burns tokens. Where planning adds cost is deliberate depth on complex tasks (drafting and revising routes), which pays for itself in fewer dead ends. Meandering, not planning, is the budget leak.
-
It becomes a dedicated role: an orchestrator agent plans and delegates, specialist agents execute their pieces, and results flow back for replanning, the general-contractor pattern covered in [Multi-Agent Systems Explained]. The same principles apply: legible plans, explicit dependencies, designed replan triggers.
-
Meaningfully: stronger models decompose better, track dependencies more reliably, and recover from surprises more gracefully, which is why serious builds route planning to premium tiers even when execution steps run on cheaper ones. But architecture beats raw capability at the margin: a mid-tier model with route discipline, replan triggers and step budgets outperforms a premium model left to wander. When a vendor credits everything to "the latest model," ask about the discipline instead; models rotate quarterly, planning architecture is what you actually own.
-
Yes, and good builds do exactly this: a drafted plan implies a step count, a model mix and therefore a token estimate, which can be checked against a per-task budget before execution begins. Tasks that plan out over budget get flagged rather than run, which converts cost control from monthly bill archaeology into a pre-flight check. It is another quiet payoff of legible plans, alongside the oversight: what can be read can be priced.
The Takeaway
Planning is competence made visible: the translation of "sort this out" into steps, order and contingency. Agents do it the way satnavs navigate: a route, constant recalculation, and no pride about missed turns.
For buyers, the practical gold is legibility: an agent that can show its route before driving it hands you oversight for free. Ask to see a plan, ask what triggers a rethink, and ask what stops the wandering. Then let the [reflection] article show you the other half of the discipline: how agents check the work the plan produced.
Bots and Brand Works builds single agents that earn their teams: maker-checker pairs, orchestrated specialists, full traces, honest per-outcome costs. If a multi-agent pitch has you wondering whether it is architecture or theatre, send it over and we will read the org chart for you.
Need Help Implementing AI Solutions?
Resources and Further Reading
- Pillar article: Agentic AI vs Workflow Automation: The 2026 Enterprise Guide
- Related: [Multi-Agent Systems Explained]
- Related: Reflection Explained
- Also in this series: What Is an AI Agent? · Agent Memory · Tool Calling · [Human Approval]
- ReAct paper (Yao et al.): Click Here
- Anthropic: Building effective agents: Click Here
- LangGraph (plan-and-execute patterns): Click Here