Skip to content

Session 0 - Module B: Advanced Pattern Theory (25 minutes)

Prerequisites: Session 0 Core Section Complete
Target Audience: Developers wanting deeper pattern understanding
Cognitive Load: 4 advanced concepts

Module Overview

This module dives deep into the technical implementation strategies behind the five core agentic patterns, explores how patterns combine for sophisticated behaviors, and examines emerging patterns being developed beyond the foundational five.

Learning Objectives

By the end of this module, you will: - Understand how each agentic pattern is technically implemented across different frameworks - Recognize how patterns combine to create sophisticated agent behaviors - Identify emerging patterns being developed beyond the core five - Make informed decisions about pattern selection and combination strategies

Part 1: Pattern Implementation Strategies (10 minutes)

Framework-Specific Pattern Implementations

Each framework implements the core patterns differently, with trade-offs in complexity, performance, and flexibility:

Reflection Pattern Implementations

Bare Metal Python Approach:

The simplest approach implements reflection manually with basic iteration control. This gives you full control over the reflection process but requires handling all the logic yourself.

class BareMetalReflectionAgent:
    def reflect_and_improve(self, initial_response: str, task: str) -> str:
        """Manual implementation of reflection loop"""
        max_iterations = 3
        current_response = initial_response

The core loop iterates up to a maximum number of times to prevent infinite reflection. Each iteration has three phases: critique generation, satisfaction checking, and response improvement.

        for iteration in range(max_iterations):
            # Generate critique
            critique_prompt = f"""
            Task: {task}
            Response: {current_response}

            Critique this response for accuracy, completeness, and clarity.
            Provide specific suggestions for improvement.
            """

            critique = self.llm.generate(critique_prompt)

The critique phase analyzes the current response against the original task, looking for areas of improvement. The prompt specifically asks for actionable suggestions rather than just identifying problems.

            # Check if satisfactory
            if "SATISFACTORY" in critique:
                break

            # Generate improved response
            improvement_prompt = f"""
            Original task: {task}
            Previous response: {current_response}
            Critique: {critique}

            Generate an improved response addressing the critique.
            """

            current_response = self.llm.generate(improvement_prompt)

        return current_response

If the critique indicates satisfaction, the loop terminates early. Otherwise, an improvement prompt incorporates the critique to generate a better response, which becomes the input for the next iteration.

LangChain Framework Approach:

LangChain provides structured components that handle prompt templating and chain orchestration, reducing boilerplate code and enabling more maintainable reflection systems.

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

class LangChainReflectionAgent:
    def __init__(self):
        # Critique chain
        self.critique_chain = LLMChain(
            llm=self.llm,
            prompt=PromptTemplate(
                template="Critique this response: {response}\nFor task: {task}",
                input_variables=["response", "task"]
            )
        )

The critique chain is defined once with a reusable template. LangChain handles variable substitution and prompt formatting automatically, reducing errors and improving consistency.

        # Improvement chain  
        self.improve_chain = LLMChain(
            llm=self.llm,
            prompt=PromptTemplate(
                template="Improve response based on critique:\nOriginal: {response}\nCritique: {critique}",
                input_variables=["response", "critique"]
            )
        )

The improvement chain similarly uses a template that clearly defines its inputs. This separation of concerns makes the system easier to debug and modify.

    def reflect_and_improve(self, response: str, task: str) -> str:
        """Framework-assisted reflection implementation"""
        critique = self.critique_chain.run(response=response, task=task)
        improved = self.improve_chain.run(response=response, critique=critique)
        return improved

The main method becomes much simpler, focusing on the high-level flow rather than prompt construction details. Each chain handles its own complexity internally.

PydanticAI Type-Safe Approach:

PydanticAI takes a different approach by enforcing type safety and structured outputs. This prevents common errors and makes agent behavior more predictable:

from pydantic import BaseModel
from typing import List, Literal

class CritiqueResult(BaseModel):
    accuracy_score: float
    completeness_score: float  
    clarity_score: float
    suggestions: List[str]
    overall_rating: Literal["poor", "fair", "good", "excellent"]

class ImprovedResponse(BaseModel):
    enhanced_content: str
    improvements_made: List[str]
    confidence_level: float

By defining structured models for critique and improvement results, the system ensures consistent output formats. This makes it easier to build reliable downstream systems that consume agent outputs.

class PydanticReflectionAgent:
    def reflect_and_improve(self, response: str, task: str) -> ImprovedResponse:
        """Type-safe reflection with structured outputs"""

        # Generate structured critique
        critique: CritiqueResult = self.critique_agent.run(
            f"Critique response: {response} for task: {task}"
        )

The agent first generates a structured critique using the defined CritiqueResult model, which provides scores and ratings rather than free-form text feedback.

        # Only improve if scores are below threshold
        if critique.overall_rating in ["poor", "fair"]:
            improved: ImprovedResponse = self.improvement_agent.run(
                f"Improve: {response}\nSuggestions: {critique.suggestions}"
            )
            return improved

Based on the structured ratings, the system makes intelligent decisions about whether improvement is needed, avoiding unnecessary processing when the response is already adequate.

        return ImprovedResponse(
            enhanced_content=response,
            improvements_made=[],
            confidence_level=0.95
        )

The type-safe approach enables intelligent decision-making based on structured scores rather than string parsing. The system only attempts improvement when the critique indicates it's necessary, avoiding unnecessary LLM calls.

Tool Use Pattern Implementations

Dynamic Tool Discovery:

Advanced tool agents go beyond static tool sets by intelligently selecting and learning from tool usage. This approach combines task analysis with historical performance data.

class AdvancedToolAgent:
    def __init__(self):
        self.tool_registry = ToolRegistry()
        self.tool_performance_tracker = ToolPerformanceTracker()

The system maintains both a registry of available tools and a performance tracker that learns which tools work best for different types of tasks.

    def select_optimal_tool(self, task_description: str) -> Tool:
        """Intelligent tool selection based on task analysis and historical performance"""

        # Analyze task requirements
        task_features = self.extract_task_features(task_description)

        # Get candidate tools
        candidate_tools = self.tool_registry.find_matching_tools(task_features)

Tool selection starts with understanding what the task requires, then finding tools with matching capabilities. This prevents trying inappropriate tools for the given task.

        # Rank by historical performance
        ranked_tools = self.tool_performance_tracker.rank_tools(
            tools=candidate_tools,
            task_features=task_features
        )

        return ranked_tools[0] if ranked_tools else None

Rather than random selection, the system ranks candidate tools by their historical success with similar tasks, continuously improving tool selection over time.

    def execute_with_fallback(self, tool: Tool, params: dict) -> dict:
        """Execute tool with automatic fallback to alternatives"""
        try:
            result = tool.execute(params)
            self.tool_performance_tracker.record_success(tool, params, result)
            return result

Successful tool executions are recorded to improve future selection. The system learns which tools work reliably for which types of parameters.

        except ToolExecutionError as e:
            # Try fallback tools
            fallback_tools = self.tool_registry.get_fallback_tools(tool)
            for fallback in fallback_tools:
                try:
                    result = fallback.execute(params)
                    self.tool_performance_tracker.record_fallback_success(fallback, params, result)
                    return result
                except ToolExecutionError:
                    continue

            # All tools failed
            self.tool_performance_tracker.record_failure(tool, params, e)
            raise e

When tools fail, the system automatically tries fallback alternatives. Both failures and successful fallbacks are tracked to improve the robustness of future tool selection.

Part 2: Pattern Combinations (8 minutes)

Sophisticated Pattern Orchestration

Real-world agents combine multiple patterns for sophisticated behaviors:

ReAct + Reflection Combination

Combining patterns creates sophisticated capabilities that exceed what each pattern can achieve individually. This example shows ReAct reasoning enhanced with quality assurance through reflection.

class ReActReflectionAgent:
    """Combines ReAct reasoning with reflection for robust problem solving"""

    def solve_complex_problem(self, problem: str) -> dict:
        """Multi-pattern problem solving with quality assurance"""

        # Phase 1: ReAct problem solving
        react_solution = self.react_solve(problem)

        # Phase 2: Reflection on solution quality
        solution_critique = self.reflect_on_solution(react_solution, problem)

The two-phase approach first uses ReAct to generate a solution through iterative reasoning and action, then applies reflection to evaluate the quality of that solution.

        # Phase 3: Iterative improvement
        if solution_critique.needs_improvement:
            improved_solution = self.improve_solution(
                original=react_solution,
                critique=solution_critique,
                problem=problem
            )
            return improved_solution

        return react_solution

Only if reflection identifies issues does the system engage in improvement. This prevents unnecessary refinement when the initial solution is already adequate.

    def react_solve(self, problem: str) -> dict:
        """ReAct pattern: iterative reasoning and acting"""
        solution_steps = []
        current_state = {"problem": problem, "progress": []}

        for step in range(self.max_react_steps):
            # Think
            thought = self.generate_thought(current_state)

            # Act
            action = self.decide_action(thought, current_state)
            observation = self.execute_action(action)

The ReAct implementation follows the classic think-act-observe cycle, building understanding through interaction rather than pure reasoning.

            # Update state
            current_state["progress"].append({
                "step": step,
                "thought": thought,
                "action": action,
                "observation": observation
            })

            # Check if problem is solved
            if self.is_problem_solved(current_state):
                break

        return {
            "solution": self.extract_solution(current_state),
            "reasoning_chain": current_state["progress"]
        }

Each step is recorded to provide transparency into the reasoning process, and the system checks for completion after each iteration to avoid unnecessary work.

Planning + Multi-Agent Coordination

This combination tackles complex workflows that require both strategic planning and coordinated execution across multiple specialized agents.

class PlanningCoordinationAgent:
    """Combines planning with multi-agent coordination for complex workflows"""

    def execute_collaborative_plan(self, high_level_goal: str) -> dict:
        """Create plan and coordinate multiple agents for execution"""

        # Phase 1: High-level planning
        master_plan = self.create_master_plan(high_level_goal)

        # Phase 2: Agent assignment and task delegation
        agent_assignments = self.assign_tasks_to_agents(master_plan)

        # Phase 3: Coordinated execution with dynamic re-planning
        results = self.coordinate_execution(agent_assignments)

The three-phase approach separates strategic planning from agent assignment and execution coordination. This separation enables specialization while maintaining overall coherence.

        return {
            "original_goal": high_level_goal,
            "plan": master_plan,
            "execution_results": results,
            "success_metrics": self.evaluate_success(results, high_level_goal)
        }

The return structure provides complete transparency into the planning and execution process, enabling post-analysis and continuous improvement of coordination strategies.

    def coordinate_execution(self, assignments: List[AgentAssignment]) -> dict:
        """Dynamic coordination with replanning capability"""
        execution_results = {}

        for phase in self.execution_phases:
            phase_agents = [a for a in assignments if a.phase == phase]

            # Parallel execution within phase
            phase_results = asyncio.gather(*[
                agent.execute_assignment(assignment)
                for agent, assignment in phase_agents
            ])

Execution is organized by phases, with agents working in parallel within each phase. This balances efficiency (parallel work) with coordination (sequential phases).

            # Check if replanning needed
            if self.requires_replanning(phase_results):
                updated_plan = self.replan_remaining_phases(
                    original_plan=self.master_plan,
                    completed_phases=[phase],
                    phase_results=phase_results
                )
                self.update_agent_assignments(updated_plan)

            execution_results[phase] = phase_results

        return execution_results

After each phase, the system evaluates whether the original plan is still viable. If not, it dynamically replans the remaining phases based on actual results, ensuring adaptability to changing conditions.

Pattern Synergy Effects

Compound Benefits of Pattern Combination:

  1. ReAct + Reflection: Robust reasoning with quality assurance
  2. Planning + Tool Use: Strategic tool deployment for complex workflows
  3. Multi-Agent + Reflection: Team learning and continuous improvement
  4. Tool Use + Planning: Dynamic tool selection based on strategic needs
  5. All Patterns: Sophisticated autonomous systems with full capabilities

Part 3: Emerging Patterns (7 minutes)

Next-Generation Agentic Patterns

Research and industry development are producing new patterns beyond the core five:

Constitutional AI Pattern

Constitutional AI ensures agents operate within defined ethical and safety boundaries. This pattern implements a two-phase approach: generation followed by constitutional checking and revision:

class ConstitutionalAgent:
    """Implements constitutional AI for ethical and safe agent behavior"""

    def __init__(self):
        self.constitution = self.load_constitutional_principles()
        self.violation_detector = ConstitutionalViolationDetector()

The constitution defines principles the agent must follow, such as avoiding harmful content, respecting privacy, or maintaining factual accuracy. The violation detector analyzes responses for principle violations.

    def constitutional_response(self, query: str) -> dict:
        """Generate response that adheres to constitutional principles"""

        # Generate initial response
        initial_response = self.base_agent.generate(query)

        # Check for constitutional violations
        violations = self.violation_detector.check_response(
            response=initial_response,
            constitution=self.constitution
        )

Every response is checked against the constitution. This happens after generation rather than constraining the initial generation, allowing for more natural responses that are then refined.

        if violations:
            # Revise response to address violations
            revised_response = self.revise_for_constitution(
                original=initial_response,
                violations=violations,
                query=query
            )

            return {
                "response": revised_response,
                "constitutional_status": "revised",
                "violations_addressed": violations
            }

        return {
            "response": initial_response,
            "constitutional_status": "compliant",
            "violations_addressed": []
        }

When violations are detected, the system revises the response to comply with constitutional principles while maintaining helpfulness. The return structure provides transparency about any revisions made.

Self-Debugging Pattern

The Self-Debugging Pattern enables agents to identify and correct their own errors autonomously, similar to how human developers debug code:

class SelfDebuggingAgent:
    """Agent that can debug and fix its own reasoning errors"""

    def self_debugging_execute(self, task: str) -> dict:
        """Execute task with automatic error detection and correction"""

        execution_trace = []
        max_debug_iterations = 3

        for iteration in range(max_debug_iterations):
            try:
                # Attempt task execution
                result = self.execute_task(task)

                # Validate result quality
                validation_result = self.validate_execution(task, result, execution_trace)

Each iteration attempts to execute the task and validates the result. This validation checks for logical errors, incomplete solutions, or inconsistencies that might not cause exceptions but still represent failures.

                if validation_result.is_valid:
                    return {
                        "result": result,
                        "debug_iterations": iteration,
                        "execution_trace": execution_trace
                    }
                else:
                    # Debug and fix issues
                    debug_analysis = self.analyze_execution_issues(
                        task=task,
                        failed_result=result,
                        validation_issues=validation_result.issues
                    )

                    # Apply fixes
                    self.apply_debugging_fixes(debug_analysis.fixes)
                    execution_trace.append(debug_analysis)

When validation fails, the system analyzes what went wrong and attempts to fix the issues. This is similar to how a developer would debug code by identifying the problem and applying targeted fixes.

            except Exception as e:
                # Handle execution errors
                error_analysis = self.analyze_execution_error(e, task, execution_trace)
                self.apply_error_fixes(error_analysis.fixes)
                execution_trace.append(error_analysis)

        return {
            "result": None,
            "debug_iterations": max_debug_iterations,
            "execution_trace": execution_trace,
            "status": "failed_after_debugging"
        }

Exception handling addresses runtime errors through systematic analysis and fix application. If all debugging attempts fail, the system returns a detailed trace of what was attempted, enabling human developers to understand and address the underlying issues.

Meta-Learning Pattern

Meta-Learning enables agents to adapt their learning strategies based on the domain and task characteristics, essentially "learning how to learn":

class MetaLearningAgent:
    """Agent that learns how to learn and adapt its learning strategies"""

    def __init__(self):
        self.learning_strategies = LearniningStrategyRegistry()
        self.meta_optimizer = MetaLearningOptimizer()

    def adaptive_learning_execution(self, new_domain_task: str) -> dict:
        """Execute task in new domain while adapting learning approach"""

        # Analyze domain characteristics
        domain_analysis = self.analyze_domain(new_domain_task)

        # Select appropriate learning strategy
        learning_strategy = self.learning_strategies.select_strategy(domain_analysis)

The system first analyzes the domain to understand its characteristics (e.g., mathematical, linguistic, creative) and selects an initial learning strategy optimized for that domain type.

        # Execute with continuous meta-learning
        execution_results = []

        for attempt in range(self.max_learning_attempts):
            # Execute with current strategy
            result = self.execute_with_strategy(new_domain_task, learning_strategy)
            execution_results.append(result)

            # Meta-evaluate learning effectiveness
            meta_feedback = self.meta_optimizer.evaluate_learning_progress(
                results=execution_results,
                domain=domain_analysis,
                strategy=learning_strategy
            )

Each attempt uses the current learning strategy and evaluates not just task performance but learning effectiveness. The meta-optimizer analyzes whether the learning approach is working well for this specific domain.

            # Adapt learning strategy if needed
            if meta_feedback.should_adapt:
                learning_strategy = self.meta_optimizer.adapt_strategy(
                    current_strategy=learning_strategy,
                    feedback=meta_feedback,
                    domain=domain_analysis
                )

        return {
            "final_result": execution_results[-1],
            "learning_progression": execution_results,
            "adapted_strategy": learning_strategy,
            "meta_insights": meta_feedback
        }

When the current strategy isn't effective, the meta-optimizer adapts the approach based on what has been learned about this domain. The system returns the complete learning journey, showing how the agent improved its learning approach.

Swarm Intelligence Pattern

Swarm Intelligence leverages collective problem-solving by coordinating multiple diverse agents, similar to how ant colonies or bee swarms solve complex problems:

class SwarmIntelligenceAgent:
    """Implements swarm intelligence for collective problem solving"""

    def swarm_solve(self, complex_problem: str, swarm_size: int = 10) -> dict:
        """Use swarm intelligence for collaborative problem solving"""

        # Initialize diverse agent swarm
        swarm = self.create_diverse_swarm(swarm_size, complex_problem)

        # Swarm exploration phase
        exploration_results = self.swarm_exploration(swarm, complex_problem)

The swarm is initialized with diverse agents, each having different approaches and specializations. During exploration, agents work independently to generate different solution approaches, maximizing the solution space coverage.

        # Information sharing and convergence
        shared_knowledge = self.share_swarm_knowledge(exploration_results)

        # Collaborative solution refinement
        refined_solutions = self.swarm_refinement(swarm, shared_knowledge)

After independent exploration, agents share their findings and insights. This collective knowledge enables each agent to refine their solutions based on what others have discovered, leading to superior combined solutions.

        # Consensus building
        final_solution = self.build_swarm_consensus(refined_solutions)

        return {
            "solution": final_solution,
            "swarm_size": swarm_size,
            "exploration_diversity": self.measure_solution_diversity(exploration_results),
            "consensus_strength": self.measure_consensus_strength(refined_solutions),
            "collective_intelligence_metrics": self.calculate_swarm_metrics(swarm)
        }

Consensus building synthesizes the refined solutions into a final solution that benefits from collective intelligence. The return includes metrics about solution diversity and consensus strength, providing insight into the swarm's problem-solving effectiveness.

📝 Multiple Choice Test - Module B

Test your understanding of advanced pattern theory and implementation strategies:

Question 1: What is the key advantage of LangChain's framework approach over bare metal Python for reflection patterns?
A) Faster execution speed
B) Structured prompt templating and reduced boilerplate code
C) Lower memory usage
D) Built-in GPU acceleration

Question 2: In advanced tool agents, what determines which tool is selected for a given task?
A) Random selection from available tools
B) Task analysis combined with historical performance data
C) Alphabetical ordering of tool names
D) The tool with the most recent update

Question 3: What are the three phases of ReAct + Reflection combination pattern?
A) Planning, execution, evaluation
B) ReAct problem solving, reflection on solution quality, iterative improvement
C) Analysis, synthesis, deployment
D) Input processing, model inference, output generation

Question 4: Which emerging pattern enables agents to debug and fix their own reasoning errors?
A) Constitutional AI Pattern
B) Meta-Learning Pattern
C) Self-Debugging Pattern
D) Swarm Intelligence Pattern

Question 5: What is the primary benefit of combining Planning with Multi-Agent Coordination?
A) Reduced computational costs
B) Simplified code architecture
C) Strategic planning with coordinated execution across specialized agents
D) Faster individual agent performance

🗂️ View Test Solutions →

Module Summary

You've now mastered advanced pattern theory and implementation strategies:

✅ Implementation Strategies: Understood how patterns are implemented across different frameworks
✅ Pattern Combinations: Learned how patterns synergize for sophisticated behaviors
✅ Emerging Patterns: Explored next-generation patterns being developed in research
✅ Strategic Thinking: Can make informed decisions about pattern selection and combination

Related Modules:

🗂️ Code Files: All examples use theoretical implementations

🚀 Quick Start: Review the core patterns before diving into advanced implementations

Next: Session 1 - Bare Metal Agents →

🔬 Advanced Topics for Further Exploration:

  • Constitutional AI research papers
  • Meta-learning in multi-agent systems
  • Swarm intelligence algorithms
  • Pattern composition optimization strategies