Planning Strategies: ReAct, Plan-and-Execute, Tree-of-Thought

Why agents need planning strategies at all

Here's the thing, when you give an agent a complex task like "process this enterprise customer inquiry," the LLM can't just call one tool and be done. It needs to decide what to do first, monitor how that goes, then figure out what comes next. That's planning.

Without a planning strategy, agents either spin in circles (calling the same tool repeatedly) or make greedy local moves that dead-end. From what I've seen in production, the difference between an agent that completes a workflow and one that burns tokens in confusion almost always comes down to how it manages the sequence of reasoning and action.

The three main strategies, ReAct, Plan-and-Execute, and Tree-of-Thought, give you different trade-offs between adaptability, cost, and reliability. Let's break down what each one actually does.

Check your understanding

You're building an agent to book service appointments. Sometimes the customer's preferred time is unavailable and the agent needs to suggest alternatives dynamically. Which planning strategy best fits this scenario?

ReAct: Think, Act, Observe, Repeat

ReAct, short for Reasoning + Acting, coined by Shunyu Yao in 2022, is the foundational pattern most production agents use today. The loop is simple: the agent generates a Thought about what to do next, takes an Action (calling a tool), observes the result, then reasons again.

For example, a sales lead qualification agent might think "I need recent conversations from the healthcare vertical," call the CRM search tool, get back 12 results, then think "Now I'll analyze fit scores" and call the scoring API. Each step informs the next. The agent isn't locked into a rigid plan, it adapts based on what it actually sees.

The catch? ReAct can be expensive (you're calling the LLM at every step) and sometimes myopic, it optimizes locally without seeing the big picture. Shunyu Yao's original paper showed that adding a quick planning step upfront (the ReAct&Plan hybrid) boosted CTF challenge success from 83% to 95%. Modern agents in 2026 almost always start with a rough plan, then execute it ReAct-style with freedom to deviate.

Flow diagram showing ReAct cycle: Thought leads to Action, Action produces Observation, Observation feeds back to next Thought — The ReAct loop in action: agents think about the current state, take an action using tools, observe the result, and reason again, continuing until the goal is reached.

Prevent infinite loops with iteration caps

In production, always set a maximum iteration limit (e.g., 10-15 steps) for ReAct agents. Without it, you can burn through your token budget when the agent gets stuck. Most frameworks let you configure this as a simple parameter, use it.

Check your understanding

Match each component of the ReAct loop to its role in the agent's cognitive cycle:

Plan-and-Execute: Separate strategy from tactics

Plan-and-Execute flips the script. Instead of reasoning at every step, you use two specialized agents: a Planner and an Executor. The Planner looks at the goal, decomposes it into an ordered list of steps (without calling any tools), then hands that plan to the Executor, which is usually just a ReAct agent that runs each step in sequence.

This pattern shines for well-defined, structured workflows where you know the rough shape of the solution upfront. IBM's Multi-agent RAG system uses this approach: the planner breaks down a research question into subtasks ("gather documents from corpus A," "extract key statistics," "synthesize findings"), and the executor handles each one. Oracle Integration's inquiry management system does the same, validate contact, check account status, route to team, log interaction.

The trade-off? Plan-and-Execute is more efficient and predictable than pure ReAct (fewer LLM calls, clearer audit trail), but it's less adaptive. If step three reveals that step four is now irrelevant, the executor might plow ahead anyway unless you build in re-planning hooks. For exploratory tasks where you don't know what you'll find, ReAct is usually better.

When to choose Plan-and-Execute over ReAct

Use Plan-and-Execute when you have a repeatable multi-step workflow with clear phases, like customer onboarding, compliance checks, or report generation. Use ReAct when the task is exploratory, the environment is unpredictable, or you need the agent to adapt its strategy based on what it discovers along the way.

Check your understanding

Tree-of-Thought: Exploring multiple paths in parallel

Tree-of-Thought (ToT) takes planning to another level. Instead of committing to a single reasoning path, the agent explores multiple branches in parallel, evaluates each one, and prunes the dead ends. It's like a chess engine considering several moves ahead before deciding.

Denny Zhou's work on Language Agent Tree Search (LATS) showed that ToT strategies outperform ReAct on complex multi-step reasoning tasks, especially when backtracking is expensive or a wrong early move cascades into failure. You see this in research-heavy domains (Novo Nordisk's drug discovery agents, for example) where exploring alternative hypotheses upfront saves expensive lab work downstream.

The catch? ToT is expensive and complex. You're running multiple LLM inference passes, maintaining a search tree, and evaluating branch quality. For most business workflows, booking appointments, processing inquiries, generating reports, ReAct or Plan-and-Execute are plenty. Reserve ToT for high-stakes, high-complexity problems where the cost of getting it wrong justifies the computational overhead.

Tree-of-Thought is overkill for most production workflows

Don't reach for ToT just because it sounds sophisticated. It multiplies your inference costs and adds latency. Start with ReAct or Plan-and-Execute, measure where they fail, and only introduce ToT if you have a genuine need to explore multiple reasoning paths in parallel. Most production agents never need it.

Hybrid approaches: The pragmatic middle ground

Here's what I've seen work in production: agents that combine strategies based on the task phase. Start with a rough plan (cheap, gives direction), execute each step ReAct-style (adaptive, handles surprises), and re-plan only when a step reveals something unexpected.

The RP-ReAct architecture from recent research decouples strategic planning (using a reasoning-optimized model) from low-level execution (using a ReAct agent with tool access). Salesforce account creation workflows do this too, plan the sequence (create Account, get AccountID, create Task, assign owner), but let the ReAct executor handle API retries, parse responses, and manage state across tool calls.

Chi Wang and Qingyun Wu's work on AG2 (the successor to AutoGen) shows this hybrid pattern everywhere in production. Modern agents rarely use a single pure strategy. They mix planning, reactive execution, and sometimes even parallel exploration depending on what the task demands. The trick is knowing which pattern fits which phase of your workflow.

Key takeaways

ReAct interleaves reasoning and action at every step, making it adaptive but potentially expensive and myopic.
Plan-and-Execute separates strategic planning from tactical execution, excelling at structured workflows but struggling with unpredictability.
Tree-of-Thought explores multiple reasoning paths in parallel, delivering optimal solutions for complex problems at the cost of computational overhead.
Modern production agents use hybrid approaches, starting with a rough plan, executing ReAct-style, and re-planning when surprises emerge.
Choose your planning strategy based on task structure: ReAct for exploratory work, Plan-and-Execute for repeatable workflows, ToT only for high-stakes complexity.

Your product check-in

Apply “Planning Strategies: ReAct, Plan-and-Execute, Tree-of-Thought” to a product or workflow you know. What would you try, what could go wrong, and what evidence would help you decide?