85 agentic tools audited for security incidents · Talk to the lab →
MotionticBook a call
Glossary

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 compared with plan-and-execute
ReActPlan-and-execute
When planning happensBefore every stepOnce up front, then on failure
Model callsOne per stepOne for the plan, fewer during execution
Parallel stepsRare, one step at a timePossible where steps do not depend on each other
Adapts to surprisesImmediatelyOnly when replanning is triggered
FitsExploratory tasks with unknown stepsLong 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.

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.