Agent Architectures: ReAct, Planning, and Reasoning Patterns

Overview

A master architect doesn't just follow blueprints—they understand the structural principles that make buildings stable, functional, and beautiful. Similarly, AI agent architectures are not just code patterns but fundamental approaches to organizing perception, reasoning, and action that determine how intelligently an agent can behave.

In this lesson, we'll explore the key architectural patterns that have emerged in AI agents, from the elegant simplicity of ReAct (Reasoning + Acting) to sophisticated multi-layer systems that can handle complex, multi-step reasoning and planning.

Learning Objectives

After completing this lesson, you will be able to:

• Understand and implement the ReAct (Reasoning + Acting) pattern
• Design Plan-and-Execute architectures for complex tasks
• Compare different reasoning patterns and choose appropriate ones for specific use cases
• Implement reflection and self-correction mechanisms in agents
• Build agents that can decompose complex goals into manageable subtasks

The ReAct Architecture: Thinking and Acting in Harmony

The Power of Interleaving Thought and Action

Traditional approaches either think completely before acting (planning) or act without thinking (reactive). ReAct revolutionizes this by interleaving reasoning and acting—thinking a bit, acting a bit, observing the results, then thinking some more.

Analogy: Think of a skilled detective solving a case. They don't plan every step in advance, nor do they act randomly. Instead, they:

1. Think: "Based on the evidence, the suspect might be at the coffee shop"
2. Act: Go to the coffee shop and ask questions
3. Observe: "The barista says they haven't seen the suspect, but mentions they often go to the library"
4. Think: "Let me check the library next"
5. Act: Head to the library...

This iterative process allows for adaptive problem-solving that pure planning or pure reaction cannot achieve.

Architecture Pattern Comparison

Reactive Pattern (Stimulus-Response):

Deliberative Pattern (Plan-Execute):

ReAct Pattern (Think-Act-Observe):

Hybrid Pattern (Multi-Layer):

Interactive ReAct Demonstration

Plan-and-Execute Implementation

Copy
# Plan-and-Execute Agent
class PlanAndExecuteAgent:
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = tools
    
    def solve(self, task: str) -> str:
        # Phase 1: Planning
        plan = self.create_plan(task)
        
        # Phase 2: Execution
        results = []
        for step in plan:
            result = self.execute_step(step, results)
            results.append(result)
            
            # Check if we need to replan
            if self.should_replan(step, result):
                plan = self.replan(task, results, plan)
        
        return self.synthesize_results(results)
    
    def create_plan(self, task: str) -> List[str]:
        """Create a detailed plan for the task"""
        prompt = f"""
Break down this task into specific, actionable steps:
Task: {task}

Provide a numbered list of steps that can be executed sequentially.
Each step should be clear, specific, and achievable.
Consider dependencies between steps.

Plan:"""
        
        response = self.llm.complete(prompt)
        # Parse the response into individual steps
        steps = [line.strip() for line in response.split('\n') 
                if line.strip() and line.strip()[0].isdigit()]
        return steps
    
    def execute_step(self, step: str, previous_results: List[str]) -> str:
        """Execute a single step of the plan"""
        context = "\n".join(previous_results) if previous_results else ""
        
        prompt = f"""
Previous context:
{context}

Execute this step: {step}

Based on the available tools {list(self.tools.keys())}, 
determine what action to take and execute it.

Result:"""
        
        return self.llm.complete(prompt)
    
    def should_replan(self, step: str, result: str) -> bool:
        """Determine if replanning is needed based on step result"""
        prompt = f"""
Step: {step}
Result: {result}

Did this step succeed? Answer with just "SUCCESS" or "FAILURE".
"""
        response = self.llm.complete(prompt).strip().upper()
        return "FAILURE" in response
    
    def replan(self, original_task: str, completed_results: List[str], 
               remaining_plan: List[str]) -> List[str]:
        """Create a new plan given partial completion"""
        context = "\n".join(completed_results)
        remaining = "\n".join(remaining_plan)
        
        prompt = f"""
Original task: {original_task}
Completed so far: {context}
Remaining plan: {remaining}

Given what has been completed and any failures, create a new plan 
for the remaining work.

New Plan:"""
        
        response = self.llm.complete(prompt)
        return [line.strip() for line in response.split('\n') 
                if line.strip() and line.strip()[0].isdigit()]
    
    def synthesize_results(self, results: List[str]) -> str:
        """Combine all results into a final answer"""
        combined = "\n".join(results)
        
        prompt = f"""
Synthesize these step results into a final answer:
{combined}

Final Answer:"""
        
        return self.llm.complete(prompt)

# Usage Example
agent = PlanAndExecuteAgent(llm, tools)
result = agent.solve("Research and write a summary of renewable energy trends")
print(result)

Hybrid Architectures: Multi-Layer Intelligence

Combining the Best of All Worlds

Hybrid architectures combine multiple approaches in a layered system where different layers handle different types of reasoning and response.

Analogy: Think of a skilled emergency room doctor who operates on multiple levels:

• Reflexive layer: Immediate life-saving responses (check airways, stop bleeding)
• Diagnostic layer: Systematic analysis and planning (run tests, analyze symptoms)
• Strategic layer: Long-term treatment planning (recovery plan, follow-up care)

Multi-Layer Architecture

Interactive Architecture Explorer

Self-Correction and Reflection

Choosing the Right Architecture

Architecture Selection Guide

Performance Comparison

Summary and Next Steps

Key Architecture Principles

1. Match Pattern to Problem: Reactive for speed, Plan-Execute for complexity, ReAct for adaptability
2. Layer When Needed: Hybrid architectures handle diverse requirements
3. Enable Self-Correction: All patterns benefit from reflection and revision
4. Consider Trade-offs: Speed vs. quality vs. adaptability

Architecture Evolution Path

In our next lesson, we'll explore tool integration—the mechanisms that allow agents to extend their capabilities through external APIs, databases, and services. This is where agents truly become powerful by leveraging the vast ecosystem of available tools and services.

Practice Exercises

1. Pattern Implementation: Implement each architecture pattern with a simple example
2. Performance Testing: Compare response times and quality across patterns
3. Hybrid Design: Design a hybrid system for a specific use case
4. Self-Evaluation: Add reflection capabilities to any architecture

Additional Resources

• Tree of Thoughts Paper
• ReAct: Reasoning and Acting
• LangChain Agent Types
• AutoGen Multi-Agent Patterns