Flashcard: what is the ReAct prompting pattern?

Flashcard·Easy·4.0 · 0·~30s·Asked atBraintrust Coinbase Midjourney·Relevant atAmazon Anthropic Apple LangChain

Attempt it

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.

Your answer

**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.

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.

Memory aid

Easy to grasp

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.

Key concepts

ReAct pattern Tool use Agent loop

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

ReAct is the prompting pattern that made agents practical. Before ReAct, LLMs were one-shot text generators: send a prompt, get an answer. After ReAct, the same model could iteratively call tools, observe results, and refine its approach across many steps. Almost every modern agent framework (LangChain, LlamaIndex, AutoGen, CrewAI, OpenAI Assistants) implements some variant of the ReAct loop under the hood.

This deep dive walks through the structure of the ReAct loop, explains exactly which side (model or orchestrator) produces which text, names the implementation mechanics that make the loop robust in production, and connects raw-text ReAct to the structured tool-calling APIs that frontier models now expose.

The structure of the loop

ReAct stands for Reason plus Act. The loop has four labels:

code

Thought: <the model's reasoning about what to do next>
Action: <a tool call, e.g. search('Python release date')>
Observation: <the actual result returned by the tool>
Thought: <next reasoning step that uses the observation>
Action: <next tool call, or no action if the model is ready>
Observation: <next tool result>
...
Final Answer: <the model's final response to the user>

The pattern is iterative. At each step the model produces a Thought (its reasoning) and an Action (a proposed tool call). The orchestrator runs the action against the real tool, captures the result, and writes it back as the next Observation. The model picks up reasoning from there. The loop continues until the model emits a Final Answer line, which signals it has enough information to respond.

The key insight is the separation of concerns. The model generates language; the orchestrator handles execution and state. The model cannot make a real web search or run a real SQL query; it can only describe what it wants to do. The orchestrator translates the description into an actual call, runs it, and feeds the result back into the prompt for the next iteration.

Who writes what (model vs orchestrator)

Production mechanics: tools, errors, and limits

Native tool-calling: ReAct in structured form

Failure modes and observability

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Yao et al.'s 2022 ReAct paper introduced the pattern on HotpotQA and ALFWorld benchmarks, showing it beat plain CoT and plain action-only baselines.
LangChain's AgentExecutor and LangGraph implement ReAct as a default agent pattern, used across thousands of production LLM applications.

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?

Native tool-calling uses structured API messages with typed schemas instead of free-form text. It solves parsing reliability (no regex hacks to extract Action arguments), schema validation, and parallel tool calls. Semantics are identical to ReAct.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases 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.

60 second bullets to scan on the way to the call.

What ReAct stands for (Reason + Act) and what each component does
The four labels in the loop (Thought, Action, Observation, Final Answer)

Primary sources. Browse if you want the original framing.