LLM Reasoning Strategies: ReAct vs Multi-Step

Date: 2024-12-21 Topic: Comparing reasoning approaches for complex LLM tasks

Background

Today I explored different reasoning strategies for LLM applications: ReAct (Reasoning and Acting) and multi-step reasoning. Both are useful for complex tasks but suit different scenarios.

ReAct: Reasoning + Acting

ReAct interleaves thinking with action in a loop:

Thought: Analyze current situation
Action: Execute an operation
Observation: Get result
Repeat: Continue based on observation

def react_reasoning(question: str, context: str) -> str:
    prompt = """
    Based on the following information, use ReAct to think step by step.
    Each step should include:
    1. Thought: Analyze the current situation
    2. Action: Determine the next action
    3. Result: Record the action result

    Context: {context}
    Question: {question}

    Let's think step by step:
    """

    response = llm.chat(prompt.format(context=context, question=question))
    return response

Multi-Step Reasoning

Break complex problems into sequential subtasks:

class MultiStepReasoning:
    async def multi_step_analysis(self, question, context, steps):
        results = {}
        accumulated_context = context

        for step in steps:
            step_result = await self.step_reasoning(
                step["prompt"],
                accumulated_context
            )
            results[step["name"]] = step_result
            accumulated_context += f"\n{step['name']}: {step_result}"

        return results

# Usage
steps = [
    {"name": "trend_analysis", "prompt": "Analyze growth trends"},
    {"name": "risk_assessment", "prompt": "Assess risk factors"},
    {"name": "recommendation", "prompt": "Provide recommendations"}
]

When to Use Each

ReAct is better when:

Tasks require dynamic decision-making
The next step depends on previous results
Tool selection varies based on findings

Multi-step is better when:

Steps are known in advance
Tasks can be cleanly decomposed
Parallel processing is possible

Example: Financial Analysis

ReAct approach:

Thought 1: First analyze revenue growth trend
Action 1: Calculate annual growth rates
Result 1: 50% (2022), 20% (2023) - slowing

Thought 2: Need to understand why growth is slowing
Action 2: Check market conditions
Result 2: Market saturation in core segment

Thought 3: Evaluate diversification options
Action 3: Analyze competitor strategies
...

Multi-step approach:

Step 1: Revenue analysis → Growth metrics
Step 2: Profitability analysis → Margin trends
Step 3: Risk assessment → Risk factors
Step 4: Recommendation → Investment advice

Hybrid Approach

For complex analysis, combine both:

async def analyze_report(self, content: str):
    # Phase 1: ReAct for structure discovery
    structure = await self.react_reasoning(
        "Analyze overall structure and key points",
        content
    )

    # Phase 2: Multi-step for detailed analysis
    details = await self.multi_step_analysis(
        "Deep analysis",
        structure,
        [
            {"name": "market", "prompt": "Market analysis"},
            {"name": "financial", "prompt": "Financial analysis"},
            {"name": "strategy", "prompt": "Strategic recommendations"}
        ]
    )

    return {"structure": structure, "details": details}

Today's Reflection

The choice between ReAct and multi-step isn't binary. ReAct shines when you don't know what you'll find - it adapts to discoveries. Multi-step is efficient when the path is clear.

In practice, I've found that starting with multi-step and adding ReAct for uncertain branches works well. Define the main steps, but allow the LLM to reason dynamically within each step if needed.

The key insight: ReAct adds latency (multiple LLM calls) but improves accuracy for complex reasoning. For straightforward tasks, the overhead isn't worth it.

Further Learning

Chain-of-Thought prompting
Tree-of-Thought reasoning
Tool-use in LLMs
Agentic frameworks (LangGraph, CrewAI)

FilesExpand file tree

33.md

Latest commit

History