// term 84 · Agentic Systems
ReAct Framework
Reasoning Plus Acting
The agent pattern that interleaves reasoning with action — think about what's needed, act through a tool, observe the result, think again. ReAct grounds each step of reasoning in real feedback, replacing confident speculation with evidence gathered along the way.
// Loop
thought→act→obs
The three-beat cycle interleaving deliberation with execution — each beat feeding the next.
// Effect
grounded
Reasoning anchored in fetched evidence rather than internal recall — hallucinated premises replaced by observed facts.
// Legacy
the template
The pattern beneath most production agent loops — ReAct's structure became the default grammar of tool-using AI.
// full definition
What ReAct Framework actually is
A model reasoning purely from memory speculates fluently — inventing the file path it should have checked, the price it should have looked up, the API behavior it should have tested. ReAct (Reason + Act) breaks the speculation habit structurally: the model thinks aloud about what it needs, acts to get it — a search, a query, a tool call — observes what actually came back, and reasons forward from that evidence. Each cycle replaces an assumption with an observation; by the end, the conclusion stands on fetched facts rather than confident recall.
The pattern's power is in the interleaving, not the ingredients. Reasoning-only approaches (chain of thought) deliberate beautifully over potentially wrong premises; action-only approaches execute without deliberating about what the results mean. ReAct alternates: the thought selects the next action and interprets the last observation; the observation corrects and redirects the thinking. Errors surface early — a failed call or surprising result arrives mid-task, while the plan can still adapt, rather than after a long reasoning chain has built conclusions on the missing premise.
The explicit thought trace is the pattern's second gift. Because the model narrates its reasoning between actions — why this tool, what that result means, what's still unknown — the loop produces a legible record of how the task unfolded: every decision, every action, every observation, in order. For debugging, the trace localizes failures (bad reasoning, bad tool choice, or bad tool result); for governance, it is the audit trail of an autonomous process; for evaluation, it exposes the steps behind the outcome.
ReAct's historical role is foundational: it demonstrated that interleaved reasoning and tool use beats either alone, and its grammar — thought, action, observation — became the substrate of production agent frameworks. Modern agents elaborate the template (planning layers above, reflection passes within, structured function calling beneath) rather than replacing it. Its limits inherited too: loops can fixate on failing approaches, verbose thoughts inflate token costs, and observation quality bounds the whole — feed the loop bad tool results and it reasons impeccably toward wrong conclusions.
// how it works
Think, act, observe, repeat
ReAct runs a three-beat loop — explicit reasoning choosing an action, the action returning evidence, the evidence shaping the next thought — until the task resolves.
Thought
The model reasons explicitly about the current state — what's known, what's missing, what action would help next.
Action
The chosen tool invokes — a search, query, computation, or call — deliberation becoming information gathering.
Observation
The result returns as evidence — facts, errors, and surprises entering the loop's working context.
Integration
The next thought interprets the observation — premises updated, the plan adjusted, the next need identified.
Iteration
The cycle repeats — each loop trading an assumption for an observation — until the task's needs are met.
Resolution
The final answer composes from accumulated evidence — with the full thought-action-observation trace as its record.
// anatomy
The components teams must understand
01
Thought Trace
Reasoning, narrated
Explicit deliberation between actions — the legible record that makes agent behavior debuggable and auditable.
02
Action Selection
Deliberate tool choice
Each invocation justified by the preceding thought — tools used for reasons, not reflexes.
03
Observation Channel
Evidence returning
Tool results, errors included, feeding the loop — the grounding that separates ReAct from narrated speculation.
04
Working Context
The loop's memory
Accumulated thoughts, actions, and observations — the growing evidence base each cycle reasons from.
05
Termination Logic
Knowing when done
Completion criteria and loop budgets — the bounds that end cycles in answers rather than wandering.
06
Fixation Guards
Escaping bad grooves
Repeated-failure detection and strategy switches — the discipline against loops that retry instead of rethink.
// strategic implications
What this changes for the business
01 · Reliability
Evidence replaces speculation
Interleaved acting grounds each reasoning step in observed fact — the structural fix for models inventing what they should have looked up. For tasks touching live systems and current data, the ReAct pattern is the difference between informed conclusions and fluent guesses.
02 · Transparency
The trace is the audit trail
Thought-action-observation records expose how every conclusion was reached — which tool, what result, what inference. Preserve and surface these traces; they are the debugging substrate and the governance evidence of autonomous work.
03 · Foundation
Know the grammar beneath your agents
Most production agent frameworks elaborate ReAct's loop — understanding it explains agent behavior, cost profiles (thoughts are tokens), and failure modes (fixation, observation quality). The pattern is the literacy; the frameworks are dialects.
// common misconceptions
What ReAct Framework is not
Myth
“ReAct is obsolete — modern agents have moved on.”
Reality
Modern agents elaborate the loop — planning above, reflection within, structured calling beneath — but the interleaved grammar remains the substrate. Understanding ReAct is understanding what production agents actually do per step.
Myth
“The thought trace is the model's actual reasoning.”
Reality
Traces are generated narration — useful, predictive, and auditable, but not guaranteed faithful to internal computation. Treat them as evidence about the process, verified by the actions and observations they sit between.
Myth
“Grounded loops produce correct conclusions.”
Reality
Observation quality bounds the loop — wrong tool results ground reasoning in wrong facts, impeccably. ReAct fixes the speculation failure mode; source and tool reliability remain their own layers.
// from literacy to leverage
Know the term. Now build the strategy.
Vocabulary is the entry fee. Turning these primitives into pipeline, moats, and margin is the work. That's the conversation.