Concept: ReAct Pattern for AI Agents

What is ReAct?

ReAct (Reasoning + Acting) is a framework that combines:

• Reasoning: Thinking through problems step-by-step
• Acting: Using tools to accomplish subtasks
• Observing: Learning from tool results

This creates agents that can solve complex, multi-step problems reliably.

The Core Pattern

┌─────────────┐
│   Problem   │
└──────┬──────┘
       │
       ▼
┌─────────────────────────────────────┐
│          ReAct Loop                 │
│                                     │
│  ┌──────────────────────────────┐  │
│  │  1. THOUGHT                  │  │
│  │  "What do I need to do?"     │  │
│  └─────────────┬────────────────┘  │
│                ▼                    │
│  ┌──────────────────────────────┐  │
│  │  2. ACTION                   │  │
│  │  Call tool with parameters   │  │
│  └─────────────┬────────────────┘  │
│                ▼                    │
│  ┌──────────────────────────────┐  │
│  │  3. OBSERVATION              │  │
│  │  Receive tool result         │  │
│  └─────────────┬────────────────┘  │
│                │                    │
│                └──► Repeat or      │
│                     Final Answer   │
└─────────────────────────────────────┘

Why ReAct Matters

Traditional LLMs Struggle With:

1. Complex calculations - arithmetic errors
2. Multi-step problems - lose track of progress
3. Using tools - don't know when/how
4. Explaining decisions - black box reasoning

ReAct Solves This:

1. Reliable calculations - delegates to tools
2. Structured progress - explicit steps
3. Tool orchestration - knows when to use what
4. Transparent reasoning - visible thought process

The Three Components

1. Thought (Reasoning)

The agent reasons about:

• What information is needed
• Which tool to use
• Whether the result makes sense
• What to do next

Example:

Thought: I need to calculate 15 × 8 to find revenue

2. Action (Tool Use)

The agent calls a tool with specific parameters:

Example:

Action: multiply(15, 8)

3. Observation (Learning)

The agent receives and interprets the tool result:

Example:

Observation: 120

Complete Example

Problem: "If 15 items cost $8 each and 20 items cost $8 each, 
          what's the total revenue?"

Thought: First I need to calculate revenue from 15 items
Action: multiply(15, 8)
Observation: 120

Thought: Now I need revenue from 20 items
Action: multiply(20, 8)
Observation: 160

Thought: Now I add both revenues
Action: add(120, 160)
Observation: 280

Thought: I have the final answer
Answer: The total revenue is $280

Key Benefits

1. Reliability

• Tools provide accurate results
• No arithmetic mistakes
• Verifiable calculations

2. Transparency

• See each reasoning step
• Understand decision-making
• Debug easily

3. Scalability

• Handle complex problems
• Break into manageable steps
• Add more tools as needed

4. Flexibility

• Works with any tools
• Adapts to problem complexity
• Self-corrects when needed

Comparison with Other Approaches

Zero-Shot Prompting

User: "Calculate 15×8 + 20×8"
LLM: "The answer is 279"  ❌ Wrong!

Problem: LLM calculates in head, makes errors

Chain-of-Thought

User: "Calculate 15×8 + 20×8"
LLM: "Let me think step by step:
     15×8 = 120
     20×8 = 160
     120+160 = 279"  ❌ Still wrong!

Problem: Shows work but still miscalculates

ReAct (This Implementation)

User: "Calculate 15×8 + 20×8"
Agent:
  Thought: Calculate 15×8
  Action: multiply(15, 8)
  Observation: 120
  
  Thought: Calculate 20×8
  Action: multiply(20, 8)
  Observation: 160
  
  Thought: Add results
  Action: add(120, 160)
  Observation: 280
  
  Answer: 280  ✅ Correct!

Success: Uses tools, gets accurate results

Architecture Diagram

┌──────────────────────────────────────┐
│          User Question               │
└──────────────┬───────────────────────┘
               │
               ▼
┌──────────────────────────────────────┐
│      LLM with ReAct Prompt           │
│                                      │
│  "Think, Act, Observe pattern"       │
└──────┬───────────────────────────────┘
       │
       ├──► Generates: "Thought: ..."
       │
       ├──► Generates: "Action: tool(params)"
       │         │
       │         ▼
       │    ┌─────────────────┐
       │    │  Tool Executor  │
       │    │                 │
       │    │  - multiply()   │
       │    │  - add()        │
       │    │  - divide()     │
       │    │  - subtract()   │
       │    └─────────┬───────┘
       │              │
       │              ▼
       └───────── "Observation: result"
       │
       ├──► Next iteration or Final Answer
       │
       ▼
┌──────────────────────────────────────┐
│         Final Answer                 │
└──────────────────────────────────────┘

Implementation Strategies

1. Explicit Pattern Enforcement

Force the LLM to follow structure:

systemPrompt: `CRITICAL: Follow this EXACT pattern:
Thought: [reasoning]
Action: [tool call]
Observation: [result]
...
Answer: [final answer]`

2. Iteration Control

Prevent infinite loops:

maxIterations = 10  // Safety limit

3. Streaming Output

Show progress in real-time:

onTextChunk: (chunk) => {
    process.stdout.write(chunk);
}

4. Answer Detection

Know when to stop:

if (response.includes("Answer:")) {
    return fullResponse;  // Done!
}

Real-World Applications

1. Math & Science

• Complex calculations
• Multi-step derivations
• Unit conversions

2. Data Analysis

• Query databases
• Process results
• Generate reports

3. Research Assistants

• Search multiple sources
• Synthesize information
• Cite sources

4. Coding Agents

• Read code
• Run tests
• Fix bugs
• Refactor

5. Customer Support

• Query knowledge base
• Check order status
• Process refunds
• Escalate issues

Limitations & Considerations

1. Iteration Cost

Each thought/action/observation cycle costs tokens and time.

Solution: Use efficient models, limit iterations

2. Tool Quality

ReAct is only as good as its tools.

Solution: Build robust, well-tested tools

3. Prompt Engineering

System prompt must be very clear.

Solution: Test extensively, iterate on prompt

4. Error Handling

Tools can fail or return unexpected results.

Solution: Add error handling, validation

Advanced Patterns

Self-Correction

Thought: That result seems wrong
Action: verify(previous_result)
Observation: Error detected
Thought: Let me recalculate
Action: multiply(15, 8)  # Try again

Meta-Reasoning

Thought: I've used 5 iterations, I should finish soon
Action: summarize_progress()
Observation: Still need to add final numbers
Thought: One more step should do it

Dynamic Tool Selection

Thought: This is a division problem
Action: divide(10, 2)  # Chooses right tool

Thought: Now I need to add
Action: add(5, 3)  # Switches tools

Research Origins

ReAct was introduced in:

"ReAct: Synergizing Reasoning and Acting in Language Models"
Yao et al., 2022
Paper: https://arxiv.org/abs/2210.03629

Key insight: Combining reasoning traces with task-specific actions creates more powerful agents than either alone.

Modern Frameworks Using ReAct

1. LangChain - AgentExecutor with ReAct
2. AutoGPT - Autonomous task execution
3. BabyAGI - Task management system
4. GPT Engineer - Code generation
5. ChatGPT Plugins - Tool-using chatbots

Why Learn This Pattern?

1. Foundation of Modern Agents

Nearly all production agent systems use ReAct or similar patterns.

2. Understandable AI

Unlike black-box models, you see exactly what's happening.

3. Extendable

Easy to add new tools and capabilities.

4. Debuggable

When things go wrong, you can see where and why.

5. Production-Ready

This pattern scales from demos to real applications.

Summary

ReAct transforms LLMs from:

• Brittle calculators → Reliable problem solvers
• Black boxes → Transparent reasoners
• Single-shot answerers → Iterative thinkers
• Isolated models → Tool-using agents

It's the bridge between language models and autonomous agents that can actually accomplish complex tasks reliably.

If the tool registry grows large, you can pre-filter which tools appear in each ReAct iteration (for example with embedding similarity over exemplar phrases); see Example 15: tool routing with embeddings.