ReAct (Reason + Act) is a prompting pattern that interleaves the model's chain-of-thought reasoning with tool or action calls in a structured loop: Thought, Action, Observation, Thought, Action, Observation, ..., Final Answer. At each step, the model produces a Thought (reasoning about what to do next), an Action (a tool call like search('Python release date') or sql_query(...)), the orchestrator runs the action and feeds the result back as an Observation, and the loop repeats until the model emits Final Answer. ReAct was introduced by Yao et al. in 2022 and is the substrate for nearly every modern agent framework (LangChain, LlamaIndex, AutoGen, CrewAI). It combines two ideas: chain-of-thought (the model writes reasoning before acting) and tool use (the model can query external systems mid-reasoning). The key implementation detail is that the orchestrator runs the model in a generation loop, stops generation on the Observation: marker via a stop sequence, executes the real tool, injects the real observation, and resumes generation. The model never executes tools itself; it only proposes actions for the orchestrator to run.
**ReAct** (short for Reason + Act) is a prompting pattern that lets an LLM use external tools. The pattern is a structured loop with four labels:
```
Thought: <the model's reasoning about what to do next>
Action: <a tool call, like search('Python release date')>
Observation: <the actual result the tool returned>
Thought: <next reasoning step using that result>
... repeat ...
Final Answer: <the model's final response>
```
The model only produces the Thought, Action, and Final Answer text. The Observation comes from outside: an orchestrator (the code that wraps the model) actually runs the action against a real tool (a web search, a SQL database, an API), gets the result, and injects it back into the prompt as the next Observation.
The loop works mechanically as follows. The model generates text up to the line 'Observation:'. A stop sequence halts generation there. The orchestrator parses the Action, runs the real tool, formats the result, appends it after 'Observation:' in the prompt, and resumes generation. The model picks up from there with the next Thought.
ReAct was introduced in 2022 and is the substrate for nearly every modern agent framework: LangChain, LlamaIndex, AutoGen, CrewAI all implement variants of it.
**ReAct** (Reason + Act) is a prompting pattern that interleaves the model's chain-of-thought reasoning with tool calls, in a structured loop terminated by a Final Answer. It combines two ideas. First, **chain-of-thought**: the model writes out its reasoning before taking action. Second, **tool use**: the model can query external systems mid-reasoning when it needs information it does not have.
The canonical loop has the shape Thought, Action, Observation, Thought, Action, Observation, ..., Final Answer. The model produces the Thought, the Action, and the Final Answer. The orchestrator (the code wrapping the model) produces the Observation by actually executing the Action against a real tool.
The mechanics matter. The orchestrator runs the model with a stop sequence on `\nObservation:` so generation halts the moment the model finishes its Action. The orchestrator parses the Action, routes it to the appropriate tool, executes it, formats the result, appends it as the next Observation, and resumes generation.
ReAct's leverage is that the model interleaves reasoning with information gathering. On a multi-hop question (Who is the CEO of the company that bought GitHub), the model can search for the acquirer, then search for that company's CEO, threading reasoning across two tool calls.
The pattern is the substrate for LangChain agents, LlamaIndex query engines, AutoGen, CrewAI, and almost every modern agent framework. Frontier models with native tool-calling (Claude Opus 4.7, GPT-5.5) implement ReAct under structured tool-call APIs rather than raw text, but the conceptual loop is identical.
Quick reference
TL;DR
ReAct interleaves reasoning and tool calls in a structured Thought-Action-Observation loop, ending in a Final Answer; it is the substrate for most modern agent frameworks.
Imagine a detective solving a case out loud. They say I think the answer might be X, so let me check the records, then they actually walk to the records room and look something up, then come back and say okay, the records say Y, so now I think Z. ReAct makes the LLM behave the same way. The model writes a Thought (its reasoning), then an Action (what tool it wants to use), then the orchestrator runs the tool for real and writes back the Observation (what came back). The loop repeats until the model has enough information to write a Final Answer. The model itself cannot run tools; it just describes what tool to run, and a separate program (the orchestrator) does the actual running.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Single-shot questions that need no external information If the model can answer from its training knowledge in one pass, ReAct just adds latency and tokens; use direct prompting.
Latency-critical user-facing requests under 500 milliseconds Each ReAct iteration requires a model call plus a tool call; multi-step loops compound latency to multiple seconds, often too slow for live UX.
Highly parallel, independent tool calls with no inter-step reasoning ReAct is sequential by design; when actions are independent (fetch 10 records in parallel), use a tool that batches them rather than threading each through the loop.
Quick scan · 2–4 min
Everything important, quickly.
6 min: define ReAct as Reason + Act loop, walk through the four-label structure, explain orchestrator vs model roles, name the stop-sequence mechanism, cover failure modes, connect to native tool-calling APIs.
Real-world examples
Real products, models, and research that use this idea.
1Yao et al.'s 2022 ReAct paper introduced the pattern on HotpotQA and ALFWorld benchmarks, showing it beat plain CoT and plain action-only baselines.
2LangChain's AgentExecutor and LangGraph implement ReAct as a default agent pattern, used across thousands of production LLM applications.
3Claude Opus 4.7 and GPT-5.5 native tool-calling APIs encode ReAct semantics as structured JSON messages (tool_use blocks with tool_result responses) instead of raw text.
4AutoGen, CrewAI, and LlamaIndex's ReActAgent all run the Thought-Action-Observation loop under the hood with various extensions for multi-agent coordination.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does native tool-calling (Claude tool_use, OpenAI function-calling) differ from raw-text ReAct, and what does it solve?
Sign in or go Pro to see the approach for this follow-up.
QWhat goes wrong without a max-steps cap on a ReAct loop?
Sign in or go Pro to see the approach for this follow-up.
QHow does ReAct relate to chain-of-thought and to tool-only agents?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Thinking the LLM actually executes tools; the model only proposes actions, an orchestrator runs them and feeds the real results back as observations.