Plan-and-Execute versus ReAct

When you build an AI agent you have to decide how it controls its own work, and you almost always choose between two patterns: ReAct, which decides one step at a time by reasoning and acting in a loop, and plan-and-execute, which draws up a full plan first and then executes it step by step. There is no absolute winner: ReAct adapts better to surprises, while plan-and-execute uses fewer calls to the large model and brings more order to long tasks. In this guide you will see how each one works, when each pattern is the right choice, and which hybrid approaches combine the best of both. The same explanation is available in Spanish.

Key takeaways

• ReAct (reasoning and acting, from Yao and colleagues’ paper, arXiv 2210.03629^[1], ICLR 2023) interleaves thought, action and observation in a single loop: the model decides the next step only after seeing the result of the previous one.
• Plan-and-execute separates a planner, which lays out all the steps in advance, from an executor that carries them out one by one without consulting the large model at every action.
• Cost and latency are the big difference: plan-and-execute avoids a call to the planner model for every tool use; the LLMCompiler variant measures up to 3.7x lower latency, up to 6.7x lower cost and up to 9% higher accuracy versus ReAct.
• ReAct still wins on exploratory tasks where the path is not known in advance and you must adapt to each observation.
• Hybrid approaches (replanning after each block, ReWOO, LLMCompiler) are today’s most common practice: plan in advance and revise the plan when something fails.

The two agentic control patterns

Every agent solves a task by chaining calls to the model and to tools, but they differ in who decides the next step and when. That detail defines the control pattern, and in 2026 the practical debate comes down to two families.

The first is ReAct, short for reasoning and acting. It is the heart of the agentic loop and the ReAct pattern: the model generates a thought, chooses an action (calling a tool, for example), observes the result and starts over. Each iteration builds on what it has just learned, so the agent improvises the plan as it goes.

The second is plan-and-execute. Here the agent first stops to think about the whole task and produces an explicit plan with all the steps; an executor then carries them out in order. The idea connects with planning and task decomposition and with the Plan-and-Solve prompting paper (Wang and colleagues, arXiv 2305.04091^[2], ACL 2023), which showed that asking the model for a plan before solving "consistently outperforms zero-shot chain-of-thought across all datasets by a large margin".

How does plan-and-execute work?

The plan-and-execute pattern has three pieces: a planner, an executor and, almost always, a replanning step. The planner receives the goal and returns an ordered list of subtasks. The executor takes the first, resolves it (calling a tool or a smaller model) and stores the result; then it moves to the next. When the plan finishes, or when a step fails, the planner is called again to close the task or correct course.

The key difference from ReAct is how often the expensive model intervenes. In ReAct, the large model decides on every iteration; in plan-and-execute, the large model mainly intervenes when planning and replanning, while each step’s execution can fall to a lighter model. This pseudocode skeleton captures both loops:

# ReAct: one decision per step, always with the large model
state = goal
while not done:
    thought, action = large_model(state)     # 1 expensive call per step
    observation = execute(action)
    state = state + observation

  # Plan-and-execute: plan once, execute cheaply
plan = large_model(goal)                      # 1 expensive call: lays out N steps
for step in plan:
    result = light_model(step)                # cheap execution per step
    if failed(result):
        plan = large_model(goal, results)     # replan only if needed

The best-known variants refine this idea. ReWOO (reasoning without observation) makes the plan use variables like #E1 or #E2 to chain results without calling the model between steps. LLMCompiler goes further: it turns the plan into a task graph and executes tasks in parallel when they do not depend on one another.

Advantages: fewer calls, lower cost and better planning

The most tangible advantage is economic. Because the executor does not consult the large model at every action, plan-and-execute cuts the number of expensive calls and the accumulated latency. LangChain’s documentation puts it this way: these agents "do not need to call the large planner LLM for each tool invocation", and they let you reserve the powerful model for planning and use smaller models for execution.

The numbers back this up. The LLMCompiler paper (arXiv 2312.04511^[3]) measures, versus an equivalent ReAct agent, up to 3.7x lower latency, up to 6.7x lower cost and up to 9% higher accuracy, thanks to planning in advance and executing in parallel. The second advantage is plan quality: forcing the model to think through the whole task before starting reduces the risk of it getting lost midway, a typical failure of agents that only look one step ahead.

There is an important nuance. Anthropic warns in Building Effective Agents^[4] that "agentic systems often trade latency and cost for better task performance", and recommends starting with the simplest thing and adding complexity only when it genuinely helps. Plan-and-execute fits well when the task is long and its shape is predictable; for something short, setting up a separate planner is more machinery than you need.

When is ReAct still better?

ReAct shines precisely where plan-and-execute struggles: on open-ended tasks whose path is not known in advance. If the next step depends on what you discover in the previous one (searching the web, reading a file, querying an API and deciding based on the answer), a plan fixed at the start goes stale quickly. ReAct, deciding with the fresh observation in hand, adapts without friction.

It is also simpler to build and debug. A single reason-act-observe loop is easy to instrument and to understand when something goes wrong, whereas separating planner and executor adds pieces and points of failure. For many medium-sized agents, a well-built ReAct is enough, and that simplicity is exactly what Anthropic advises against giving up without reason.

Here is the quick comparison between the two patterns:

Hybrid approaches: replanning and parallel execution

In practice, almost no one picks one of the two in its pure form. The dominant pattern is plan-and-execute with replanning: the agent draws up a plan, executes a block of steps and then calls the planner again with the results to adjust what is left. This keeps the efficiency of planning in advance and recovers part of ReAct’s adaptability.

Modern frameworks offer both patterns as interchangeable pieces. The OpenAI Agents SDK, for example, lets you build a classic ReAct agent or chain a planner agent with executor agents through handoffs. The practical recommendation is to start with ReAct for its simplicity and migrate toward plan-and-execute (or a hybrid with replanning) only when you measure that tasks are long and repetitive enough that the saved calls outweigh the added complexity.

Frequently asked questions

Is plan-and-execute always cheaper than ReAct?

Not always, but it usually is on multi-step tasks. The saving comes from not calling the large model at every action and from being able to use a smaller model for execution; the LLMCompiler paper measures up to 6.7x lower cost versus ReAct. On one- or two-step tasks, however, setting up a separate planner adds an extra call for no benefit, so ReAct is just as efficient and simpler.

Can I combine the two patterns?

Yes, and it is the most advisable option. The usual hybrid is plan-and-execute with replanning: you plan in advance, execute a block of steps and replan with the results in hand. Variants like ReWOO and LLMCompiler take this idea further with reference variables and parallel execution, combining the order of planning with ReAct’s ability to react.

Which one should I use to start?

Start with ReAct. It is a single reason-act-observe loop, easy to build and debug, and it covers most medium-sized agents well. Migrate to plan-and-execute when you notice that your tasks are long, with predictable steps, and that the cost of repeated calls to the large model starts to add up. Anthropic advises exactly that: start simple and add complexity only when it genuinely helps.

Conclusion

ReAct and plan-and-execute are not rivals but two tools for different problems. ReAct decides step by step and adapts to surprises with a single simple loop; plan-and-execute plans in advance, spends fewer calls on the expensive model and brings more order to long tasks, at the cost of more machinery. The mature choice is almost always a hybrid: plan when the task allows it and replan when reality changes. The next step is to try both on the same task in your favourite framework, such as the OpenAI Agents SDK, and measure cost and accuracy before deciding.

Sources: [1] Plan-and-Solve Prompting, arXiv 2305.04091^[2], [2] Plan-and-Execute Agents, LangChain blog^[5], [3] Building Effective Agents, Anthropic^[4], [4] ReAct, arXiv 2210.03629^[1], [5] An LLM Compiler for Parallel Function Calling, arXiv 2312.04511^[3].

Sources

1. arXiv 2210.03629
2. arXiv 2305.04091
3. arXiv 2312.04511
4. Building Effective Agents
5. Plan-and-Execute Agents, LangChain blog

Route: AI Agents Fundamentals