What is a plan-and-execute agent?
A plan-and-execute agent is an agent design in which a planner model first writes a multi-step plan for the whole task, an executor carries out the steps with tools, and the plan is revised only when results require it.
A ReAct agent decides one step at a time, calling the model again after every observation. A plan-and-execute agent separates the two jobs: one model call produces the plan, and the steps then run with fewer, cheaper calls, or none at all where a step is plain code.
The idea comes from a cluster of 2023 papers. Plan-and-Solve prompting (Wang and colleagues, May 2023, ACL 2023) asked a model to devise a plan that divides a task into subtasks before carrying them out, to cut missing-step errors in zero-shot reasoning. ReWOO and LLMCompiler then applied the same split to tool use.
What the research found
ReWOO (May 2023)
Xu and colleagues detached reasoning from tool observations so the planner did not need to see each result before planning the next call. On HotpotQA it reported 5 times better token efficiency and a 4% accuracy gain.
LLMCompiler (December 2023, ICML 2024)
Kim and colleagues added a planner, a task-fetching unit and an executor that runs independent calls in parallel. Against ReAct it reported up to 3.7 times faster, up to 6.7 times cheaper and up to about 9% more accurate.
Plan-and-Solve (May 2023)
Planning before solving consistently beat zero-shot chain-of-thought across ten reasoning datasets in the paper's GPT-3 experiments.
Plans in today's agents
Current agents tend to keep the plan as an artifact rather than a hidden first step. Anthropic's post on harnesses for long-running agents (November 2025) has an initializer agent write a feature list, with every item marked failing, that later coding sessions work through one by one. Spec-driven tools such as GitHub's Spec Kit turn a specification into a written plan and a task list before any code is generated.
A written plan has a second use: it gives a human something to review before the agent spends time and money, and it gives the agent a checklist to measure "done" against.
Where plan-and-execute goes wrong
Stale plans
The world changes mid-run, a tool returns something unexpected, and the executor carries on with steps that no longer make sense.
Planner errors travel
A wrong assumption in the plan is copied into every step. Without a check after key steps, nobody notices until the end.
Replanning loops
An agent that replans on every small surprise ends up as an expensive ReAct loop with extra steps.
Over-detailed plans
Plans that fix every argument in advance break on real data. Plans that name goals and checks hold up better.
How Motiontic's engineers apply it
Motiontic's engineers use an explicit plan when a task has many steps that can be named up front, such as a migration or a document-processing run. The plan is written to a file, each step has a check, and the agent replans only when a check fails, which keeps cost down without letting a bad plan run to the end unnoticed.
ReAct compared with plan-and-execute
| ReAct | Plan-and-execute | |
|---|---|---|
| When planning happens | Before every step | Once up front, then on failure |
| Model calls | One per step | One for the plan, fewer during execution |
| Parallel steps | Rare, one step at a time | Possible where steps do not depend on each other |
| Adapts to surprises | Immediately | Only when replanning is triggered |
| Fits | Exploratory tasks with unknown steps | Long tasks whose steps can be named in advance |
Common questions
What is the difference between plan-and-execute and ReAct?
ReAct reasons and acts one step at a time, reading each result before deciding the next step. Plan-and-execute writes a plan for the whole task first and only goes back to the planner when a step fails or the plan stops fitting.
Is plan-and-execute cheaper than ReAct?
Often. The papers behind it, ReWOO and LLMCompiler, reported large savings in tokens and cost against ReAct on their own benchmarks, because execution needs fewer full model calls.
When does a plan-and-execute agent fail?
When the plan is wrong or goes stale and nothing checks the results along the way. Checks after key steps and a rule to replan on failure guard against it.
Related
ReAct agent
Reason, act, observe, repeat: the pattern most agent loops descend from.
Agent loop
Model call, tool call, result, repeat: the cycle at the centre of every agent.
Spec-driven development
Write down what the software must do first, then let the coding agent plan and build against it.
Long-running agent
Agents that work for hours or days, and the state that lets them pick up where they stopped.
AI agent development
Agents that do real work for users, with the evals, traces and guardrails to keep them in production.
Sources
- Wang et al., Plan-and-Solve Prompting (arXiv 2023-05-06, ACL 2023)
- Xu et al., ReWOO: Decoupling Reasoning from Observations (arXiv 2023-05-23)
- Kim et al., An LLM Compiler for Parallel Function Calling (arXiv 2023-12-07, ICML 2024)
- Anthropic, Effective harnesses for long-running agents (2025-11-26)
- GitHub Blog, Spec-driven development with AI: Get started with a new open source toolkit (2025-09-02)
Running agents that have to hold up?
Describe the agent, the systems it touches and what it must never get wrong. The first call is with a lab engineer, who will say plainly whether it is ready for production, and whether Motiontic is the right team.