A capable model still needs a way to break a goal into steps, choose between competing plans, and notice when a step went wrong. This is the landscape of reasoning patterns — Chain-of-Thought, ReAct, Reflexion, Tree of Thoughts, and Plan-and-Execute — that give agents that ability.
Agent planning and reasoning is the set of techniques that let an AI agent decompose a goal, decide what to do next, and correct course when something goes wrong, instead of producing a single unreflective answer. The foundational layer is Chain-of-Thought (step-by-step reasoning). On top of that sit four patterns in active production use: ReAct (interleave reasoning with tool actions), Reflexion (self-critique and retry), Tree of Thoughts (explore multiple reasoning paths, not just one), and Plan-and-Execute / ReWOO (commit to a full plan upfront, then execute it). Most production planners draw on one of five underlying strategies: task decomposition, multi-plan selection, external module-aided planning, reflection and refinement, or memory-augmented planning.
Underneath every agentic workflow sits a reasoning engine with two jobs. Planning decomposes an open-ended goal into a sequence of smaller, more tractable reasoning steps. Tool calling takes each step and grounds it — checking a fact, running a query, calling an API — so the agent's next decision is informed by something more solid than its own prior guess.
For simple tasks, a full planning phase isn't always necessary — an agent can iteratively reflect on and improve a response without ever explicitly planning ahead. Planning earns its cost on tasks with real branching complexity: multiple valid approaches, dependencies between steps, or a real chance of taking a wrong turn.
Chain-of-Thought is the reasoning-only baseline. Every pattern that follows adds something to it — action, reflection, branching, or upfront commitment — but none of them replace it.
Chain-of-Thought prompting asks the model to show its intermediate reasoning steps before landing on an answer, rather than jumping straight there. It's a reasoning-only baseline: no tool calls, no environment feedback, just decomposition of the problem into a visible sequence of smaller inferences.
It measurably improves multi-step reasoning and decomposition — which is exactly why it shows up as a layer inside almost every more advanced agent pattern, rather than being replaced by them.
ReAct binds reasoning directly to tool use. The agent writes a thought, takes an action based on it, observes the result, and folds that observation into its next thought — cycling through Thought → Action → Observation until the task is done.
Because every intermediate decision is written out, the whole trajectory is inspectable and auditable, which is a large part of why ReAct became the default pattern in production agent frameworks: it balances adaptability with a reasoning trail a person can actually check. Its main weakness is a tendency to loop — repeating the same thought and action without making real progress when the model can't find a new angle.
Most agent architectures have a distinct planning step that invokes one or more of these five strategies before any action is executed.
None of these strategies are mutually exclusive — production planners frequently combine two or three of them for the harder tasks.
Break a goal into smaller, ordered subtasks that can be tackled one at a time.
Generate several candidate plans, then pick the strongest one before execution.
Lean on a dedicated planning module or solver rather than the LLM alone.
Revise a plan mid-flight based on new information or a detected mistake.
Draw on stored past experience to inform how the current plan is built.
Reflexion adds an explicit self-reflection loop on top of a reasoning pattern like ReAct. After an attempt, the agent generates a verbal critique of what went wrong — a dead end it hit, a wrong assumption it made — and carries that critique into its next attempt as additional context, rather than repeating the same mistake.
The gains from this loop can be striking: on coding benchmarks, models using Reflexion have posted pass rates that jump well past their own baseline performance, with the entire improvement coming from the reflection step itself rather than a stronger underlying model.
Where Chain-of-Thought commits to one reasoning path, Tree of Thoughts explores several branches at once — generating multiple possible next thoughts at each step, evaluating which ones look promising, and pruning the rest before continuing deeper down the surviving branches.
It costs more compute than a single-path approach, so it earns its keep on problems where an early wrong turn is expensive to recover from — puzzles, complex planning problems, or any task where backtracking after committing to one path wastes real time.
ReWOO ("Reasoning WithOut Observation") takes a different position from ReAct: instead of interleaving thought and tool call at every step, it plans the entire sequence of actions upfront, then executes them without needing to pause and re-reason after each tool response.
A planner module decomposes the task into subtasks, a worker module executes each one against real tools, and a solver module synthesizes the results into a final answer. This can outperform ReAct on certain benchmarks and cuts down on repeated tool calls, but it has a real cost: because the plan is fixed in advance, it struggles when the environment turns out to hold less context than expected, or when extra tools are added that the upfront plan didn't anticipate.
No single pattern dominates on every axis — cost, reliability, and interpretability all pull in different directions.
If your biggest risk is hallucination on knowledge-heavy tasks, ReAct's grounding in real tool observations tends to help. If it's brittle one-shot answers on tasks with a checkable outcome — like code that either passes tests or doesn't — Reflexion's self-critique loop earns its extra latency. If the risk is committing early to the wrong approach, Tree of Thoughts' willingness to explore multiple branches is worth the added compute.
| Pattern | Core mechanism | Strength | Main cost or risk |
|---|---|---|---|
| Chain-of-Thought | Single-path step-by-step reasoning | Cheap, fast | No grounding, no correction |
| ReAct | Interleaved thought → action → observation | Inspectable, grounded | Can loop without progress |
| Reflexion | Self-critique after each attempt | Learns from failure | Extra latency per retry |
| Tree of Thoughts | Explore and prune multiple branches | Avoids early wrong turns | Higher compute cost |
| Plan-and-Execute / ReWOO | Plan upfront, then execute without pausing | Fewer redundant tool calls | Brittle to unplanned surprises |
These patterns aren't mutually exclusive, and production systems rarely rely on just one. A common combination pairs Reflexion with ReAct for adaptive, self-correcting behavior on long tasks, or pairs Plan-and-Execute with Tree of Thoughts for problems that need both an upfront structure and room to explore.
Underneath all of them runs the same basic loop: perceive the situation, reason about what to do, act, and reflect on the result before perceiving again. Choosing which reasoning pattern powers each part of that loop — not abandoning the loop itself — is what separates a reliable agent from an impressive demo.
Chain-of-Thought is reasoning only — the model thinks step by step but never touches a tool or the outside world. ReAct adds action: the agent alternates between a reasoning thought and an actual tool call, observing the real result before its next thought, which grounds the reasoning in something more reliable than the model's own assumptions.
Use Tree of Thoughts when an early wrong turn is expensive to recover from — puzzles, multi-step planning with real dependencies, or problems with several plausible approaches. It costs more compute because it explores multiple branches rather than one, so it's not worth it for simple, low-ambiguity tasks where Chain-of-Thought already works reliably.
Reflexion adds an explicit self-critique step after an attempt fails or falls short: the agent writes out what went wrong in its own words and carries that critique forward into its next attempt as extra context. It's most valuable on tasks with a checkable outcome — like code that passes or fails tests — where the agent can clearly tell it needs to try again.
Because each new thought is conditioned on the same observation, the model can end up regenerating a similar thought and action repeatedly without making real progress, especially when it hasn't been given a mechanism to recognize it's stuck. Pairing ReAct with a reflection step, or a hard step limit, is a common mitigation.
ReWOO plans an entire sequence of actions upfront and then executes them without pausing to re-reason after every tool response, unlike ReAct which interleaves reasoning and action at every step. This reduces redundant tool calls and can outperform ReAct on some benchmarks, but it's more brittle when the environment surfaces information the upfront plan didn't anticipate.
Rarely. Most production systems combine patterns — Reflexion layered on top of ReAct for adaptive self-correction, or Plan-and-Execute combined with Tree of Thoughts for long-horizon problems that need both structure and exploration. The patterns are building blocks inside a broader perceive-reason-act-reflect loop, not competing replacements for each other.
Start from the failure mode you're most worried about — hallucination, brittle one-shot answers, or early wrong turns — and let that choose the pattern, not the other way around.