ReAct Prompting: Combining Reasoning and Actions

ReAct prompting teaches a model to alternate between two modes: thinking out loud and taking actions in the outside world. The reasoning steers what to do next; the actions feed real information back into the reasoning. It is the prompting pattern that turns a chatty model into something that can actually get work done.

1. Introduction

Chain-of-Thought made AI better at reasoning by itself. But pure reasoning has a hard limit — the model can only work with what is already in its training data or its current context. The moment a task requires looking up a fact, running a query, hitting an API, or checking the state of a system, raw CoT runs out of room. ReAct, introduced in a 2022 paper by Yao et al., solves exactly that gap.

The idea is deceptively simple. The model is allowed to produce three kinds of output in any order: a Thought (its internal reasoning), an Action (a tool call it would like to make), and an Observation (the result fed back by the environment after the action runs). Together these form a loop that resembles how a careful human researcher actually works — hypothesise, look something up, update their thinking, decide the next move.

This tutorial covers the ReAct pattern from prompt design through to a worked agent loop you can build with any model that supports function calls or simple stop tokens.

2. The Concept Explained

A ReAct prompt instructs the model to follow a strict cycle. After receiving the user's goal, it must first produce a Thought that explains what it intends to do and why. Then it produces an Action — a specific call to one of the tools you have given it (search, calculator, database query, web fetch, internal API). Your runtime executes the action and feeds the result back as an Observation. The model then either continues with a new Thought, takes another Action, or commits to a Final Answer.

Think of ReAct as the difference between a student writing an exam from memory and a researcher who can leave their desk to fetch a reference book. The researcher's thinking is interleaved with real lookups. They write a paragraph, get up, check a source, come back, refine their argument. ReAct gives the same affordance to the model.

The ReAct loop: Thought drives Action, Action produces an Observation, which feeds the next Thought. Eventually the model exits with a Final Answer.

3. The Problem Without ReAct

Suppose you ask a model to research a small company and summarise its product. Without ReAct, the model has two unattractive options: hallucinate plausible-sounding facts, or refuse and apologise. Neither is useful.

Pure-reasoning attempt

You are a research analyst. Give me a 200-word
brief on the company "Lumen Cargo Systems",
including its main product, target market, and
two competitors.

If the model has never seen this company, it will either confidently invent details or hedge so much that the brief is useless. The model has no way to look anything up — it can only generate text from its prior weights.

4. The Solution: A ReAct Prompt

Now give the same task with a ReAct scaffold and a small set of tools:

ReAct scaffold

You are a research analyst with access to tools.

Available actions:
- search(query: string) — returns the top 3 web results
- fetch(url: string) — returns the visible text of a page
- finish(answer: string) — submits the final brief and ends the loop

Follow this exact format on every step:

Thought: <your reasoning about what to do next>
Action: <one of search / fetch / finish>
Action Input: <the input for that action>

After each Action, you will receive:
Observation: <the tool result>

Continue the Thought / Action / Observation loop until you
have enough information, then call finish() with a 200-word
brief covering main product, target market, and two competitors.

Task: Research the company "Lumen Cargo Systems".

Your runtime parses each Action, executes the corresponding tool, and appends an Observation back into the model's context. The model now reasons over real evidence instead of guessing.

5. Step-by-Step Breakdown

Define the tool surface. Decide which actions the model can take. Keep the list small (3–6 tools is ideal). Each tool should have a clear name, one or two arguments, and a predictable output format.
Lock the output format. Insist on the literal labels Thought:, Action:, Action Input:. This makes parsing reliable. Models are remarkably good at sticking to these labels when the system prompt is explicit.
Implement the runtime loop. Read the model's response, parse out the next Action and its input, execute the corresponding function, and append the Observation to the conversation. Repeat.
Set hard stop conditions. Cap the loop at a maximum number of iterations (typically 5–10). Without a cap, a confused model can loop forever and burn through tokens.
Reserve a special "finish" action. The model signals completion by calling finish(answer). Your runtime detects that action and exits the loop with the answer as the final result.
Handle tool errors gracefully. When a tool fails, return a structured error Observation. The model will usually re-think and try a different approach — exactly the behaviour you want.

Tip: Modern function-calling APIs (OpenAI, Anthropic, Gemini) effectively give you ReAct out of the box — the SDK handles the Thought/Action parsing internally and you simply implement the tools. Even when using these APIs, knowing the underlying ReAct pattern helps you write better tool descriptions and debug strange loops.

6. Practice Exercises

Exercise 1

Build a minimal ReAct loop in any language with two tools: search(query) and calculate(expression). Test it with the question

What is the population of Auckland, divided by the population of Wellington?

Watch how the model decides which tool to use first.

Exercise 2

Take a ReAct prompt that works and deliberately break it — remove the format instructions, or rename Action to Step. Observe how the model's output degrades. This shows you which parts of the scaffold are load-bearing.

Exercise 3

Add a deliberately broken tool that returns errors 30% of the time. Run a ReAct task ten times and count how often the model recovers (retries with a different approach) versus gives up. This stress-tests the robustness of your scaffold.

7. Key Takeaways

ReAct interleaves Thought, Action, and Observation so the model can reason and interact with the outside world in the same loop.
It removes the biggest weakness of pure reasoning — the inability to look anything up — which dramatically reduces hallucinations on knowledge-heavy tasks.
The pattern needs four things: a tool surface, a strict output format, a runtime that executes actions, and a finish signal with a hard iteration cap.
Modern function-calling APIs implement ReAct internally; understanding the pattern still helps you debug and design tool surfaces well.
ReAct is the foundation of most modern AI agents — almost every agent framework is a sophisticated ReAct loop under the hood.

Discussion

Tree of Thoughts: Advanced Multi-Path Reasoning Prompts Self-Consistency Prompting for More Reliable AI Outputs