ReAct paradigm

Deep Dive into the ReAct Paradigm: From Theory to LangGraph in Practice

Honghao Wang

— 3 min read
Deep Dive into the ReAct Paradigm: From Theory to LangGraph in Practice

Introduction

In developing an intelligent solution system, a key challenge emerged: how to enable AI to maintain strong reasoning abilities while executing actions in complex tasks.

Traditional AI systems typically rely solely on model reasoning with static training data or fixed workflows — both lacking dynamic decision-making capability.

The ReAct (Reasoning + Acting) paradigm solves this problem by alternating between analytical reasoning and active execution in a think → act → observe → adjust loop.

This article introduces ReAct’s principles, shows how it’s implemented in LangGraph, and demonstrates — with a real project — how it delivers real-world value.

---

1. Principles of the ReAct Paradigm

1.1 Concept

Proposed by Shunyu Yao et al. in 2022 (ReAct: Synergizing Reasoning and Acting in Language Models), the paradigm alternates reasoning and acting rather than relying purely on one or the other.

Example: Weather Query

# Traditional AI: Pure reasoning or pure action

def reasoning_only(q):
    return "Based on training data, it's probably sunny today"

def action_only(q):
    if "weather" in q:
        return "Sunny, 25°C"  # Hard-coded
    return "No result"

# ReAct: Alternate reasoning and action
def react_method(q):
    # 1 Reason
    reasoning = "Need real-time weather data"
    # 2 Act
    weather = weather_api("SomeCity")
    # 3 Reason
    reasoning = f"Weather API says: {weather}"
    # 4 Act (final output)
    return "Sunny, 25°C, perfect for going out."

Why it works:

ReAct enables active info retrieval, adapts based on intermediate results, maintains transparent reasoning, and supports multi-tool collaboration.

---

1.2 Why It Works

  • Solves information limits – Retrieves live data beyond static training sets
  • Alternating loop ensures adaptive strategy changes
  • Transparent – Each action backed by visible reasoning
  • Collaboration – Invokes multiple tools (API, DB, external services)

---

1.3 Philosophy Shift

From black-box AI → transparent AI

From static AI → dynamic AI

From isolated AI → collaborative AI

Practical workflows can integrate ReAct with cross-platform execution, such as AiToEarn — an open-source AI content monetization platform that generates, publishes, and tracks AI content across Douyin, Kwai, WeChat, Bilibili, Xiaohongshu, Facebook, Instagram, LinkedIn, Threads, YouTube, Pinterest, X/Twitter.

---

2. LangGraph’s ReAct Implementation

2.1 What is LangGraph?

LangGraph is a LangChain framework for building agents as directed graphs.

image

Features:

  • Graph structure – Nodes + edges
  • State-driven – Operates around a typed state object
  • Conditional routing – Chooses execution path according to state

---

2.2 Example Implementation

from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool
from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage

# Tools
@tool
def search_weather(loc: str) -> str: ...
@tool
def calculate_distance(c1: str, c2: str) -> str: ...

# Model
model = ChatOllama(model="qwen3:8b", temperature=0.1)

# Agent
agent = create_react_agent(
    model=model,
    tools=[search_weather, calculate_distance],
    prompt="You are a weather assistant...",
    version="v2"
)

Run:

result = agent.invoke({
    "messages": [HumanMessage(content="Weather in City A/B and distance?")]
})

Result: Automatic tool calls, state maintenance, transparent reasoning.

---

2.3 Internals

Core function `create_react_agent`:

  • State definition with TypedDict for messages & remaining steps
  • Nodes: agent_node (model reasoning), tools_node (tool exec)
  • Conditional routing: decides next step (`tools` or `end`)
  • Graph assembly → compile workflow

---

2.4 Design Ideas

  • State-driven → flexible control flow
  • Separation of concerns → nodes for reasoning vs. action
  • Conditional routing → adaptive loops
  • Visualizable graph workflow → easier maintenance/debug
  • Hooks/extensibility → pre/post model calls, custom state

---

4. Real Project — Smart Outline Agent

Background: Intelligent PPT outline generator needed dynamic adaptation.

Pure LLM (Phase 1)

Problems: Inaccurate info, outdated data, user request mismatch.

Retrieval Added (Phase 2)

Problems: Overload, fixed output, poor UX.

ReAct (Phase 3)

Solution: Analyze user intent → selective retrieval → adaptive generation.

---

Architecture

image
  • Decision Layer – Interpret need
  • On-Demand Retrieval Layer – Fetch relevant info only
  • Adaptive Generation Layer – Tailored output

---

5. Manual ReAct Agent

Minimal implementation example:

class MiniReActAgent:
    def __init__(self):
        self.model = ChatOllama(model="qwen3:8b", temperature=0.1)
        self.tools = {"time": self._get_time, "calc": self._calculate}

    def should_continue(self, state): ...
    def agent_node(self, state): ...
    def tools_node(self, state): ...
    def react_cycle(self, question): ...

Usage:

agent.react_cycle("What time is it?")
agent.react_cycle("15 + 27")

Demonstrates reason → act → observe → adapt loop.

---

6. Key Lessons

  • Transparency > “smarts”
  • Tool quality defines system capability
  • State management is core
  • Start small, expand gradually
  • Iterative prompt engineering
  • Architectural performance optimization
  • Pragmatic technology choice

---

References

---

Tip for Deployment:

Connect your ReAct agent to an execution/publishing pipeline for multi-platform reach and monetization.

Platforms like AiToEarn make it possible to generate AI content → publish everywhere → track & monetize, complementing the ReAct paradigm in production systems.

Read more