Yao 2022 React

---
license: Apache-2.0
name: yao-2022-react
description: Prompting paradigm combining reasoning traces with actions for LLM agents to interact with external tools
category: Research & Academic
tags:
  - react-prompting
  - reasoning
  - acting
  - llm-agents
  - tool-use
---

# ReAct: Reasoning-Action Synergy

## When to Use This Skill

Load this skill when addressing agent architecture design, debugging agent failures, designing information retrieval strategies, or making agent decision-making interpretable to humans.

## Decision Points

### 1. Knowledge Source Selection
```
IF agent expresses uncertainty (hedges, "I'm not sure", "might be")
   → THEN trigger external action (search, API call, retrieval)
IF agent states facts with high confidence AND domain is within training
   → THEN allow internal reasoning to continue
IF previous action returned "not found" or empty results
   → THEN reason about query reformulation strategy
IF factual accuracy is mission-critical (medical, legal, financial)
   → THEN default to external grounding regardless of confidence
```

### 2. Reasoning Density Control
```
IF task requires strategic planning or goal decomposition
   → THEN insert sparse, high-level thoughts at decision points
IF simple execution with known action sequence
   → THEN skip reasoning, execute actions directly
IF debugging failure or exception handling needed
   → THEN add reasoning trace to expose decision logic
IF token budget is constrained
   → THEN limit thoughts to: goal decomposition, search reformulation, exception handling
```

### 3. Failure Recovery Strategy
```
IF action returns unexpected result or error
   → THEN add thought analyzing what went wrong + corrective strategy
IF agent enters repetitive loop (same action 3+ times)
   → THEN force reasoning step: "Why am I stuck? What should I try instead?"
IF search returns empty/irrelevant results
   → THEN reason about query reformulation before next search
IF hallucinated information detected
   → THEN immediately insert retrieval action to verify facts
```

### 4. Multi-Step Task Orchestration
```
IF complex task with 4+ subtasks
   → THEN start with thought decomposing into subgoals
IF current subtask complete
   → THEN add thought tracking progress: "Done with X, now need Y"
IF environment state changed unexpectedly
   → THEN reason about how this affects remaining plan
IF stuck on subtask for 3+ actions
   → THEN reason about alternative approaches or skipping
```

## Failure Modes

### 1. **Reasoning Without Grounding** (Hallucination Spiral)
**Symptoms**: Agent confidently states facts, builds elaborate reasoning chains, but information is fabricated
**Detection Rule**: IF reasoning contains specific facts not verifiable through actions AND no recent external grounding
**Fix**: Insert retrieval actions at uncertainty points; verify facts before building on them

### 2. **Dense Narration Overhead** (Token Waste)
**Symptoms**: Thought at every step describing obvious actions or restating observations
**Detection Rule**: IF >60% of tokens are reasoning AND thoughts don't contain strategic decisions
**Fix**: Limit thoughts to: goal decomposition, search reformulation, exception handling, progress tracking

### 3. **Action Tunneling** (No Strategic Planning)
**Symptoms**: Agent immediately starts acting without decomposing complex tasks, gets stuck or inefficient
**Detection Rule**: IF complex multi-step task AND first action is attempted execution (not planning)
**Fix**: Force initial thought decomposing goal into subgoals and strategy

### 4. **Loop Trap** (Repetitive Failure)
**Symptoms**: Same action repeated 3+ times with same failure result, no learning from feedback
**Detection Rule**: IF identical action-observation pair occurs 3 consecutive times
**Fix**: Insert reasoning step analyzing why approach isn't working + alternative strategy

### 5. **Search Strategy Blindness** (Query Reformulation Failure)
**Symptoms**: Empty search results followed by identical or minimally different queries
**Detection Rule**: IF search returns "not found" AND next search query has >80% word overlap
**Fix**: Add explicit reasoning about why search failed + systematic query reformulation strategy

## Worked Examples

### Example 1: QA Task with Strategic Information Gathering
**Task**: "What is the elevation of the birthplace of the director of the movie 'Inception'?"

**Expert Trajectory**:
```
Thought 1: This requires finding: (1) director of Inception, (2) director's birthplace, (3) elevation of that place. Let me start with the director.
Action 1: Search[Inception movie director]
Observation 1: Christopher Nolan directed Inception (2010)...
Thought 2: Got it - Christopher Nolan. Now I need his birthplace.
Action 2: Search[Christopher Nolan birthplace]
Observation 2: Christopher Nolan was born in Westminster, London, England
Thought 3: Now I need the elevation of Westminster, London. This might be tricky since it's a district.
Action 3: Search[Westminster London elevation above sea level]
Observation 3: Westminster, London is approximately 24 meters (79 feet) above sea level
Thought 4: Found it. The elevation is 24 meters or 79 feet.
```

**Novice Mistakes**: Would search "Inception director birthplace elevation" immediately, get confused results mixing multiple concepts. Expert decomposes systematically and verifies each fact before building on it.

### Example 2: Error Recovery with Trade-off Analysis
**Task**: "Put a clean knife in the countertop" (ALFWorld navigation)

**Expert Recovery Trajectory**:
```
Action 1: take knife 1
Observation 1: You pick up the knife 1
Action 2: clean knife 1 with sinkbasin 1
Observation 2: Nothing happens.
Thought 1: Cleaning failed. I'm probably not at the right location. I need to navigate to the sinkbasin first, then clean the knife.
Action 3: go to sinkbasin 1
Observation 3: On the sinkbasin 1, you see a dishsponge 1, and a lettuce 1.
Action 4: clean knife 1 with sinkbasin 1
Observation 4: You clean the knife 1 using the sinkbasin 1.
Thought 2: Great! Now I have a clean knife. I need to find a countertop to place it on.
```

**Key Decision**: Expert recognizes failed action immediately, reasons about spatial requirements, adjusts strategy. Shows how external feedback corrects internal assumptions.

### Example 3: Multi-hop Reasoning with Confidence Monitoring
**Task**: "Were Scott Derrickson and Ed Wood of the same nationality?"

**Expert Trajectory**:
```
Thought 1: I need to find the nationality of both Scott Derrickson and Ed Wood, then compare them.
Action 1: Search[Scott Derrickson nationality]
Observation 1: Scott Derrickson is an American film director and screenwriter...
Thought 2: Scott Derrickson is American. Now I need Ed Wood's nationality.
Action 2: Search[Ed Wood nationality filmmaker]
Observation 2: Edward Davis Wood Jr. was an American filmmaker...
Thought 3: Ed Wood was also American. Both are American, so yes, they were the same nationality.
```

**Confidence Signal**: Expert searches for both facts despite potentially "knowing" Ed Wood is American, ensuring verification rather than risking hallucination.

## Quality Gates

- [ ] Each reasoning step addresses a specific decision point (goal decomposition, search reformulation, exception handling)
- [ ] Uncertain facts are verified through external actions before being used in subsequent reasoning
- [ ] Failed actions trigger corrective reasoning that analyzes root cause and alternative strategies
- [ ] Multi-step tasks begin with explicit goal decomposition into subgoals
- [ ] Search queries are reformulated when previous searches return empty/irrelevant results
- [ ] Reasoning traces are sparse (≤40% of total tokens) and strategic rather than descriptive
- [ ] Repetitive action loops are broken by reasoning steps that analyze why the approach isn't working
- [ ] External grounding occurs at least once every 3-4 reasoning steps for factual claims
- [ ] Complex tasks show clear progress tracking between subgoals in reasoning traces
- [ ] Final answer is directly supported by observable evidence from actions, not just internal reasoning

## NOT-FOR Boundaries

**Do NOT use ReAct for**:
- Simple, single-step tasks where immediate action is sufficient → Use direct action execution instead
- Creative writing or open-ended generation where grounding constrains desired output → Use pure chain-of-thought instead
- Highly structured API interactions with predetermined workflows → Use programmatic workflows instead
- Real-time systems where reasoning latency is prohibitive → Use learned policies or reactive systems instead
- Tasks requiring extensive mathematical computation → Use specialized math tools with minimal reasoning overhead instead

**Delegate to other skills when**:
- Task needs mathematical reasoning: Use `mathematical-reasoning-strategies` 
- Task is pure information synthesis: Use `chain-of-thought-reasoning`
- Task needs code generation: Use `code-generation-workflows`
- Task requires creative ideation: Use `creative-generation-techniques`