ReAct and Plan-and-Execute Agents
Understand and implement advanced agent architectures that combine reasoning and action for complex task completion.
ReAct and Plan-and-Execute Agents is a free AI Agents with LangChain & Autonomous Workflows lesson on CoddyKit — lesson 1 of 6. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the AI Agents with LangChain & Autonomous Workflows learning path, one of 6 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Beyond Simple AI Agents
Welcome to Advanced Agent Architectures! So far, you've learned about basic agents and chains in LangChain. These are great for straightforward tasks.
However, real-world problems can be complex. They often require agents to reason, make decisions, and perform multiple steps to achieve a goal. This is where advanced architectures come in.
Introducing ReAct Agents
One powerful advanced architecture is ReAct, which stands for Reasoning and Acting. It's inspired by how humans solve problems.
- Reasoning: The agent thinks about the problem, current state, and what to do next.
- Acting: The agent then performs an action, often by using a tool.
This cycle allows agents to dynamically adapt and solve complex tasks.
The ReAct Loop: Thought, Action, Observation
ReAct agents operate in an iterative loop:
- Thought: The agent generates a thought, explaining its reasoning and what it plans to do.
- Action: Based on the thought, the agent chooses a tool and its input (e.g., 'search', 'calculator').
- Observation: The agent receives the result from the tool's execution.
This loop continues until the agent believes it has enough information to provide a final answer.
ReAct in Action: A Simple Flow
Let's see a simplified Python example of how a ReAct agent's logic might flow. Notice how it thinks, acts, and observes to reach a conclusion.
def run_react_agent(query):
print(f"User Query: {query}")
print("Thought: I need to find the population of London. I will use a search tool.")
print("Action: Use 'search_tool' with query 'population of London'")
# Simulate tool output
observation = "Observation: The population of London is ~9 million (2023 est.)."
print(observation)
print("Thought: I have the information. I can now answer the user.")
print("Action: Respond with the observed information.")
return observation.replace("Observation: ", "")
if __name__ == "__main__":
result = run_react_agent("What is the population of London?")
print(f"\nFinal Answer: {result}")Understanding Plan-and-Execute
Another powerful architecture is Plan-and-Execute. Unlike ReAct, which is more reactive, Plan-and-Execute agents first create a comprehensive plan.
They are particularly effective for tasks that are complex, multi-step, and where a clear sequence of actions can be determined upfront.
The Planner and Executor Components
Plan-and-Execute agents typically consist of two main parts:
- The Planner: This component takes the initial goal and breaks it down into a sequence of smaller, manageable steps. It focuses on strategy.
- The Executor: This component then takes each step from the plan and carries it out, often by using specific tools. It focuses on execution.
This separation helps manage complexity and ensures a structured approach.
Plan-and-Execute: A Structured Flow
Here's a simplified Python example illustrating the Plan-and-Execute flow. Notice how the goal is first planned, then each step is executed in order.
def planner(goal):
print(f"Goal: {goal}")
print("Planner: Breaking down the goal into steps...")
plan = [
"Step 1: Find today's date.",
"Step 2: Get the weather forecast for New York City for today.",
"Step 3: Summarize the date and weather information."
]
print(f"Plan created: {plan}")
return plan
def executor(step):
print(f"Executing: {step}")
if "date" in step:
return "Observation: Today's date is October 26, 2023."
elif "weather" in step:
return "Observation: New York weather: Sunny, 60°F."
elif "summarize" in step:
return "Observation: Summary: Oct 26, 2023, NYC is Sunny, 60°F."
return "Observation: Step completed."
if __name__ == "__main__":
my_goal = "Tell me today's date and weather in New York City."
plan_steps = planner(my_goal)
print("\n--- Execution Phase ---")
for step in plan_steps:
res = executor(step)
print(res)ReAct vs. Plan-and-Execute
Both are powerful, but suited for different scenarios:
- ReAct: More dynamic and reactive. Best for tasks where the path isn't clear upfront, requiring exploration and iterative decision-making (e.g., complex research questions).
- Plan-and-Execute: More structured and systematic. Best for tasks where a clear sequence of steps can be defined (e.g., booking a flight with known steps: search, select, confirm).
Choosing the Right Architecture
When deciding between ReAct and Plan-and-Execute, consider:
- Task Complexity: Is it a clear, sequential task (Plan-and-Execute) or an exploratory, problem-solving one (ReAct)?
- Predictability: Can you easily predict the steps needed (Plan-and-Execute) or will the agent need to adapt dynamically (ReAct)?
- Error Handling: Plan-and-Execute can sometimes be easier to debug due to defined steps, while ReAct's dynamic nature can be harder to trace.
Quick Check: Agent Architectures
An AI agent needs to solve a complex, multi-step problem where the exact sequence of actions is not known beforehand, and it might need to explore different options and react to intermediate results.
Recap: Advanced Agent Architectures
Great job! In this lesson, you explored two advanced agent architectures:
- ReAct (Reasoning and Acting): Agents that iteratively think, act, and observe, suitable for dynamic, exploratory tasks.
- Plan-and-Execute: Agents that first create a detailed plan and then execute each step, ideal for structured, multi-step workflows.
Understanding these patterns helps you build more robust and intelligent AI agents for complex challenges. Next, we'll look at agents that can self-correct!
Frequently asked questions
Is the “ReAct and Plan-and-Execute Agents” lesson free?
Yes — the full text of “ReAct and Plan-and-Execute Agents” is free to read here on the web, and the AI Agents with LangChain & Autonomous Workflows course includes 6 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the AI Agents with LangChain & Autonomous Workflows course, upgrade to CoddyKit PRO.
What will I learn in “ReAct and Plan-and-Execute Agents”?
Understand and implement advanced agent architectures that combine reasoning and action for complex task completion. You practise AI Agents with LangChain & Autonomous Workflows with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start AI Agents with LangChain & Autonomous Workflows?
No prior experience is required. AI Agents with LangChain & Autonomous Workflows on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 6, so you can start here or from the beginning and move at your own pace.
How long does the “ReAct and Plan-and-Execute Agents” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this AI Agents with LangChain & Autonomous Workflows lesson?
Yes. Every AI Agents with LangChain & Autonomous Workflows lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.