Build an AI Agent from Agentic Architectural Patterns

The Premise: Patterns As Requirements

Traditional tutorials show you how to build one specific agent — a chatbot, a coding assistant, a research tool. But they don't give you a framework for building any agent. They show you the pieces but not the why behind those pieces.

"Agentic Architectural Patterns for Building Multi-Agent Systems" by Dr. Ali Arsanjani and Juan Pablo Bustos (Packt, 2026) is different. It distills enterprise-grade agentic AI into a structured library of proven architectural patterns — each one a reusable solution to a specific challenge in building robust, scalable, multi-agent systems.

Why This Approach?

• Pattern-driven specification: The patterns give us a clear, comprehensive specification. No guessing what the agent should do.
• Modular architecture: Each pattern is a module you build, test, and iterate on independently.
• Extensible foundation: Once you have these patterns, you can assemble the agent for any task — coding, research, automation, or any domain.
• Deep understanding: You'll understand the design rationale behind each pattern, not just the implementation details.

About the Book

"Agentic Architectural Patterns for Building Multi-Agent Systems: Proven Design Patterns and Practices for GenAI, Agents, RAG, LLMOps, and Enterprise-Scale AI Systems" was written by Dr. Ali Arsanjani and Juan Pablo Bustos, published by Packt in January 2026 (574 pages).

The book is organized into two parts:

Part 1: Foundations and Core Agent Concepts

• Chapter 1: GenAI in the Enterprise — landscape, maturity models, and agent focus
• Chapter 2: Agent-Ready LLMs — selection, deployment, and adaptation strategies
• Chapter 3: The Spectrum of LLM Adaptation for Agents — from RAG to fine-tuning

Part 2: Agentic AI Architecture and Design Patterns

• Chapter 4: Agentic AI Architecture — components, interactions, and the three-layer stack (function calling, tool protocols/MCP, A2A collaboration)
• Chapter 5: Multi-Agent Coordination Patterns — orchestrator agents, delegation, and specialized agent collaboration
• Chapter 6: Explainability and Compliance Agentic Patterns — auditability, governance, and responsible AI
• Chapter 7: Robustness and Fault Tolerance Patterns — adaptive retry, adversarial testing, and resilient agent design

The book introduces a concrete, hierarchical multi-agent architecture where high-level orchestrator agents manage complex workflows by delegating sub-processes to specialized agents. Each pattern is backed by real-world scenarios and code examples using the open-source Agent Development Kit (ADK).

The Agentic Patterns We'll Implement

Here are the key design patterns extracted from the book (from the index and chapter descriptions), organized by the phase they'll be implemented in:

Phase 1 Patterns (Foundation)

Phase 2 Patterns (Core Capabilities)

Phase 3 Patterns (Safety & Reliability)

Phase 1: Requirements Extraction

Week 1–2

Before writing any agent code, we extract structured requirements from the book. This is where we train an AI agent (Hermes or Claude) to act as a product manager and systems analyst, reading your copy of the book and producing actionable specifications.

Step 1: Feed the Book to an Agent

Since you have the book, use one of these approaches to digitize it for the requirements extraction agent:

1. Scanned PDF pages: Use Marker-PDF or similar OCR pipeline to convert to text, then chunk by chapter for LLM consumption
2. Kindle/Digital copy: Export via Calibre, clean the text, chunk by chapter
3. Print-to-text: If it's a physical copy, scan chapters individually and OCR each page

Step 2: Product Requirements Extraction

Run a dedicated agent prompt to extract product-level requirements:

# Role: You are a product manager and systems analyst.
# Source: "Agentic Architectural Patterns for Building Multi-Agent Systems"
# by Dr. Ali Arsanjani and Juan Pablo Bustos (Packt, 2026)

# Task: For each agentic pattern in the book, extract:
1. What problem it solves (the "context" element)
2. The problem statement (when is this pattern needed?)
3. The solution structure (how does it work?)
4. Implementation guidance (from the book's examples)
5. Success criteria (how do we know it works?)
6. User scenarios where this pattern is essential

# Output: Structured JSON with "user_stories", "system_requirements",
#      "capability_map" (pattern → capability), "prioritization" (MoSCoW)

Step 3: System Architecture Extraction

Next, extract the technical specifications. The book's three-layer agentic architecture is critical:

1. Layer 1 — Function Calling: How agents execute functions. Get the exact schemas, parameter types, and return formats.
2. Layer 2 — Tool Protocols (MCP): How agents interact with external APIs and data sources. Extract the MCP connection patterns.
3. Layer 3 — Agent-to-Agent (A2A) Collaboration: How agents delegate, coordinate, and share state. Extract the multi-agent delegation patterns.

Phase 2: Capability Implementation

Weeks 3–5

Now we build. The key is to implement patterns in the book's prescribed order — foundation first, then coordination, then safety. Each pattern becomes a Python module with a clear interface.

Week 3: Foundation Patterns (LLM + RAG)

1. LLM Selection & Deployment: Build a model router that routes tasks to the right model based on complexity. Use the book's guidance on FP16 vs FP32 vs INT8 trade-offs. Test: the agent responds correctly with a fast, quantized model on simple tasks, and switches to a full-precision model for complex reasoning.
2. RAG: Implement the contextual enhancement pattern. Index your knowledge base (docs, APIs, previous agent outputs) using a vector store. Test: the agent retrieves relevant context before generating responses.
3. Function Calling: Build the lowest layer of the three-layer stack. Create typed function schemas with parameter validation. Test: the agent correctly calls functions and processes returned data.

Week 4: Core Agentic Patterns

1. Multi-Agent Coordination (from Chapter 5): Implement the orchestrator-delegate hierarchy. Create an "orchestrator" agent that breaks tasks into subtasks and assigns them to specialized agents (planner, coder, reviewer). This is the heart of the book's architecture.
2. Agent Protocol (MCP): Connect agents to external tools — Git operations, code execution, web search. Use the MCP patterns from the book's implementation examples.
3. Adaptive Retry: Build retry logic that adapts based on error type — the book distinguishes between retries that simply repeat and retries that mutate the prompt. Implement both variants and test against real failure cases (e.g., malformed code output, API rate limits).
4. Agent Calls Human: Implement the human-in-the-loop pattern at strategic decision points. The agent should pause and request approval from the user before making significant changes (like committing code or deploying).

Week 5: Safety & Reliability Patterns

1. Agent Authentication & Authorization: Implement access control for agents. Different agent roles get different permissions (e.g., the reviewer agent can read but not write, the builder agent can write but needs approval before commit).
2. Adversarial Testing & Red Teaming: Create a testing agent that intentionally tries to break your coding agent — inject malformed prompts, test edge cases, check for prompt injection vulnerabilities.
3. In-Context Learning: Implement the agent's ability to learn from experience without retraining. Add a "lessons learned" mechanism where the agent stores successful patterns in its context and references them for similar future tasks.

Phase 3: The Coding Agent Assembly

Weeks 6–7

Now we assemble the agent. We take the patterns built in Phase 2 and combine them into a functional coding agent — a concrete, working demonstration of the book's patterns in action.

Agent Architecture from the Book

# Coding Agent built on agentic architectural patterns
class CodingAgent:
     def __init__(self):
         # Pattern: Multi-Agent Coordination (Chapter 5)
         self.orchestrator = OrchestratorAgent("task_decomposer")
         self.specialists = {
             "planner": SpecialistAgent("code_planner"),
             "builder": SpecialistAgent("code_writer"),
             "reviewer": SpecialistAgent("code_reviewer"),
         }

         # Pattern: LLM Selection & Adaptation (Chapter 2-3)
         self.llm_router = ModelRouter({
             simple_tasks: "gpt-4o-mini",   # Fast, cheap
             complex_reasoning: "claude-sonnet-4",  # Strong reasoning
         })

         # Pattern: RAG (Chapter 3)
         self.knowledge = KnowledgeRetriever("codebase_index")

         # Pattern: Function Calling (Chapter 4)
         self.tools = FunctionCallingLayer([
             "read_file", "write_file", "shell_execute", "git_ops", "web_search"
         ])

         # Pattern: MCP Tool Protocols (Chapter 4)
         self.mcp_client = MCPClient(tools=self.tools)

         # Pattern: Agent Calls Human (Chapter 6/7)
         self.human_interface = HumanCallout(approval_required=["git_commit", "deploy"])

         # Pattern: Adaptive Retry (Chapter 7)
         self.retrier = AdaptiveRetry(
             max_attempts=3,
             mutation_strategy="prompt_reformulation",
         )

         # Pattern: In-Context Learning
         self.icl = InContextLearner(
             storage="memory_context",
             retrieval_mode="similar_tasks",
         )

         # Pattern: Auth & Authorization
         self.auth = AgentAuth(
             roles={
                 "orchestrator": {"read", "write", "deploy"},
                 "planner": {"read", "plan"},
                 "builder": {"read", "write"},
                 "reviewer": {"read", "approve", "reject"},
             }
         )

     async def execute(self, task: str) -> AgentResult:
         # Step 1: Route to best model
         model = self.llm_router.select(task)

         # Step 2: Planner orchestrates (multi-agent coordination)
         spec = await self.orchestrator.plan(task, model=model)

         # Step 3: Execute plan with pattern-based agents
         results = []
         for step in spec.steps:
             try:
                 # Step 4: RAG for context
                 context = self.knowledge.retrieve(step.description)

                 # Step 5: In-context learning — apply past lessons
                 prior_lessons = self.icl.recall_similar(step.description)

                 # Step 6: Execute tools with MCP
                 output = await self.mcp_client.execute(
                     step.action,
                     params={"context": context, "lessons": prior_lessons},
                 )

                 # Step 7: Adaptive retry on failure
                 if output.failed:
                     output = self.retrier.retry(step, output)

                 # Step 8: Human-in-the-loop for critical ops
                 if step.requires_approval:
                     output = await self.human_interface.request_approval(output)

                 results.append(output)
             except AgentError as e:
                 # Step 9: Adaptive retry with prompt mutation
                results.append(self.retrier.mutation_retry(step, e))

         return AgentResult(plan=spec, results=results, status="completed")

What You're Building

• Input: A task description ("Add authentication to the user API", "Refactor this module to use async/await", "Write tests for this function")
• Process: The orchestrator breaks it into steps → specialized agents each execute their role → adaptive retry handles failures → human approval gates critical changes
• Output: A structured result with code changes, reasoning trace, and any issues encountered

Implementation Order

1. Week 6, Sunday: Set up the project structure. Build the orchestrator + function calling layer. Get a basic "read directory, suggest changes" working.
2. Week 6, Tuesday: Add RAG. The agent queries the codebase for context before generating changes.
3. Week 6, Thursday: Add multi-agent coordination. Split into planner, builder, and reviewer specialists.
4. Week 6, Saturday: Add adaptive retry and human-in-the-loop. The agent handles failures gracefully and gets approval before committing.
5. Week 7, Sunday: Add authentication, authorization, and adversarial testing. Your agent is now security-ready.
6. Week 7, Tuesday: Add in-context learning. The agent remembers past successes and applies them to new tasks.
7. Week 7, Saturday: Full integration test — give the agent 5 real coding tasks and verify the complete pipeline works end-to-end.

Phase 4: Iteration <br> Refinement

Weeks 8+

With the coding agent working on basic tasks, you'll inevitably hit limitations. This phase is about iterating based on real development experience, applying additional patterns from the book only where they solve actual problems.

Patterns to Add Based on Dev Feedback

1. Agent Fine-Tuning for Capability Enhancement (from Chapters 2-3): As you discover the agent struggles with specific types of code (e.g., React components vs. Go backends), fine-tune the model on those domains for persistent capability upgrades.
2. Advanced Multi-Agent Protocols (from Chapter 5): If the agent processes complex tasks slowly, add parallel delegation — where multiple specialist agents work simultaneously instead of sequentially.
3. Compliance & Explainability (from Chapter 6): If the agent needs to run in environments where changes must be auditable (e.g., enterprise codebases), add detailed trace logging for every agent decision.
4. Adversarial Hardening (expanded from Chapter 7): Build a comprehensive red-teaming suite that continuously tests the agent against new attack vectors — prompt injection, tool misuse, context poisoning.

Iteration Loop

1. Test the agent on diverse task types and codebases
2. Identify failure patterns — where does the agent struggle?
3. Match the failure to a pattern from the book
4. Implement the corresponding capability
5. Retest and verify the agent handles the task better
6. Document lessons learned in the agent's knowledge base

Prioritization Framework

Not every pattern is equally urgent. Use the Eisenhower matrix — which the book itself references in its governance and orchestration patterns — to decide what to implement first:

Recommended Tech Stack

The book uses the open-source Agent Development Kit (ADK) for its code examples. Here's the stack for our implementation:

Common Pitfalls to Avoid

Complete Timeline Summary