What is the ReAct pattern?
Confuse it with the JavaScript framework and you miss what a vendor deck is actually promising: an agent loop, not a UI library.
ReAct pattern
reason-and-act
The ReAct pattern is a loop where a language model reasons, takes an action such as a tool call, then reads the result before reasoning again. It comes from the 2022 paper "ReAct: Synergizing Reasoning and Acting in Language Models" by Yao et al., published at ICLR 2023.
Before ReAct, teams picked one of two prompting styles. Chain-of-thought had the model reason in text, but it never touched the outside world. It could not check a fact or look anything up. Action-only prompting called tools but skipped the reasoning, so a bad first guess had nothing to correct it. Yao's paper interleaved the two: reason, act, observe, reason again.
That is also why the name causes trouble in a sales meeting. Say "ReAct" to a room with a frontend engineer in it and half the table hears the JavaScript library. The paper predates any agent-framework use of the term, and the two share nothing beyond the letters.
It was a prompting trick, not an architecture
In the original paper, the model wrote plain text in a fixed shape. A Thought line, then an Action line, then it stopped and waited for an Observation. The code around the model parsed the Action line, called a tool, and fed the result back as the next Observation. None of this needed special model training.
That is what made it popular fast. Any model that could follow a text pattern could run a ReAct loop. The earliest LangChain agents and the earliest AutoGPT-style projects were, structurally, this pattern with a parser wrapped around it.
- ThoughtThe model reasons about what to do next.
- ActionIt names a tool and its arguments.
- ObservationThe tool's result comes back as text.
- ThoughtIt reasons again, now with new information.
- AnswerIt stops once it has enough to respond.
The loop repeats until the model decides it has enough to answer. Nothing forces it to stop early, which is why a step limit belongs in your code, not in the prompt.
Native tool calling replaced the hand-rolled version
OpenAI and Anthropic now ship tool calling as a first-class part of the API. You send a schema, the model returns a structured call, and you never parse a Thought/Action line out of free text again. Reasoning still happens, often inside the model's own extended thinking. You no longer write the regular expression that used to hold the whole system together.
So when a vendor deck says "we built this with ReAct," the honest question is which version. A team still parsing Thought/Action text out of a raw completion in 2026 is carrying maintenance cost that structured tool calling removed years ago. Only the loop shape had to survive. The string-parsing did not.
Related questions
01Is the ReAct pattern the same as the React JavaScript framework?
No. React the framework is Meta's UI library for building interfaces, and it predates this pattern by nearly a decade. This ReAct is an AI prompting technique from a 2022 research paper. Sharing a name is a coincidence of abbreviation, not a shared origin.
02Do modern agent frameworks still use ReAct?
Most still run a reason-then-act loop, but the mechanics changed. Native tool calling replaced the hand-written Thought/Action text parsing the original paper used, so the loop survives while the plumbing underneath it does not.
03What problem does ReAct solve that plain chain-of-thought does not?
Chain-of-thought reasons in text with no way to check anything against the outside world. ReAct lets the model call a tool mid-reasoning, read back a real result, and correct its next step based on it.
04Does ReAct stop itself when it has enough information?
The model can decide it has enough and produce a final answer, but nothing in the pattern forces that decision. A production system needs its own step limit, because a stuck loop will keep calling tools until something external stops it.
