Planner-Executor Loop

A planner-executor loop is an agent architecture that separates deciding what to do from doing it: a planning phase decomposes a goal into a sequence of steps, and a separate execution phase carries each step out, one at a time, often re-planning when a step fails.

The split exists because reasoning and acting have different requirements. Planning benefits from a model that reasons carefully about the whole problem before committing to an approach — usually worth paying for a stronger model, since it happens once. Execution is repetitive, narrowly scoped, and happens many times per task — usually a place to save money and latency with a faster, cheaper model, since each step just needs to follow the plan and report back.

How it works

The planner receives the goal and produces a structured plan: an ordered list of steps, each with a clear, checkable objective. The executor then works through the plan step by step — calling tools, reading results, and moving to the next step — without re-deriving the overall strategy each time. If a step fails or returns something the plan didn't anticipate, the executor either adapts locally or escalates back to the planner for a revised plan. This is different from a flat agent loop where one model reasons and acts every single step: here, the expensive reasoning is front-loaded and amortized across many cheap execution steps.

Why it matters

Cost and latency in agent systems scale with how many times you call an expensive model, not how many actions get taken. A loop that reasons from scratch at every step pays frontier-model prices for work a cheap model could execute once it has a plan to follow. The planner-executor split is one of the highest-leverage design decisions in production agents: it turns "every step is expensive" into "planning is expensive, execution is cheap," often without any loss in task completion, because execution steps rarely need the planner's full reasoning depth — they need to run the plan.

A worked example

A task needs 8 execution steps to complete. Run entirely on a frontier model that re-reasons every step (1,200 input and 400 output tokens each, at $5/$25 per million tokens) costs $0.128. Split the work instead: one planning call on the frontier model (3,000 input, 800 output tokens) costs $0.035, then 8 execution steps on a cheaper model (1,200 input, 150 output tokens each, at $1/$5 per million) cost $0.016 total. Planner-executor total: $0.051 — 2.5x cheaper than the all-frontier-model approach, a 60% cost reduction, for the same 8 steps completed.

How miatz teaches it

Learners build a planner-executor loop from parts in the agents track: first a flat loop that reasons and acts every step, then a version with the planning phase pulled out and pointed at a different model — and they run the cost math themselves, the way the example above was computed, rather than taking the savings on faith. War Room drills include agent incidents where a missing re-plan step let a failed execution step silently cascade, because knowing when to escalate back to the planner is as much the skill as building the split in the first place.