ReAct, CoT, and Plan-and-Execute: AI Agent Reasoning Patterns Explained

Give an LLM a prompt and it gives you text back. Give it a reasoning pattern and it becomes something far more useful — an agent that can break down problems, use tools, and work through multi-step tasks without hand-holding.

But not all reasoning patterns are created equal. The three that dominate the agent landscape right now — Chain-of-Thought, ReAct, and Plan-and-Execute — each make fundamentally different trade-offs between speed, accuracy, and autonomy. Pick the wrong one and your agent wastes tokens going in circles. Pick the right one and it handles tasks you'd expect to need a human for.

This article breaks down how each pattern works, when to reach for it, and where it falls short.

What Is a Reasoning Pattern?

A reasoning pattern is the control flow that governs how an LLM approaches a problem. It determines whether the model answers in one shot, thinks step by step, calls external tools, or builds an explicit plan before acting.

Without a reasoning pattern, you have a stateless text generator. You send a prompt, you get a response, end of story. Add a reasoning pattern and you get something closer to deliberate problem-solving:

• A way to decompose complex questions into manageable steps
• A decision loop that determines when to think, when to act, and when to stop
• A trace of the agent's logic that you can inspect and debug

If you've built an AI agent from scratch, you've already used a reasoning pattern — even if you didn't call it that. The Thought → Action → Observation loop in that tutorial is ReAct. The step-by-step "thinking" that an LLM does before calling a tool? That's Chain-of-Thought.

These patterns are the cognitive architecture underneath every agent framework.

Chain-of-Thought: Think Before You Answer

Chain-of-Thought (CoT) is the simplest pattern and the foundation everything else builds on. Instead of jumping straight to an answer, you get the model to show its work — generating intermediate reasoning steps before arriving at a conclusion.

The original 2022 paper by Wei et al. showed that adding a few worked examples with step-by-step reasoning to the prompt dramatically improved performance on math, logic, and commonsense tasks. A follow-up paper on zero-shot CoT found that simply appending "Let's think step by step" to any prompt triggered the same behavior — no examples needed.

How it works in practice

You ask: "If a store sells 3 shirts at $24 each and gives a 15% discount, what's the total?"

Without CoT, the model might guess. With CoT, it generates:

3 shirts × $24 = $72. 15% of $72 = $10.80. Total after discount = $72 − $10.80 = $61.20.

That intermediate trace isn't just cosmetic. It genuinely improves accuracy because the model conditions each step on the previous one.

Where CoT fits in the agent picture

CoT is pure reasoning with no actions. The model thinks, but it can't query an API, search the web, or write to a database. That makes it powerful for closed-domain problems where all the information is in the prompt, but insufficient for anything requiring real-world data.

Its real importance is foundational. Every agent pattern that follows — ReAct, Plan-and-Execute, Tree of Thoughts — relies on the LLM's ability to reason step by step. CoT is the substrate they're all built on.

ReAct: Reasoning Meets Action

ReAct (Reason + Act) takes Chain-of-Thought and adds the ability to do things. The agent alternates between thinking and acting in a loop, grounding its reasoning in real observations from the outside world.

The pattern was introduced by Yao et al. at ICLR 2023 and quickly became the default architecture for most agent frameworks. Google Research's overview describes it as "synergizing reasoning and acting" — the model's thoughts inform which tools to call, and tool results inform subsequent reasoning.

The loop

Every ReAct cycle follows three steps:

1. Thought — the agent reasons about what it knows and what it needs to do next
2. Action — the agent calls a tool (search, calculator, API, database query)
3. Observation — the agent reads the tool's output and feeds it into the next thought

Here's a concrete trace:

Question: What is the population of the capital of France?

Thought: I need to find the capital of France first, then look up its population.
Action: search("capital of France")
Observation: Paris is the capital of France.

Thought: Now I need the population of Paris.
Action: search("population of Paris 2024")
Observation: The population of Paris is approximately 2.1 million (city proper).

Thought: I have the answer.
Final Answer: The population of Paris, the capital of France, is approximately 2.1 million.

This is the same tool-calling loop you'll find in LangChain, OpenAI's Agents SDK, and every other agent framework. The implementation details differ, but the Thought/Action/Observation cycle is universal.

Strengths and weaknesses

ReAct excels at single-focus tasks that require gathering information or taking a series of related actions — answering research questions, interacting with APIs, navigating databases.

ReAct struggles with tasks that require upfront planning. Because it decides what to do one step at a time, it can wander, repeat itself, or miss the big picture. Ask a ReAct agent to "plan a three-course dinner, buy ingredients, and write the recipes" and it might start Googling appetizers before thinking about what the main course is.

Plan-and-Execute: Think Big, Then Do

Plan-and-Execute flips the script. Instead of interleaving reasoning and action step by step, it separates planning from execution into two distinct phases.

The academic foundation comes from the Plan-and-Solve paper (Wang et al., ACL 2023), and the architecture was popularized in production by LangChain's planning agents and the viral BabyAGI project.

How it works

1. Plan — a planner LLM receives the full task and generates a multi-step plan
2. Execute — an executor agent works through each step, using tools as needed
3. Re-plan (optional) — after each step, the planner can revise remaining steps based on new information

This separation has a practical benefit: you can use a powerful, expensive model (like Claude Opus or GPT-4) for planning, and a faster, cheaper model for execution. The planner runs once; the executor runs many times.

When Plan-and-Execute beats ReAct

Plan-and-Execute shines when the task has dependencies between steps or requires coordinating multiple sub-tasks. Think project management: you need to know the full scope before you start assigning work.

It also fits naturally into multi-agent systems, where a planner agent delegates steps to specialized executor agents — one for research, one for coding, one for writing.

The trade-off is latency and complexity. The initial planning step takes time, the plan can be wrong, and re-planning adds overhead. For simple tasks, this is overkill. For complex multi-step workflows, it's essential.

Comparing the Three Patterns

	Chain-of-Thought	ReAct	Plan-and-Execute
Thinking style	Linear reasoning	Interleaved reasoning + action	Upfront plan, then execution
Tool use	None	Yes, one tool per cycle	Yes, during execution phase
Planning horizon	Current step only	Next step only	Full task upfront
Cost per task	Low (single LLM call)	Medium (multiple calls in loop)	High (planner + executor calls)
Best for	Closed-domain reasoning	Information gathering, API tasks	Complex multi-step workflows
Complexity	Trivial	Moderate	High

The patterns aren't mutually exclusive. A Plan-and-Execute agent typically uses ReAct within its execution phase, and ReAct inherently uses Chain-of-Thought for its reasoning steps. They stack.

Beyond the Big Three: Patterns Worth Knowing

The field moves fast. Three emerging patterns push reasoning further:

• Reflexion — after a failed attempt, the agent writes a self-critique explaining what went wrong, stores it in memory, and retries with that reflection in context. It hit 91% on HumanEval coding benchmarks by learning from its own mistakes — no retraining required.

• Tree of Thoughts — generalizes CoT from a single chain to a branching tree. The model generates multiple candidate reasoning paths, evaluates them, and explores the most promising branches. On the Game of 24 puzzle, this jumped GPT-4 from 4% to 74% accuracy. The trade-off: it multiplies LLM calls dramatically.

• LATS (Language Agent Tree Search) — the most ambitious pattern, combining ReAct, Tree of Thoughts, and Monte Carlo Tree Search into a unified framework. The LLM acts as agent, value function, and self-reflector simultaneously. Powerful, but expensive enough that it's mostly a research tool for now.

How to Choose the Right Pattern

Skip the theory — here's the decision guide:

• Your task is a single question with all context provided → Chain-of-Thought. No tools needed, just better reasoning.
• Your task requires fetching data or calling APIs → ReAct. The standard agent loop handles most real-world tasks well.
• Your task has multiple dependent steps or needs coordination → Plan-and-Execute. Worth the added complexity for workflows where order matters.
• Your agent keeps making the same mistakes → Add Reflexion on top of whatever pattern you're using.
• You're not sure → Start with ReAct. It's the default for a reason — flexible enough for most tasks, simple enough to debug.

Most production agents don't pick one pattern and stick with it rigidly. They use ReAct as the backbone, add planning when tasks get complex, and layer in self-reflection when reliability matters. The difference between an agent and a workflow often comes down to how much reasoning autonomy you give the system.

Start simple. Add complexity only when the task demands it.