Gen AI

ReAct Pattern

ReAct combines Reasoning (thinking aloud) and Acting (using tools). The LLM thinks about what to do, takes an action, observes the result, and thinks again. It is the core loop of autonomous agents.

The ReAct loop forces the LLM to output a Thought, followed by an Action. The environment returns an Observation, triggering the next Thought.

Why Does This Exist?

Prior to 2022, Large Language Models were separated into two distinct categories of research:

Reasoning: Using techniques like Chain of Thought (CoT) to solve math and logic problems.
Acting: Training models to play text-based games or navigate web browsers by outputting commands (like move_forward or click_button).

The breakthrough of the ReAct (Reason + Act) paper was combining these two domains. If an LLM just acts without reasoning, it clicks randomly and fails. If an LLM just reasons without acting, it cannot fetch real-time information or affect the outside world.

ReAct interleaves reasoning and acting. By forcing the LLM to "think out loud" before it takes an action, the LLM creates an actionable plan, executes it, and then evaluates the result. This simple loop is the foundational architecture for almost all modern AI agents (including Agentic RAG systems).

Think of It Like This

Cooking in a new kitchen

Acting Only: You walk into the kitchen, open a random drawer, pull out a whisk, turn on the oven, and grab an egg. Chaos ensues.

Reasoning Only: You sit at the kitchen table and write a brilliant, detailed plan for baking a cake. But you never actually stand up to bake it.

ReAct (Reason + Act): (Thought) "I want to bake a cake. First, I need to see if I have flour." (Action) Open pantry. (Observation) I see sugar and baking soda, but no flour. (Thought) "I cannot bake a cake without flour. I need to go to the store." (Action) Leave house.

You are constantly evaluating the environment and adjusting your plan.

How It Actually Works

Implementing ReAct requires a specific prompt structure and a Python execution loop (the "orchestrator").

1. The Prompt (The Rules of the Game)

The system prompt defines the tools available to the LLM and strictly enforces the formatting of the output. The LLM is instructed to output exactly one Thought: followed by one Action:.

1You are a helpful AI assistant. You have access to the following tools:2- Wikipedia(query): Searches Wikipedia and returns a summary.3- Calculator(expression): Evaluates a math expression.4
5Use the following format:6Question: the input question you must answer7Thought: you should always think about what to do8Action: the action to take, should be one of [Wikipedia, Calculator]9Action Input: the input to the action10Observation: the result of the action11... (this Thought/Action/Observation can repeat N times)12Thought: I now know the final answer13Final Answer: the final answer to the original input question

2. The Orchestrator Loop

The LLM generates text. As soon as it generates the Action: and Action Input: lines, the Python orchestrator stops the LLM.

The orchestrator reads the action (e.g., Calculator(5 * 8)), executes the Python code for that tool, and gets the result (40).

The orchestrator appends Observation: 40 to the text and sends the whole block back to the LLM. The LLM reads the observation, generates its next Thought:, and the loop continues until the LLM outputs Final Answer:.

Show Me the Code

This is a conceptual, simplified version of a ReAct orchestrator loop. Libraries like LangChain handle this parsing automatically, but seeing the raw loop is instructive.

1import openai2import re3
4def execute_tool(action, action_input):5    print(f"  [Executing Tool]: {action} with input: '{action_input}'")6    if action == "WeatherAPI":7        if "Seattle" in action_input:8            return "65 degrees and raining."9        return "72 degrees and sunny."10    return "Tool not found."11
12def react_loop(question, max_iterations=3):13    system_prompt = """14    You can use the tool: WeatherAPI(city).15    You must format your response exactly as:16    Thought: <your thought>17    Action: <tool name>18    Action Input: <input>19    """20    21    # We maintain a running log of the conversation (the "scratchpad")22    conversation = [23        {"role": "system", "content": system_prompt},24        {"role": "user", "content": question}25    ]26    27    print(f"Question: {question}\n")28    29    for i in range(max_iterations):30        # 1. Call the LLM to get the next Thought + Action31        response = openai.chat.completions.create(32            model="gpt-4o",33            messages=conversation,34            stop=["Observation:"] # VERY IMPORTANT: Stop generation before it hallucinates the observation!35        )36        37        llm_output = response.choices[0].message.content38        print(llm_output)39        40        # Add the LLM's thought/action to the conversation history41        conversation.append({"role": "assistant", "content": llm_output})42        43        # 2. Check if the LLM reached the final answer44        if "Final Answer:" in llm_output:45            return46            47        # 3. Parse the action and execute it48        action_match = re.search(r'Action:\s*(.*)', llm_output)49        input_match = re.search(r'Action Input:\s*(.*)', llm_output)50        51        if action_match and input_match:52            action = action_match.group(1).strip()53            action_input = input_match.group(1).strip()54            55            # Execute the python tool56            observation = execute_tool(action, action_input)57            print(f"Observation: {observation}\n")58            59            # Add the observation back to the conversation as if the user said it60            conversation.append({"role": "user", "content": f"Observation: {observation}"})61        else:62            print("Error parsing action. Exiting loop.")63            break64
65# --- Execution ---66react_loop("What should I wear in Seattle today?")67
68# -> Question: What should I wear in Seattle today?69# -> 70# -> Thought: I need to find the current weather in Seattle to recommend clothing.71# -> Action: WeatherAPI72# -> Action Input: Seattle73# ->   [Executing Tool]: WeatherAPI with input: 'Seattle'74# -> Observation: 65 degrees and raining.75# -> 76# -> Thought: It is raining and mild. A raincoat and layers are appropriate.77# -> Final Answer: You should wear a raincoat and carry an umbrella since it's 65 degrees and raining.

Watch Out For

The Parsing Nightmare

If you build a ReAct loop from scratch, you will quickly discover that LLMs constantly disobey formatting instructions. They will output Action: [WeatherAPI] (Seattle) instead of Action: WeatherAPI, crashing your regex parser. Modern agent frameworks rely heavily on strict JSON schemas or OpenAI's native Tool Calling API rather than pure text parsing to solve this fragility.

The Quick Version

ReAct combines "Chain of Thought" reasoning with environmental "Actions".
The LLM is placed inside a while loop orchestrated by Python code.
The LLM outputs a Thought and an Action.
The Python code halts the LLM, executes the requested tool (like a DB search or API call), and hands the result back to the LLM as an Observation.
The LLM repeats this loop until it has enough information to output the Final Answer.