ReAct Agents (Reason + Act)

A ReAct agent is a language model that alternates between reasoning and acting. It writes a short thought about what it knows and what it still needs, takes an action such as a search or an API call, reads the observation that comes back, and repeats until it can answer. Shunyu Yao and colleagues at Princeton and Google Brain introduced the pattern in October 2022. Their point was to join two things models had been asked to do separately: reasoning step by step, as in chain-of-thought, and acting on an environment. The reasoning chooses the next action, and the action grounds the reasoning in real data.

How a ReAct agent runs: thought, action, observation#

Each turn has three parts. The thought is a sentence or two of working reasoning. The action is one tool call with arguments. The observation is whatever the tool returns, added to the context so the next thought can respond to it. The loop ends when a thought concludes there is enough to answer.

Take the two-hop question "what is the elevation of Kenya's capital?" No single search answers it. The trace works it out as it goes: notice the capital is missing, look it up, read the result, then look up the elevation and answer. That is three model calls, and at no point did the model need to know the answer already.

Why reading results beats reasoning alone#

Reasoning alone cannot check itself. Plain chain-of-thought builds on whatever the model already believes, so a wrong premise turns into a confident, well-argued wrong answer. Acting alone can call tools but has no reasoning to decide what to fetch next or how to combine results. ReAct joins them so each result can correct the plan in the middle of the run.

The paper measured the gap. On ALFWorld, a benchmark of household tasks, ReAct beat imitation and reinforcement-learning baselines by an absolute 34 percentage points of success rate, and on WebShop, a simulated online shop, by 10, prompted with only one or two examples. On HotpotQA and FEVER, question-answering and fact-checking benchmarks, interleaving Wikipedia lookups with reasoning gave trajectories that were more factual and easier to inspect than chain-of-thought alone, which cut hallucination. Check those numbers against your own task before relying on them, because ALFWorld and WebShop are simulated environments with short horizons.

Use the loop whenever the right next action depends on what the last one returned. Debugging is the standard case, because step two depends on what the stack trace in step one says. Research, data exploration and any environment that answers back behave the same way.

How we run the loop in production#

Our executive operations agent, in production as a shipped desktop product, runs a think, act and observe cycle on every step. It acts inside email, calendars, CRM and other systems through registered tools and signed-in browser sessions. Two details from that build apply to any ReAct loop.

The raw observation goes back into the loop rather than a summary of it. A summary is the model's reading of the result, and if that reading is wrong, every later step inherits the mistake with no way to see it. After each step a critic decides whether to continue, retry or escalate. Without it, one bad observation propagates through every later step, and the agent reports success on work it never finished. The run is checked at the end by comparing what the agent claims it completed against the actual state of the target application.

Most of what went wrong was not reasoning. A login failed, a page had moved since the plan was made, an action was unsupported, a tool returned part of a result. Retries are bounded, because an agent that retries forever against a broken vendor burns cost and time while looking busy. When the agent stops, it hands back the specific unresolved step with its trace attached. Prospex, our prospect research engine, uses a reason-and-act loop of the same kind to draft pitch variants, objections and follow-ups.

Small errors compound over long runs#

ReAct conditions every step on the full history, so an early mistake travels. A misread observation in step 2 shapes the thought in step 3, which picks a worse action in step 4, and nothing in the loop notices. The arithmetic is harsh: if each step is 95% reliable, a 20-step run succeeds about 36% of the time, and a 50-step run under 8%.

That argues for short loops with checks outside the model. Cap the number of turns. Make tools fail loudly with an error, not an empty string the model can talk past. Check the trajectory against something external at points where a wrong turn would be expensive. Grade runs with trajectory-level evals that score the steps as well as the final answer, because a run can reach the right answer through a step that will fail on the next input.

ReAct, plan-and-execute and Reflexion#

Plan-and-execute writes the whole plan first and runs it with little replanning. It makes fewer calls to the large model, is easier to predict and review, and fits work whose steps are known in advance, such as a document pipeline. Anthropic's "Building effective agents" draws a similar line between workflows, which follow predefined paths, and agents, which direct their own loop, and recommends the simplest one that works. Start with a fixed workflow, and move to a loop only when the steps cannot be written down in advance. Reflexion adds to ReAct rather than replacing it: after a failed run the agent writes a short critique into memory and tries again with that lesson in context. Many systems mix them, planning first, running each step ReAct-style, and replanning when an observation breaks the plan.

From parsed text to native tool calls#

The original ReAct was a prompt format. The model wrote literal Thought: and Action: lines, and a fragile parser pulled out the tool name and arguments with regular expressions. Native tool calling, which OpenAI shipped in June 2023 and the other major providers followed, moved that contract into the API. The assistant turn carries reasoning text and typed tool-call blocks, the runtime executes them, and results come back as structured messages. The cycle is the same with the parsing risk removed. Build on native tool calls and do not hand-parse the old format. Reasoning models move part of the thought step inside the model, as thinking before each tool call, which changes the cost of each turn more than the shape of the loop.