Self-Directed Planning for Autonomous Agents

You are an autonomous agent. Your goal is: {goal}.
Look at the current state and decide the single best next action.
Then take it. Repeat until the goal is met.

Here's a result that surprised us: in a batch of side-by-side runs, a mid-tier model handed a solid plan finished more tasks correctly than a top-tier model told to "figure it out as you go." The plan mattered more than the model. That's counterintuitive if you think intelligence is the bottleneck - and it points straight at the most underused lever in agent design.

Autonomous agent planning is the step where an agent decides its overall approach before it starts acting, rather than improvising one action at a time. Most agents skip it. They have an implicit plan - "pick the next action each turn" - but no explicit, inspectable strategy. This teardown takes a weak planning prompt, shows exactly why it fails, and rebuilds it into one that makes an agent noticeably more reliable without touching the model.

Before: the weak planning prompt

Here's how most agents "plan" - which is to say, they don't:

You are an autonomous agent. Your goal is: {goal}. Look at the current state and decide the single best next action. Then take it. Repeat until the goal is met.

What this does: it asks the model to choose one action per turn based only on the current state, with no requirement to think about the overall approach first - planning collapses into a sequence of local decisions.

This looks reasonable and runs fine on easy tasks. On anything with more than a few steps, it quietly falls apart, and the reason is worth understanding because it's not obvious from reading the prompt.

Why it fails

It fails because per-step decisions are locally sensible and globally incoherent. Each turn the agent picks a reasonable next action given what's in front of it - but with no overall plan, nothing keeps those local choices pointed at the same destination. The agent wanders. It does useful-looking things that don't add up.

The concrete symptom is thrashing: the agent explores option A, abandons it for option B, circles back to A, and never commits long enough to finish anything. Without a plan to deviate from, every turn is a fresh decision with no memory of the intended path. There's no cost to changing direction, so the agent changes direction constantly.

The second failure is invisible dead ends. A per-step agent can't tell that its whole approach is doomed, because it never articulated an approach. It just keeps taking locally-reasonable steps down a path that leads nowhere. A plan would have made the doomed strategy visible at step zero, when it's cheap to fix.

⚠️ Common mistake: Assuming a smarter model removes the need for planning. It doesn't - a smarter model just improvises smarter-looking local actions that still don't cohere. Planning is a structural fix, not an intelligence problem, which is exactly why a weaker model with a plan can win.

After: the improved planning prompt

Here's the rebuild - a self-directed planning prompt that forces an explicit, multi-horizon plan and treats it as a commitment:

You are an autonomous agent. Goal: {goal}. STEP 1 - PLAN. Before acting, write a plan with two horizons: - STRATEGY: the 3-6 high-level phases to reach the goal (stable). - NEXT ACTIONS: the concrete steps for the current phase only. STEP 2 - COMMIT. Execute NEXT ACTIONS in order. STEP 3 - DEVIATE ONLY WITH CAUSE. You may change the plan, but you must first state which observation invalidated it and what you're changing. No silent direction changes. STEP 4 - REPLAN the NEXT ACTIONS when a phase completes; keep STRATEGY unless an observation forces a rethink.

What this does: it makes the agent commit to a stable high-level strategy and a volatile short-term action list, and it requires an explicit justification before any deviation - turning planning from an implicit per-step habit into an inspectable contract the agent must argue against to break.

The behavior change is immediate. The agent stops thrashing because deviation now has a cost - it has to justify it. And doomed strategies surface at planning time, before a single expensive action runs.

⚡ Pro tip: Split the plan into a stable strategy and a volatile action list. Re-planning the whole thing every turn is as bad as never planning - you want the high-level plan to hold steady while only the near-term steps churn.

Breaking down each element

The two horizons are the core insight. A single flat plan is either too rigid (you can't adapt) or too fluid (you re-plan constantly). Splitting it fixes both: strategy gives coherence across the whole run, near-term actions give adaptability where reality is uncertain. You re-plan the cheap, volatile layer often and the expensive, stable layer rarely.

The commit step matters more than it looks. Without an instruction to execute the planned actions in order, models drift back into per-step improvisation even when they've written a plan - they'll write a lovely plan and then ignore it. "Execute NEXT ACTIONS in order" closes that gap.

The deviate-with-cause clause is the guardrail. It doesn't forbid changing the plan - rigidity is its own failure - it forces the change to be reasoned and logged. The agent must name the observation that broke the plan. This does two things: it stops frivolous direction changes, and it leaves a trail you can read when a run goes wrong. The plan becomes a contract, and deviations become auditable events.

The selective replan in step 4 keeps strategy stable while phases complete. Finishing a phase is a normal event, not a crisis - it triggers planning the next phase's actions, not rethinking the entire strategy.

One nuance people miss: the strategy horizon should be phrased in outcomes, not actions. "Reconcile all accounts" is a stable outcome; "run the reconcile script" is an action that might change. Outcome-phrased strategy survives tactical surprises because the destination holds even when the route changes. Action-phrased strategy breaks the moment the chosen action turns out wrong, forcing a full rethink over what should have been a minor detour.

⚡ Pro tip: Log every plan deviation with its stated cause. When an agent fails, the deviation log tells you the exact observation that sent it off course - usually a misread result the agent treated as a reason to abandon a working plan.

How much should an agent spend on planning?

Planning feels like overhead - tokens spent thinking instead of doing - so teams under-invest in it. That instinct is backwards. Planning is the cheapest place in the entire agent loop to spend compute, because one good planning call prevents many wasted action steps, and action steps are where the real cost and risk live.

Run the math on the report agent from a planning lens. A thorough plan might cost one extra model call up front. A missing plan cost it hundreds of aimless iterations. The ratio isn't close. For any task with more than a handful of steps, the expected savings from planning dwarf its cost - which means autonomous agent planning should get more token budget on harder tasks, not less.

A useful rule: scale planning investment to the reversibility and length of the task. A quick, reversible task barely needs a plan - improvising is fine when mistakes are cheap and short. A long, expensive, or irreversible task deserves a detailed plan reviewed before execution, because that's where a missing plan costs the most.

⚡ Pro tip: On expensive or irreversible tasks, generate the full plan and stop - inspect it before any action runs. A plan is cheap to read and cheap to fix; the actions it prevents are neither.

There's a second, less obvious payoff. A written plan is an audit artifact. When an agent that planned explicitly fails, you can compare the plan to what it actually did and see precisely where it diverged. An agent that improvised leaves no such trail - there's nothing to compare against, so debugging is guesswork. This is also the natural place to inject constraints: because the plan is explicit and inspected, you can require it to include safety steps - "verify before deleting," "check the count before writing" - and reject plans that skip them. A plan you can validate is a plan you can constrain.

⚡ Pro tip: Treat the plan as a contract you can validate against. Require certain steps to appear, reject plans missing them, and diff the plan against the actual run when debugging. The explicit plan turns a black-box agent into one you can inspect.

Variations for different contexts

A financial operations analyst running a reconciliation agent wants strategy locked hard - the phases (load, match, flag exceptions, report) never change - and only the exception-handling actions fluid. Rigid strategy, flexible tactics.

A UX researcher running an agent to synthesize interview transcripts wants the opposite balance: a loose strategy because the themes emerge as it reads, and frequent re-planning as new patterns appear. Here the volatile layer does most of the work, and forcing a rigid upfront strategy would blind the agent to what the data actually says.

A site reliability engineer automating incident triage wants strategy that can be interrupted - if the agent's investigation reveals an active outage, the whole plan should yield to a "mitigate now" strategy. So their planning prompt adds a priority-interrupt clause: certain observations don't just deviate the plan, they replace it.

Same planning skeleton, three tunings of the stable-versus-fluid balance. Good autonomous agent planning isn't one template - it's matching how much you lock down to how predictable the task is.

Save and reuse this

The multi-horizon planning prompt above is the kind of asset worth versioning, because the exact wording of the deviate-with-cause clause and the strategy/actions split took iteration to land - and once it works, it drops into any agent you build. Keeping your planning prompts in PromptABCD means every new agent starts with a plan-first design that already beats "figure it out as you go," instead of you rediscovering, run after run, that the plan mattered more than the model. Get the planning prompt right once; reuse the reliability everywhere.