Skip to content

Agentic AI Architectures

A practical guide to 70 agentic design patterns used in modern AI systems. Each architecture includes a description, when to use it, key benefits, a diagram, and a hands-on mini-project notebook.

What is an Agentic Architecture?

An agentic architecture defines how one or more AI agents are structured, coordinated, and given autonomy to accomplish complex tasks. These patterns range from simple single-agent loops to hierarchical teams of dozens of specialized agents.

The 70 Architectures

# Architecture Part Complexity Best For
1 Single Agent (ReAct) I Low Simple tool-augmented tasks
2 Prompt Chaining I Low Sequential multi-step pipelines
3 Routing I Low-Med Multi-domain classification
4 Parallelization I Medium Independent concurrent subtasks
5 Orchestrator-Worker I Med-High Unpredictable task decomposition
6 Supervisor I Med-High Coordinated multi-agent control
7 Reflection / Self-Correction I Medium Self-improving output quality
8 Evaluator-Optimizer I Medium Scored quality iteration
9 Swarm I High Conversational multi-domain handoffs
10 Hierarchical Teams I High Large-scale enterprise workflows
11 Generator-Verifier II Medium Execution-based verification
12 Agent-as-a-Judge II Medium One-shot quality evaluation
13 Human-in-the-Loop II Medium High-stakes approval workflows
14 Map-Reduce Agents III Medium Processing large documents/datasets
15 Mixture-of-Agents III High Maximum quality via model diversity
16 DAG / Graph Orchestration III Medium Complex dependency workflows
17 Plan-and-Execute III Medium Strategic multi-step tasks
18 Cascading Agents III Medium Cost-optimized inference
19 Blackboard Pattern IV High Incremental collaborative problem-solving
20 Market-Based / Bidding IV Medium Dynamic task allocation
21 Contract Net Protocol IV Medium Formal task delegation
22 Debate / Adversarial IV Medium Rigorous decision analysis
23 Red-Team Agent IV Medium Security & safety testing
24 Role-Based Collaboration IV Medium Persona-driven team pipelines
25 Conversational Multi-Agent IV Medium Emergent group problem-solving
26 Event-Driven Multi-Agent IV High Reactive async systems
27 Inner Monologue V Low Clean output with hidden reasoning
28 Speculative Execution V Medium Low-latency branching decisions
29 Skeleton of Thought V Medium Fast long-form generation
30 ReAcTree V High Multi-strategy tree exploration
31 Agentic RAG VI Medium Intelligent document retrieval
32 Agentic Coding VI Medium Self-healing code generation
33 Self-Tooling Agent VI Medium Runtime tool creation
34 Dynamic Tool Generation VI Medium Systematic tool generation
35 Neuro-Symbolic Agent VII High LLM + formal logic/rules
36 Dual-Paradigm Framework VII Medium System 1 / System 2 routing
37 LATS VIII High LLM + Monte Carlo Tree Search
38 Introspective MCTS VIII High Per-simulation introspective search
39 Reflective MCTS VIII High Cross-episode reflective search
40 Collaborative Tree Search VIII High Multi-agent collaborative search
41 Beam Search for Agents VIII Medium Top-K solution exploration
42 Model Context Protocol (MCP) IX Low Tool integration standard
43 Agent-to-Agent Protocol (A2A) IX Medium Cross-vendor agent communication
44 Agent Communication Protocol (ACP) IX Medium Framework-agnostic agent messaging
45 Agent Network Protocol (ANP) IX High Internet-scale agent networking
46 Episodic Memory X Medium Learning from past experiences
47 Semantic Memory X Medium Storing facts and relationships
48 Procedural Memory X Medium Remembering how to do tasks
49 Agentic Memory (A-MEM) X High Interconnected knowledge notes
50 Collaborative Memory X Medium Shared team knowledge
51 Contextual Experience Replay X Medium Prioritized experience replay
52 Meta-Memory X High Memory system optimization
53 Guardrail Agent XI Low Content safety filtering
54 Circuit Breaker XI Low Preventing cascading failures
55 Saga Pattern XI Medium Multi-step rollback
56 API Gateway / Gatekeeper XI Low Centralized access control
57 Least-Privilege Ephemeral Identity XI Medium Per-task scoped credentials
58 Dead Letter / Escalation XI Low Handling failed tasks
59 Agentic Mesh XII High Enterprise multi-agent infrastructure
60 Agent Registry and Discovery XII Medium Large-scale agent management
61 Agent Control Plane XII High Agent governance and lifecycle
62 Data Flywheel XII Medium Continuous improvement from usage
63 VLA Models XIII Very High Vision + language + robot actions
64 Embodied AI XIII Very High Physical world agents
65 World Models XIII Very High Internal environment simulation
66 CoALA XIV — Agent architecture taxonomy
67 AEGIS Framework XIV High Comprehensive layered safety
68 ADAS XIV High Automated agent design search
69 Self-Evolving Agents (MASE) XIV High Self-improving agents
70 Nested Learning XIV High Multi-timescale optimization

Key Principles

  1. Start simple. Use a single ReAct agent first. Only add complexity when needed.
  2. Match architecture to task. Don't use a multi-agent swarm when prompt chaining suffices.
  3. Minimize autonomy. Give the system the smallest amount of freedom that still delivers the outcome.
  4. Combine patterns. Real systems often layer multiple patterns (e.g., Supervisor + Reflection + Guardrails).
  5. Observe everything. Log all agent decisions, tool calls, and handoffs for debugging.
  6. Safety is not optional. Every production agent needs guardrails, regardless of the architecture.
  7. Memory is a superpower. Agents with memory outperform stateless agents on repeated tasks.
  8. Plan before acting. For complex tasks, explicit planning reduces wasted effort.
  9. Verify outputs. Generator-Verifier patterns catch errors that self-reflection misses.
  10. Design for failure. Use circuit breakers, sagas, and dead letter queues for resilience.

References