A Comprehensive Guide to Building Robust, Scalable, and Intelligent AI Agents
This repository is a comprehensive collection of Agentic Design Patterns implemented using the Google Agent Development Kit (ADK). It provides production-ready implementations, detailed documentation, and practical examples for building sophisticated AI agent systems.
Each pattern addresses specific challenges in agent design—from simple task chaining to complex multi-agent orchestration—enabling developers to build reliable, maintainable, and scalable AI applications.
- Python 3.10+
- uv (recommended) or pip
Using uv (recommended):
# Clone the repository
git clone <repository-url>
cd agentic-design
# Create virtual environment and install dependencies
uv venv
uv pip install -e .
# Set up environment variables
cp .env.example .env
# Edit .env with your API keysUsing pip:
# Create virtual environment
python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
# Install dependencies
pip install -e .Create a .env file with your API credentials:
GOOGLE_API_KEY=your_google_api_key_here
# Add other API keys as needed for specific patterns| Pattern | Description | Module |
|---|---|---|
| 🔗 Prompt Chaining | Sequential LLM calls for multi-step workflows | prompt-chaining/ |
| 🧭 Routing | Dynamic decision-making for adaptive systems | routing/ |
| ⚡ Parallelization | Concurrent execution for performance optimization | Parallelization/ |
| 🔄 Reflection | Self-correction and iterative improvement | Reflection/ |
| 🛠️ Tool Use | External tool integration via function calling | Tool_use/ |
| 🤝 Multi-Agent | Cooperative ensembles of specialized agents | Multi_Agent/ |
| 📋 Planning | Strategic goal decomposition for complex tasks | Planning/ |
| 👤 Human-in-the-Loop | Strategic human-AI collaboration | Human_in_the_loop/ |
| 🛡️ Guardrails & Safety | Content policy enforcement and safety controls | Guardrails_Safety_Patterns/ |
| 📊 Evaluation & Monitoring | Performance assessment and continuous monitoring | Evaluation_and_Monitoring/ |
| 🎯 Prioritization | Task scheduling and importance-based execution | Prioritization/ |
| 🔍 Exploration & Discovery | Information gathering and knowledge expansion | Exploration_and_Discovery/ |
| 📝 Goal Setting & Monitoring | Objective definition and progress tracking | Goal_setting_monitoring/ |
| 🧠 Learning & Adaptation | Continuous improvement from feedback | Learning_and_adaptation/ |
| 📡 Inter-Agent Communication | Standardized agent interaction protocols | Inter_Agent_Communication/ |
| 🔧 Resource-Aware Optimization | Efficient resource utilization and cost management | Resource_aware_optimisation/ |
| 🧩 Model Context Protocol | Context management and state handling | Model_context_protocol/ |
| Recovery and resilience patterns | Exception_handling_recovery/ |
These patterns define how agents make decisions and orchestrate tasks:
- Prompt Chaining → Sequential execution for multi-step processes
- Routing → Dynamic path selection based on context
- Parallelization → Concurrent execution of independent tasks
- Reflection → Iterative self-improvement through critique
These patterns extend agent capabilities through external integration:
- Tool Use → Function calling and external API integration
- Multi-Agent → Specialized agent collaboration
- Planning → Strategic goal decomposition
These patterns ensure reliable and safe agent operation:
- Guardrails & Safety → Content filtering and policy enforcement
- Human-in-the-Loop → Strategic human oversight
- Evaluation & Monitoring → Performance tracking and assessment
- Exception Handling → Recovery from failures
These patterns improve efficiency and effectiveness:
- Prioritization → Importance-based task scheduling
- Resource-Aware Optimization → Efficient resource utilization
- Learning & Adaptation → Continuous improvement
Divide complex tasks into sequential steps where each step refines the output.
Input → Step 1 → Step 2 → Step 3 → Output
When to use: Multi-stage workflows requiring progressive refinement
Example: Content generation (ideation → outline → draft → edit)
Dynamically route requests to specialized handlers based on intent.
Input → Router → Handler A / Handler B / Handler C
When to use: Different input types requiring specialized processing
Example: Customer support (billing, technical, sales)
Execute independent tasks concurrently to reduce latency.
┌→ Task A →┐
Input ─┼→ Task B →┼→ Synthesize → Output
└→ Task C →┘
When to use: Multiple independent operations (API calls, data processing)
Example: Research agent (search multiple sources simultaneously)
Generate → Critique → Refine for high-quality outputs.
Generate → Evaluate → Refine → Final Output
When to use: Quality-critical applications requiring accuracy
Example: Code generation with self-review
Extend agent capabilities through function calling and external APIs.
User Request → Agent → Tool Call → Execution → Response
When to use: Access to real-time data, calculations, or external systems
Example: Weather queries, database lookups, calculations
Coordinate multiple specialized agents to solve complex problems.
┌→ Specialist A →
User ──→ Coordinator ┼→ Specialist B → Synthesis → Output
└→ Specialist C →
When to use: Complex tasks requiring diverse expertise
Example: Software development team (requirements, coding, testing, docs)
Each pattern includes a runnable agent.py file. Execute any example:
# Using uv
uv run python prompt-chaining/agent.py
# Using Python directly
python prompt-chaining/agent.pyagentic-design/
├── README.md # This file
├── pyproject.toml # Project configuration
├── .python-version # Python version specification
├── agent.py # Main demo: Farm Management System
├── main.py # Entry point placeholder
│
├── prompt-chaining/ # Sequential pattern implementation
├── routing/ # Dynamic routing pattern
├── Parallelization/ # Concurrent execution pattern
├── Reflection/ # Self-correction pattern
├── Tool_use/ # Function calling pattern
├── Multi_Agent/ # Agent collaboration pattern
├── Planning/ # Goal decomposition pattern
├── Human_in_the_loop/ # Human-AI collaboration
├── Guardrails_Safety_Patterns/ # Safety and policy enforcement
├── Evaluation_and_Monitoring/ # Performance tracking
├── Prioritization/ # Task scheduling
├── Exploration_and_Discovery/ # Information gathering
├── Goal_setting_monitoring/ # Objective management
├── Learning_and_adaptation/ # Continuous improvement
├── Inter_Agent_Communication/ # Agent interaction protocols
├── Resource_aware_optimisation/ # Resource management
├── Model_context_protocol/ # Context handling
└── Exception_handling_recovery/ # Resilience patterns
│
└── assets/ # Documentation images and diagrams
# Run all tests
uv run pytest
# Run specific pattern tests
uv run pytest Evaluation_and_Monitoring/# Format code
uv run ruff format .
# Lint code
uv run ruff check .This repository uses the Google Agent Development Kit (ADK)—a comprehensive framework for building production-grade AI agents.
- Agents: LLM-powered agents with structured instructions
- Tools: Function calling for external integrations
- Sessions: State management for multi-turn conversations
- Runners: Orchestration and execution management
- Callbacks: Before/after model hooks for guardrails and personalization
- MCP Integration: Model Context Protocol for external tool access
- Start with Prompt Chaining—understand sequential workflows
- Explore Tool Use—add external capabilities
- Study Reflection—learn self-correction
- Implement Routing—build decision-making agents
- Master Parallelization—optimize performance
- Design Multi-Agent systems—coordinate specialists
- Add Guardrails & Safety—ensure reliability
- Implement Evaluation & Monitoring—production readiness
- Explore Human-in-the-Loop—strategic collaboration
| Use Case | Recommended Pattern |
|---|---|
| Multi-stage processing | Prompt Chaining |
| Intent classification | Routing |
| Multiple API calls | Parallelization |
| Quality-critical outputs | Reflection |
| External data access | Tool Use |
| Complex collaborative tasks | Multi-Agent |
| Step-by-step goal achievement | Planning |
| High-stakes decisions | Human-in-the-Loop |
| Content safety | Guardrails |
| Production monitoring | Evaluation & Monitoring |
- Decompose complex tasks into smaller, focused agents
- Compose patterns together for sophisticated behaviors
- Validate outputs at critical transition points
- Monitor performance in production environments
- Iterate based on real-world feedback
This repository is built upon the foundational work presented in Antonio Gulli's book on Agentic Design Patterns. The concepts, patterns, and architectural insights are drawn from his comprehensive research and expertise in the field.
- Antonio Gulli — For the foundational book on Agentic Design Patterns that inspired this implementation
- Google ADK Team — For the excellent agent framework
- Anthropic — For pioneering agentic AI patterns
- LangChain/LangGraph — For workflow orchestration concepts
Ready to build intelligent agents?
Start with prompt-chaining/ → Tool_use/ → Multi_Agent/