Agents

Plan-and-Execute

2023ActivePublished: 6 June 2026Updated: 6 June 2026Published

Key innovation

Separates planning from execution: a strong LLM produces a multi-step plan up front, while a cheaper executor (typically a ReAct loop) carries out individual steps, with optional re-planning between steps.

How it works

1. The planner receives the goal and any context, then generates an ordered list of steps (the plan), typically in structured form (JSON / list). 2. The executor picks the first unfinished step and carries it out — usually as a ReAct loop (thought → action → observation) with tool access. 3. The step result is appended to the running state (scratchpad). 4. (Re-planning variant) The planner judges whether the plan is still valid in light of the new observation — if not, it generates a new plan for the remaining task. 5. The loop continues until the plan is exhausted or the planner emits a completion signal. The final answer is synthesized from the collected observations.

Problem solved

Purely reactive agent loops such as ReAct tend to lose track of the long-term goal, multiply redundant tool calls, and burn tokens of the strong LLM on every single reasoning step. Plan-and-Execute introduces global context (an explicit plan) and lets a cheap executor model handle routine steps while the expensive planner is invoked sparingly.

Components

PlannerProduces the global plan for solving the task.

A strong LLM that produces an ordered list of steps from the user goal. Typically runs once up front and optionally again during re-planning.

Official

ExecutorExecutes a single step and returns an observation.

An agent (usually a ReAct loop) that carries out one plan step with tool access. May run on a cheaper / smaller model than the planner.

Official

Re-plannerAdapts the plan to observations from the executor.

Optional component that evaluates the plan after each step and emits an updated list of remaining steps or a completion signal.

Official

Tool registryProvides action capabilities.

Set of tools (search, calculator, APIs, code) available to the executor; the planner may be aware of this set when constructing the plan.

Official

State / scratchpadShared loop context.

Working memory accumulating the goal, plan, completed steps, and their observations; shared between planner and executor.

Implementation

Reference implementations

LangChain — Plan-and-Execute Agents

Python · LangChain

Official

LangGraph — plan-and-execute tutorial

Python · LangChain

Official

BabyAGI

Python · Yohei Nakajima

Implementation pitfalls

Plan disconnected from tool capabilitiesHigh

The planner generates steps the executor cannot perform (missing tool, wrong signature). Causes error loops and wasted tokens.

Fix:Pass the tool list with descriptions (tool schemas) to the planner and enforce structured output validated against that list.

No re-planning on state changeHigh

Rigid plan execution after contradictory observations leads to nonsensical final steps.

Fix:Enable re-planning (after every step or on failure); use a LangGraph state machine instead of a plain loop.

Planner cost explosionMedium

Re-planning after every step on a strong model dramatically increases cost — sometimes exceeding plain ReAct on a single model.

Fix:Re-plan only conditionally (step failure, scope change); cache the plan; consider ReWOO for offline tasks.

Too granular or too coarse stepsMedium

Very granular steps yield plans with hundreds of items (state explosion); very coarse steps yield steps the executor cannot perform atomically.

Fix:Enforce in the planner prompt the rule "one step = one tool call or one sub-answer".

Evolution

Original paper · 2023 · ACL 2023 · Lei Wang

Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models

Lei Wang, Wanyu Xu, Yihuai Lan, Zhiqiang Hu, Yunshi Lan, Roy Ka-Wei Lee, Ee-Peng Lim

2022

ReAct (Reasoning + Acting)

Yao et al. propose interleaving reasoning and actions — the direct conceptual predecessor in which planning and execution are fused into a single loop.

ReAct (concept)ReAct: Synergizing Reasoning and Acting in Language Models (paper)

2023

BabyAGI

Inflection point

Yohei Nakajima releases a minimal agent with a separate task-creator and task-executor — the first popular open-source implementation of Plan-and-Execute.

BabyAGI repository (paper)

2023

Plan-and-Solve Prompting

Inflection point

Wang et al. formalize the split into planning and execution phases for zero-shot CoT, showing gains over "Let’s think step by step".

Plan-and-Solve Prompting (paper)

2023

LangChain Plan-and-Execute Agents

Inflection point

Harrison Chase introduces a reference implementation of the pattern in LangChain — LLM planner + ReAct executor + optional re-planner.

Plan-and-Execute Agents (LangChain blog) (paper)

2023

ReWOO (Reasoning WithOut Observation)

Xu et al. propose a variant where the planner generates the full plan as variables and tool execution and synthesis are separated — drastically reducing token usage.

ReWOO: Decoupling Reasoning from Observations for Efficient Augmented Language Models (paper)

2023

LLMCompiler

Kim et al. extend Plan-and-Execute with a dependency graph between steps and parallel execution of independent tool calls.

An LLM Compiler for Parallel Function Calling (paper)

Hyperparameters (configurable axes)

Planner modelCritical

Model used to generate the plan. Usually a strong reasoning model (e.g. GPT-4 / Claude Opus / o1).

Executor modelHigh

Model executing single steps. Often cheaper / faster than the planner.

Re-plan strategyHigh

When to trigger re-planning: never / after every step / only on failure / on scope change.

Max stepsMedium

Hard cap on plan steps / executor iterations; safeguard against loops.

Tool setCritical

Set of tools exposed to the executor; constrains what the planner can plan at all.

Execution paradigm

Primary mode

Conditional

Two distinct stages (planning, execution) with different compute profiles — often run on different models.

Activation pattern

Stage dependent

Routing mechanism

The planner drives the flow by selecting subsequent steps and routing them to executor tools; in the re-planning variant it can reroute after an observation.

Parallelism

Parallelism level

Sequential

Plan steps are usually executed sequentially (step n+1 depends on the observation from step n). Variants such as LLMCompiler detect independent steps and execute them in parallel.

Scope

Inference