Building AI Agents: The ReAct Pattern (Reasoning + Acting) Explained

While basic Large Language Model applications operate in single-turn request-response cycles, Autonomous AI Agents possess agency: the capacity to independently reason, choose tools, execute code, observe external environmental state, and iterate in a loop until a multi-step objective is fulfilled.

In 2022, Yao et al. formalised the foundational architecture of autonomous agents: the ReAct Pattern (Reasoning + Acting).

By interleaving verbal reasoning traces ("Thought") with action execution ("Action" and "Observation"), the ReAct pattern prevents compounding errors, enables tool self-correction, and transforms raw language models into dynamic problem-solving engines.

---

1. The Anatomy of a ReAct Loop

The core execution state of an agent is managed through an append-only Scratchpad Context:

${\text{Context}}_t=\left[\text{System Prompt},\text{User Goal},(T_1,A_1,O_1),(T_2,A_2,O_2),\dots ,(T_{t-1},A_{t-1},O_{t-1})\right]$

The Three Operational Phases:

1. Thought ($T_t$): The model generates a chain-of-thought internal monologue describing its current hypothesis and planning the next action.
2. Action ($A_t$): The model emits a structured function call payload (e.g. JSON format with tool name and arguments). The LLM execution halts and yields control back to the agent runtime.
3. Observation ($O_t$): The agent runtime executes the requested tool in the external environment (e.g. database query, API call, bash script) and injects the raw result string directly into the prompt context.

The loop repeats until the model decides that the goal is complete and emits a Final Answer.

---

2. Agent Execution Guardrails: Preventing Runaway Loops

Autonomous agents in production require strict deterministic runtime guardrails to prevent infinite loops, resource exhaustion, and runaway API bills:

Cycle Detection Algorithm:

If an agent executes the exact same tool with the exact same arguments for $N\ge 3$ consecutive steps (e.g. repeatedly calling search('pricing') and receiving the same empty result), the runtime intercepts the loop and injects a synthetic environmental hint: "System: You have executed this exact tool 3 times with no change in output. You MUST change your strategy or return a fallback answer."

---

3. Minimal Python Implementation: The ReAct Engine

---

4. Production Failure Modes: The Infinite Tool Error Loop

Failure Mode: Infinite Retry Thrashing on Ambiguous Tool Errors

• Symptom: An autonomous SQL analyst agent burns through $40 of OpenAI API credits on a single query, repeatedly outputting 50 steps until hitting maximum token limits.
• Root Cause: The database tool returned a vague error message: RuntimeError: Syntax error. The LLM could not diagnose what part of the SQL query was invalid, so it slightly altered whitespace and re-submitted the exact same query in an infinite loop.
• Resolution: Design informative, actionable tool error returns. Instead of returning Syntax error, the tool should return: {"status": "error", "message": "Syntax error at character 42: column 'created_at' does not exist in table 'orders'. Available columns: ['id', 'user_id', 'order_timestamp', 'total_amount']"}. This gives the model immediate contextual guidance to correct its query in Step 2.

---

5. Summary & Key Takeaways

1. ReAct Interleaves Reasoning and Actions: Alternating Thought $\to$ Action $\to$ Observation enables autonomous agents to self-correct and solve multi-step problems.
2. The Scratchpad Tracks Trajectory: An append-only conversation log maintains historical environmental feedback across steps.
3. Guardrails are Mandatory: Enforce strict step limits, timeout clocks, cost budgets, and duplicate action detection.
4. Actionable Error Feedback: Tools must return detailed, corrective error messages to guide the agent toward rapid recovery.