Evolution of AI/Agentic Architecture Patterns: A Spectrum from Simplicity to Autonomy

TLDR;

AI and agentic architecture patterns represent the next evolution in software design, enabling systems that not only process data but also reason, plan, and act autonomously. This paper organizes twelve key patterns into a narrative spectrum, beginning with foundational prompting techniques like Few-Shot Prompting, which rely on simple input-output guidance, and advancing toward sophisticated multi-agent collaborations that handle complex, real-world tasks. Envision this as a circle: Patterns build upon or refine neighbors, progressing from static, single-step interactions (suited for basic queries) to dynamic, self-improving agent swarms that mirror human-like decision-making, then cycling back to integrated frameworks for enterprise-scale deployment. This flow underscores incremental advancements—for example, Chain-of-Thought extends basic prompting with reasoning steps, Tool Use adds external capabilities, and Multi-Agent scales to distributed teamwork. Similarities to traditional patterns from the companion paper on software architectures are highlighted, such as how Multi-Agent parallels Microservices for modularity, while integration points show where AI patterns enhance existing systems, like embedding Reflection in Layered Architectures for self-correction. We detail each pattern, its sub-components with explanations, real-world examples, and contexts. References are inlined for transparency. A glossary follows, along with out-of-scope topics.

Introduction

AI/agentic patterns have surged since 2023, driven by large language models (LLMs) and frameworks like LangChain, popularized in works such as Andrew Ng’s identification of core designs (https://medium.com/@mahimairaja/the-4-agentic-design-patterns-every-ai-developer-needs-to-know-dc5c7529460c). These patterns address autonomy, enabling AI to go beyond chatbots to proactive agents. Here, we frame them on a spectrum: From “prompt-centric” patterns that guide single models (e.g., Few-Shot) to “agentic swarms” that distribute intelligence (e.g., Multi-Agent), then to “enterprise-integrated” ones like Orchestrator for production. Neighbors evolve subtly—Few-Shot is basic like Layered’s structure, Chain-of-Thought adds depth akin to MVC’s flow; Tool Use introduces externalities similar to Client-Server requests. This shows maturation: As AI systems scale from prototypes to production, patterns hybridize with traditional architectures for robustness. Sources include Google’s guidance (https://docs.cloud.google.com/architecture/choose-design-pattern-agentic-ai-system), AWS patterns (https://docs.aws.amazon.com/prescriptive-guidance/latest/agentic-ai-patterns/introduction.html), recent 2025-2026 insights from McKinsey (https://www.mckinsey.com/capabilities/people-and-organizational-performance/our-insights/the-agentic-organization-contours-of-the-next-paradigm-for-the-ai-era), Azilen’s enterprise focus (https://www.azilen.com/blog/agentic-ai-design-patterns/), and Shakudo’s transformative patterns (https://www.shakudo.io/blog/5-agentic-ai-design-patterns-transforming-enterprise-operations-in-2025).

1. Few-Shot Prompting Pattern

Few-Shot Prompting guides models with a handful of input-output examples in the prompt, enabling quick adaptation without retraining. It’s the spectrum’s entry: Simple and context-based, differing from Chain-of-Thought by lacking explicit reasoning, similar to Layered Architecture’s basic modularity for initial structuring. It plugs into traditional patterns like MVC by enhancing controllers with example-based decision-making for dynamic UIs. Widely used in prototyping; stacks like OpenAI API or Hugging Face; infrastructure from cloud endpoints. OpenAI advocates for its efficiency in chat models (https://www.infoq.com/articles/practical-design-patterns-modern-ai-systems/). As of 2026, it’s foundational for rapid iteration in agentic systems, per IBM trends (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026).

Sub-Patterns/Components

Few-Shot starts with Example Selection, curating 3-5 relevant pairs to prime the model, like providing sentiment analysis samples for a review classifier—for instance, in customer service bots, examples teach tone detection without code changes, allowing the model to generalize from limited data and reduce hallucinations in domain-specific tasks (https://www.philschmid.de/agentic-pattern). This cross-references Role Prompting, assigning personas like “expert analyst” to refine outputs, as in Grok’s responses where a “teacher” role structures educational examples for better coherence. Prompt Engineering refines the structure, adding delimiters or formats for clarity, such as using JSON schemas to ensure outputs match expected formats, which is crucial for integrating with structured data pipelines; in enterprise, this integrates with CQRS from Microservices for query optimization, separating example-based reads from updates. Tool-assisted Few-Shot extends by pulling examples dynamically from databases, akin to Retrieval-Augmented Generation’s fetching. Zero-Shot is a variant using no examples, relying on model knowledge for broad queries, while In-Context Learning dynamically pulls examples from memory, akin to Cache-Aside in Space-Based for efficient recall, and Few-Shot Chain combines with CoT for sequenced examples in multi-step problems.

This isn’t exhaustive; nuanced versions like Chain-of-Shot combine with Chain-of-Thought for stepped examples (https://www.vellum.ai/blog/agentic-workflows-emerging-architectures-and-design-patterns), and derivatives such as Active Few-Shot select examples via reinforcement learning, as explored in 2025 research (https://blog.dailydoseofds.com/p/6-popular-agentic-design-patterns).

Real-World Examples

  1. ChatGPT Custom Instructions: Uses few-shot examples for personalized responses, like coding snippets to generate similar code, adapting to user styles dynamically (https://openai.com/blog/chatgpt-plugins). Fits for rapid adaptation in conversational AI.
  2. Google Bard Experiments: Prompts with examples for creative writing, such as poem structures guiding new compositions (https://bard.google.com). Exemplifies quick learning in content generation.
  3. IBM Watson Assistant: Examples train intents without retraining, like dialogue pairs for customer queries in banking bots (https://www.ibm.com/products/watson-assistant). Matches for enterprise chat scalability.
  4. Salesforce Einstein Copilot: Few-shot for sales forecasting, using historical deal examples to predict outcomes (https://www.azilen.com/blog/agentic-ai-design-patterns/). Highlights business analytics use.
  5. Azure OpenAI Service: Examples fine-tune responses in healthcare apps, like symptom-diagnosis pairs for triage tools (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Demonstrates domain-specific adaptation.

Hypothetical Integrations with Non-AI Patterns

Few-Shot could integrate with Layered Architecture by embedding example-based prompts in the service layer for adaptive business logic, e.g., dynamically adjusting e-commerce recommendations based on user history examples without full retraining. In Microservices, it might enhance individual services with prompt-based personalization, like a recommendation microservice using few-shot to tailor outputs per user segment, reducing inter-service calls (inspired by microservices-AI hybrids, https://www.pluralsight.com/resources/blog/ai-and-data/architecting-microservices-agentic-ai). Hypothetically, in MVC, few-shot prompts in controllers could generate dynamic views, such as auto-creating UI elements from example layouts for rapid prototyping.

Usage Contexts

In NLP tasks (e.g., translation apps or sentiment analysis in social media monitoring); stacks like LangChain for chaining prompts; infrastructure from serverless APIs like AWS Lambda; Hugging Face advocates for open models in few-shot scenarios (https://huggingface.co/docs/transformers). As per 2026 trends, it’s key for low-data domains like rare disease diagnosis (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026).

2. Chain-of-Thought (CoT) Prompting Pattern

CoT prompts models to reason step-by-step, breaking problems into logical sequences for better accuracy and interpretability. Neighboring Few-Shot, it adds explicit thinking paths, similar to MVC’s flow for handling user inputs through controlled sequences. Plugs into Pipe-Filter by chaining reasoning as sequential filters for data transformation. Common in reasoning-heavy tasks; stacks like Llama or Mistral; cloud inference endpoints. Anthropic advocates for its safety benefits in reducing errors (https://www.anthropic.com/research). In 2026, CoT is evolving with multimodal reasoning, per Clarifai trends (https://www.clarifai.com/blog/llms-and-ai-trends).

Sub-Patterns/Components

Core is Step Decomposition, guiding “think step by step,” like solving math: list equations, compute intermediates, then finalize—for example, in diagnostic tools, CoT reasons from symptoms to hypotheses, then to diagnosis, providing transparent audit trails that enhance trust in high-stakes applications like medical or legal advisory systems (https://medium.com/@anil.jain.baba/agentic-ai-architectures-and-design-patterns-288ac589179a). This links to Planning for initial task breakdown, where CoT serves as the execution phase after planning subtasks. Self-Consistency samples multiple reasoning chains and votes on the best, improving robustness against variability in model outputs, particularly useful in probabilistic scenarios like risk assessment; Tree-of-Thought explores branching paths like decision trees, allowing the model to evaluate alternatives before committing, as in strategic planning agents where multiple outcomes are simulated (https://www.vellum.ai/blog/agentic-workflows-emerging-architectures-and-design-patterns). Additional sub-components include Prompt Chaining, sequencing CoT across multiple LLM calls for complex problems, and Feedback Integration, where external validation (e.g., from tools) refines chains mid-process.

Not comprehensive; variants like Least-to-Most decompose hard problems incrementally, building from simple to complex (https://blog.bytebytego.com/p/top-ai-agentic-workflow-patterns), and derivatives such as Graph-of-Thought structure reasoning as graphs for non-linear problems, emerging in 2025 research (https://aws.plainenglish.io/5-workflow-design-patterns-for-building-reliable-agentic-ai-systems-a789cfa3bf10).

Real-World Examples

  1. Claude’s Reasoning Engine: Steps through code debugging, explaining each logical leap for developer tools (https://www.anthropic.com/claude). Fits for transparency in software engineering.
  2. Gemini Advanced Solver: Breaks down complex equations in educational platforms, guiding students through physics problems (https://gemini.google.com). Exemplifies accuracy in tutoring apps.
  3. Azure AI Studio Analytics: Chains reasoning for business intelligence, like forecasting sales with step-by-step market analysis (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Matches enterprise decision support.
  4. Salesforce Einstein CoT: Reasons through customer journeys in CRM, predicting churn with sequential logic (https://www.azilen.com/blog/agentic-ai-design-patterns/). Highlights sales optimization.
  5. IBM WatsonX Governance: Uses CoT for ethical AI decisions, stepping through compliance checks in regulated industries (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026). Demonstrates risk management.

Hypothetical Integrations with Non-AI Patterns

CoT could integrate with Event-Driven Architecture by embedding reasoning chains in event handlers, e.g., processing real-time data streams with step-by-step analysis before triggering actions, enhancing responsiveness in IoT systems. In MVC, CoT in controllers could reason through user inputs for adaptive views, like dynamically generating personalized dashboards. Hypothetically, with Microservices, CoT prompts in orchestration services could reason across service outputs for composite decisions, reducing errors in distributed systems (drawing from agentic-microservices hybrids, https://www.pluralsight.com/resources/blog/ai-and-data/architecting-microservices-agentic-ai). In Pipe-Filter, CoT acts as filters for logical transformations in data pipelines.

Usage Contexts

In problem-solving domains (e.g., education tools or financial forecasting); stacks like PyTorch for custom models; GPU-accelerated clouds; Google promotes for complex queries (https://docs.cloud.google.com/architecture/choose-design-pattern-agentic-ai-system). 2026 sees CoT in multimodal AI for video analysis (https://www.clarifai.com/blog/llms-and-ai-trends).

3. Role Prompting Pattern

Role Prompting directs models to adopt specific personas, such as “doctor” or “engineer,” to tailor outputs with appropriate style, knowledge, and behavior. Neighbors CoT by adding contextual personas to reasoning chains, similar to Client-Server’s defined roles for request handling. Plugs into Broker Architecture for mediated, role-based interactions in distributed systems. Used in simulation and personalized applications; stacks like Grok or Claude; edge devices for low-latency. xAI advocates for engaging personas in conversational AI (https://x.com/xai). By 2026, role prompting is key for agentic personalization, as per DAIN Studios (https://dainstudios.com/insights/ai-in-2026-architectures-for-a-world-of-agents).

Sub-Patterns/Components

Persona Assignment sets the role at prompt start, e.g., “You are an empathetic counselor” to guide therapeutic responses—for instance, in mental health apps, this ensures sensitive, supportive language, drawing from domain expertise without fine-tuning (https://www.infoq.com/articles/practical-design-patterns-modern-ai-systems/). This ties to Router Agent for directing tasks based on assigned roles, enabling multi-persona systems where agents switch hats for different subtasks. Dynamic Role Switching adapts personas mid-conversation, like shifting from “analyst” to “summarizer” based on user needs, enhancing flexibility in long interactions; Tool-Enhanced Roles integrate external APIs, such as a “researcher” role querying databases. Ensemble Roles aggregate multiple personas for consensus, similar to voting in self-consistency, useful for balanced outputs in advisory systems.

Limited; derivatives like System Prompt in LLMs define persistent roles (https://dev.to/knitex/common-agentic-ai-architecture-patterns-522d), and nuanced versions such as Adaptive Role Prompting use feedback to evolve personas, emerging in 2025 enterprise tools (https://www.azilen.com/blog/agentic-ai-design-patterns/).

Real-World Examples

  1. Grok’s Personality Modes: Switches to “fun mode” or “max helpful” for engaging responses (https://x.com/grok). Fits adaptability in general assistants.
  2. Salesforce Einstein Role-Based Agents: Adopts “sales coach” for guiding reps (https://architect.salesforce.com/fundamentals/enterprise-agentic-architecture). Exemplifies business personalization.
  3. Microsoft Copilot Domain Experts: Acts as “data analyst” for Excel tasks (https://www.microsoft.com/en-us/microsoft-copilot). Matches productivity tools.
  4. Google Gemini Creative Roles: “Storyteller” for narrative generation (https://docs.cloud.google.com/architecture/choose-design-pattern-agentic-ai-system). Highlights content creation.
  5. IBM WatsonX Industry Specialists: “Compliance Officer” for regulatory advice (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026). Demonstrates governance.

Hypothetical Integrations with Non-AI Patterns

Role Prompting could integrate with Client-Server by assigning server-side roles for specialized responses, e.g., a “security auditor” role in servers validating requests. In Peer-to-Peer, agents adopt peer-specific roles for decentralized negotiations. Hypothetically, with MVC, role prompts in models enhance view rendering, like a “designer” role generating UI from descriptions (from AI-microservices discussions, https://seanfalconer.medium.com/ai-agents-are-microservices-with-brains-ccb42d1504d7). In Hexagonal, roles in core logic adapters for domain-specific behaviors.

Usage Contexts

In chatbots and virtual assistants (e.g., customer service or therapy apps); stacks like Dialogflow for intent-based roles; APIs for integration; Salesforce promotes for enterprise agents (https://architect.salesforce.com/fundamentals/enterprise-agentic-architecture). 2026 trends include role-based multimodality (https://dainstudios.com/insights/ai-in-2026-architectures-for-a-world-of-agents).

4. Reflection Pattern

Reflection enables AI to review its own outputs for errors, biases, or inconsistencies, then iterate for improvements, acting as an internal feedback loop for self-correction. Neighbors Role Prompting by applying reflection to persona-driven outputs, similar to Master-Slave’s task distribution where slaves (reflections) refine master’s work. Plugs into Event-Driven for triggering reflections on events like failed actions. Common in reliability-focused applications; stacks like LangGraph for loop management; cloud for compute. Andrew Ng highlights for boosting accuracy in agentic workflows (https://medium.com/@mahimairaja/the-4-agentic-design-patterns-every-ai-developer-needs-to-know-dc5c7529460c). In 2026, reflection is standard for ethical AI, per Serious Insights (https://www.seriousinsights.net/ai-trends-2026/).

Sub-Patterns/Components

Self-Critique involves generating an output then evaluating it against criteria like accuracy or completeness, e.g., in code generation, the agent produces code, then reflects on potential bugs or optimizations, iterating until robust—for example, in debugging tools, this reduces deployment errors by simulating tests internally (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). This links to Model Critic, using a secondary LLM for unbiased review, enhancing objectivity in sensitive areas like content moderation. Iteration Loop repeats critique-refine cycles until a threshold is met, such as confidence scores; Multi-Stage Reflection breaks into phases, like factual check then ethical review. Human-in-Loop variants incorporate user feedback for hybrid reflection, useful in collaborative environments.

Not exhaustive; nuanced like Reflexion adds long-term memory to reflections for learning over time (https://www.shakudo.io/blog/5-agentic-ai-design-patterns-transforming-enterprise-operations-in-2025), and derivatives such as Chain-of-Verification combine with CoT for verified reasoning, popular in 2025 (https://research.aimultiple.com/agentic-ai-design-patterns/).

Real-World Examples

  1. Reflection AI Platform: Self-improves models in real-time for enterprise analytics (https://reflection.ai). Fits iterative refinement.
  2. AWS Bedrock Agents: Reflects on execution plans for optimization in workflows (https://docs.aws.amazon.com/prescriptive-guidance/latest/agentic-ai-patterns/introduction.html). Exemplifies production reliability.
  3. Cerebras Systems Integration: Uses reflection in hardware-accelerated AI for efficient training (https://twitter.com/i/broadcasts/1lDxLByLQmMGm). Matches hardware-software synergy.
  4. Microsoft Azure Reflective Agents: Critiques outputs in supply chain optimization (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Highlights operations.
  5. Salesforce Agentforce Reflection: Iterates on CRM predictions for accuracy (https://www.azilen.com/blog/agentic-ai-design-patterns/). Demonstrates business use.

Hypothetical Integrations with Non-AI Patterns

Reflection could integrate with Bulkhead in cloud patterns to isolate and self-correct failing components, e.g., an AI layer reflecting on microservice errors before retrying. In Strangler Fig, reflection agents monitor legacy migrations, iterating on integration points. Hypothetically, with Event-Driven, reflections trigger on events for real-time adaptation, like in IoT where agents reflect on sensor data anomalies (from EDA-AI integrations, https://seanfalconer.medium.com/ai-agents-are-microservices-with-brains-ccb42d1504d7). In Orange Architecture, reflection in the shared kernel ensures modular slices evolve consistently.

Usage Contexts

In code generation and content moderation (e.g., GitHub Copilot extensions); stacks like PyTorch for custom loops; GPUs for heavy computation; Microsoft promotes for agent reliability (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). 2026 emphasizes reflection for governance (https://www.seriousinsights.net/ai-trends-2026/).

5. Tool Use Pattern

Tool Use empowers agents to invoke external tools, APIs, or functions to extend capabilities beyond native reasoning, such as querying databases or executing code. Neighbors Reflection by using tools to validate critiques, similar to Pipe-Filter’s sequential processing where tools act as filters. Plugs into Client-Server for seamless API calls in networked environments. Used in automation and hybrid AI; stacks like Auto-GPT or Hugging Face Agents; hybrid cloud-edge. Ng emphasizes for practical operations (https://medium.com/@mahimairaja/the-4-agentic-design-patterns-every-ai-developer-needs-to-know-dc5c7529460c). 2026 sees tool use in multimodal agents, per a16z patterns (https://a16z.com/nine-emerging-developer-patterns-for-the-ai-era/).

Sub-Patterns/Components

Tool Invocation involves selecting and calling the appropriate tool based on task needs, e.g., a weather API for forecasts in travel planning—for instance, in virtual assistants, the agent reasons the need, invokes the tool, and incorporates results, enabling grounded actions in real-world scenarios (https://akka.io/blog/agentic-ai-architecture). This ties to ReAct for interleaving with reasoning, where tool calls follow thought steps. Tool Registry catalogs available tools with descriptions for discovery, allowing dynamic selection; Tool Chaining sequences multiple calls, like search then summarize. Safety Wrappers add guards against misuse, such as rate limiting tool access.

Limited; derivatives like Function Calling in OpenAI APIs standardize invocations (https://www.azilen.com/blog/agentic-ai-design-patterns/), and nuanced versions such as Adaptive Tool Use learn optimal tools over time, as in 2025 Shakudo patterns (https://www.shakudo.io/blog/5-agentic-ai-design-patterns-transforming-enterprise-operations-in-2025).

Real-World Examples

  1. Claude Artifacts Tools: Invokes browsers or calculators for enhanced responses (https://www.anthropic.com/claude). Fits capability extension.
  2. Rabbit R1 Device: Uses tools for real-world actions like booking rides (https://research.aimultiple.com/agentic-ai-design-patterns/). Exemplifies hardware integration.
  3. Microsoft UFO Agent: Controls apps via tool calls for productivity (https://research.aimultiple.com/agentic-ai-design-patterns/). Matches OS-level automation.
  4. Azure Bedrock Tooling: Invokes enterprise APIs for custom workflows (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Highlights business.
  5. Salesforce Data Cloud Tools: Queries databases in agent flows (https://www.azilen.com/blog/agentic-ai-design-patterns/). Demonstrates CRM.

Hypothetical Integrations with Non-AI Patterns

Tool Use could integrate with Gateway Routing in cloud patterns, where agents route to tools via unified endpoints for secure access. In Master-Slave, tools as slaves execute agent-master commands. Hypothetically, with Microservices, tool use in services calls external APIs, like an AI microservice using tools for data enrichment (from agent-microservices, https://seanfalconer.medium.com/ai-agents-are-microservices-with-brains-ccb42d1504d7). In Hexagonal, tools as adapters extend ports for external capabilities.

Usage Contexts

In smart assistants and robotics (e.g., Siri-like with API integrations); stacks like CrewAI for multi-tool agents; edge devices for local tools; AWS advocates for scalable tool use (https://docs.aws.amazon.com/prescriptive-guidance/latest/agentic-ai-patterns/introduction.html). 2026 trends include tool use in agent swarms (https://a16z.com/nine-emerging-developer-patterns-for-the-ai-era/).

6. ReAct Pattern

ReAct creates a loop of Reasoning, Acting, and Observing to solve problems dynamically, allowing agents to interact with environments iteratively. Neighbors Tool Use by structuring tool invocations within loops, similar to Event-Driven’s reactive asynchrony. Plugs into Saga for managing long-running, compensating actions in distributed transactions. Common in interactive agents; stacks like LangChain or AutoGen; distributed clouds. Hugging Face provides examples for implementation (https://medium.com/@anil.jain.baba/agentic-ai-architectures-and-design-patterns-288ac589179a). As of 2026, ReAct is pivotal for adaptive systems, per Vellum (https://www.vellum.ai/blog/agentic-workflows-emerging-architectures-and-design-patterns).

Sub-Patterns/Components

The Reason-Act Cycle starts with thinking about the next step, acting (e.g., tool call), observing results, and repeating—e.g., in a web research agent, reason the query, act by searching, observe snippets, then refine (https://www.philschmid.de/agentic-pattern). This connects to Reflection for post-observation critique, ensuring loops converge. Environment Interaction manages state from observations, like updating memory; Multi-Turn ReAct extends for conversations. Variants like ReWOO separate reasoning from world interaction for efficiency.

Incomplete; nuanced ReAct+ incorporates advanced tools (https://dev.to/knitex/common-agentic-ai-architecture-patterns-522d), and derivatives such as ReAct-Hybrid blend with planning for structured loops, as in 2025 Azilen designs (https://www.azilen.com/blog/agentic-ai-design-patterns/).

Real-World Examples

  1. LangChain ReAct Agents: Handles dynamic research tasks by looping queries and tools (https://langchain.com). Fits iterative problem-solving.
  2. Auto-GPT Autonomous Mode: Executes goals through ReAct loops for tasks like market analysis (https://autogpt.net). Exemplifies self-directed agents.
  3. BabyAGI Goal Pursuit: Uses ReAct for task decomposition in simulations (https://github.com/yoheinakajima/babyagi). Matches experimental AI.
  4. Azure ReAct Workflows: Loops in supply chain agents for optimization (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Highlights enterprise.
  5. Salesforce ReAct in CRM: Reasons and acts on customer data for proactive support (https://www.azilen.com/blog/agentic-ai-design-patterns/). Demonstrates sales.

Hypothetical Integrations with Non-AI Patterns

ReAct could integrate with Choreography in distributed systems, where agents react to events autonomously. In Broker, ReAct loops mediate interactions. Hypothetically, with Microservices, ReAct in orchestration services reasons across microservice calls for adaptive workflows (from Pluralsight hybrids, https://www.pluralsight.com/resources/blog/ai-and-data/architecting-microservices-agentic-ai). In Event-Driven, ReAct observes events to act, like in real-time monitoring.

Usage Contexts

In automation bots (e.g., research or e-commerce assistants); stacks like CrewAI for ReAct implementations; servers for persistence; LangChain promotes for agent building (https://medium.com/@anil.jain.baba/agentic-ai-architectures-and-design-patterns-288ac589179a). 2026 focuses on ReAct in agent swarms (https://www.vellum.ai/blog/agentic-workflows-emerging-architectures-and-design-patterns).

7. Planning Pattern

Planning decomposes complex goals into actionable steps, often delegating to sub-agents or tools for execution. Neighbors ReAct by providing upfront plans for loops, similar to Master-Slave’s task distribution. Plugs into Choreography for decentralized plan execution. Used in long-horizon workflows; stacks like AutoGen or LlamaIndex; distributed systems. Ng identifies as core for autonomy (https://medium.com/@mahimairaja/the-4-agentic-design-patterns-every-ai-developer-needs-to-know-dc5c7529460c). 2026 sees planning in organizational AI, per McKinsey (https://www.mckinsey.com/capabilities/people-and-organizational-performance/our-insights/the-agentic-organization-contours-of-the-next-paradigm-for-the-ai-era).

Sub-Patterns/Components

Task Decomposition breaks goals into subtasks, e.g., “plan trip” into research, book, confirm—for example, in travel agents, this creates parallelizable steps, optimizing resource allocation (https://www.vellum.ai/blog/agentic-workflows-emerging-architectures-and-design-patterns). This connects to Prioritizer for sequencing based on dependencies or urgency. Delegation assigns subtasks to specialized agents; Contingency Planning adds alternatives for failures. Dynamic Replanning adjusts on the fly from observations.

Not exhaustive; derivatives like Graph-of-Thought model plans as graphs for branching (https://blog.bytebytego.com/p/top-ai-agentic-workflow-patterns), and nuanced Hierarchical Planning uses levels for abstraction, as in 2025 AWS patterns (https://aws.plainenglish.io/5-workflow-design-patterns-for-building-reliable-agentic-ai-systems-a789cfa3bf10).

Real-World Examples

  1. Microsoft Autonomous Agents: Decomposes complex queries in Copilot for project planning (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Fits multi-step tasks.
  2. Cartesia Multimodal AI: Plans voice-video interactions (https://twitter.com/i/broadcasts/1lDxLByLQmMGm). Exemplifies creative workflows.
  3. Rabbit OS Agents: Breaks down user commands for device control (https://research.aimultiple.com/agentic-ai-design-patterns/). Matches consumer tech.
  4. Salesforce Project Manager Agent: Oversees CRM campaigns with decomposed steps (https://www.azilen.com/blog/agentic-ai-design-patterns/). Highlights business.
  5. IBM Watson Planning: Decomposes supply chain optimizations (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026). Demonstrates logistics.

Hypothetical Integrations with Non-AI Patterns

Planning could integrate with Scheduler Agent Supervisor for coordinating distributed tasks. In Deployment Stamps, plans replicate across instances. Hypothetically, with Orange Architecture, planning in the kernel decomposes feature slices for evolvable monoliths (inspired by modular AI, https://www.pluralsight.com/resources/blog/ai-and-data/architecting-microservices-agentic-ai). In Space-Based, plans distribute across in-memory grids for high-speed execution.

Usage Contexts

In workflow automation (e.g., project management or logistics); stacks like LlamaIndex for indexing plans; cloud orchestration; AWS advocates for agent planning (https://docs.aws.amazon.com/prescriptive-guidance/latest/agentic-ai-patterns/introduction.html). 2026 emphasizes planning for agent organizations (https://www.mckinsey.com/capabilities/people-and-organizational-performance/our-insights/the-agentic-organization-contours-of-the-next-paradigm-for-the-ai-era).

8. Retrieval-Augmented Generation (RAG) Pattern

RAG enhances generation by retrieving external knowledge, grounding outputs in facts to reduce hallucinations. Neighbors Planning by fetching data for plan steps, similar to Gateway in Broker for aggregated access. Plugs into Repository for abstracting domain data retrieval. Common in knowledge-intensive apps; stacks like Pinecone or Weaviate for vectors; vector databases. Databricks promotes for GenAI (https://www.databricks.com/product/machine-learning/build-generative-ai). 2026 trends include multi-modal RAG, per Daffodil (https://insights.daffodilsw.com/blog/top-generative-ai-trends-in-2026-the-definitive-guide-for-business-leaders-2).

Sub-Patterns/Components

Retrieval phase fetches relevant docs via vector search or keywords, e.g., embedding queries to match enterprise knowledge—for instance, in Q&A systems, retrieves docs then generates answers, ensuring currency without retraining (https://www.infoq.com/articles/practical-design-patterns-modern-ai-systems/). This links to Index Table for optimized queries. Augmentation injects retrieved context into prompts for generation; Reranking refines results post-retrieval. Advanced RAG adds agents for dynamic retrieval.

Limited; nuanced like HyDE generates hypothetical docs for better matching (https://www.shakudo.io/blog/5-agentic-ai-design-patterns-transforming-enterprise-operations-in-2025), and derivatives such as Branched RAG selects sources conditionally, as in 2025 HumanLoop (https://humanloop.com/blog/rag-architectures).

Real-World Examples

  1. Google Vertex AI RAG: Grounds search answers in custom data (https://docs.cloud.google.com/architecture/choose-design-pattern-agentic-ai-system). Fits factual responses.
  2. Perplexity AI Engine: Real-time web retrieval for queries (https://www.perplexity.ai). Exemplifies dynamic knowledge.
  3. Azure Cognitive Search RAG: Enterprise document Q&A (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Matches internal search.
  4. CustomGPT.ai RAG: Builds custom chatbots with proprietary data (https://customgpt.ai/rag-architecture-patterns/). Highlights no-code.
  5. n8n RAG Workflows: Integrates retrieval in automation pipelines (https://n8n.io/rag/). Demonstrates orchestration.

Hypothetical Integrations with Non-AI Patterns

RAG could integrate with Data Mapper in persistence layers for mapping retrieved data to objects. In CQRS, RAG enhances query sides with external knowledge. Hypothetically, with Microservices, RAG in dedicated retrieval services grounds responses across the system (from RAG-microservices, https://www.geeksforgeeks.org/system-design/ai-and-microservices-architecture/). In MVC, RAG in models fetches context for views.

Usage Contexts

In search and knowledge management (e.g., legal or medical review); stacks like Weaviate for vector search; vector DBs; Pinecone advocates for scalable RAG (https://www.pinecone.io). 2026 includes agentic RAG variants (https://insights.daffodilsw.com/blog/top-generative-ai-trends-in-2026-the-definitive-guide-for-business-leaders-2).

9. Multi-Agent Collaboration Pattern

Multi-Agent involves specialized agents collaborating on tasks, sharing knowledge and dividing labor for efficiency. Neighbors RAG by distributing retrieval among agents, similar to Microservices’ independent services. Plugs into Orchestrator for centralized management. Used in swarm intelligence; stacks like AutoGen or MultiOn; distributed clusters. McKinsey notes for organizational shifts in 2026 (https://www.mckinsey.com/capabilities/people-and-organizational-performance/our-insights/the-agentic-organization-contours-of-the-next-paradigm-for-the-ai-era).

Sub-Patterns/Components

Agent Specialization assigns unique roles, e.g., researcher, critic, synthesizer—for example, in R&D teams, agents collaborate on reports, with one gathering data, another analyzing (https://dev.to/knitex/common-agentic-ai-architecture-patterns-522d). This ties to Aggregator Agent for final synthesis. Communication Protocol uses messages or shared memory for coordination; Conflict Resolution handles disagreements. Variants include Parallel Multi-Agents for concurrent subtasks.

Not comprehensive; derivatives like Swarm architectures use graphs for interconnections (https://appstekcorp.com/staging/8353/blog/design-patterns-for-agentic-ai-and-multi-agent-systems/), and nuanced Network Agents form ad-hoc teams, as in 2025 Aufait (https://www.aufaitux.com/blog/agentic-ai-design-patterns-enterprise-guide/).

Real-World Examples

  1. AutoGen Multi-Agent Framework: Simulates group chats for coding tasks (https://microsoft.github.io/autogen). Fits collaborative development.
  2. CrewAI Workflow Teams: Agents for marketing campaigns (https://crewai.com). Exemplifies business processes.
  3. Salesforce Agent Swarms: Multi-agents for customer service (https://architect.salesforce.com/fundamentals/enterprise-agentic-architecture). Matches enterprise scale.
  4. Azure Multi-Agent Systems: Collaborates on data analysis (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Highlights analytics.
  5. IBM Watson Multi-Agents: Teams for healthcare diagnostics (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026). Demonstrates medical.

Hypothetical Integrations with Non-AI Patterns

Multi-Agent parallels Microservices, with agents as services collaborating via APIs. In Backends for Frontends, agents tailor to frontends. Hypothetically, with Event-Driven, agents react as event handlers in swarms (from Cisco patterns, https://outshift.cisco.com/blog/how-agent-oriented-design-patterns-transform-system-development). In Ports and Adapters, agents as adapters for core logic.

Usage Contexts

In simulations and R&D (e.g., drug discovery teams); stacks like MultiOn for swarms; Kubernetes clusters; Microsoft promotes for multi-agent apps (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). 2026 sees swarms in organizations (https://www.mckinsey.com/capabilities/people-and-organizational-performance/our-insights/the-agentic-organization-contours-of-the-next-paradigm-for-the-ai-era).

10. Orchestrator Pattern

Orchestrator manages and coordinates agent swarms, routing tasks and aggregating results for unified outputs. Neighbors Multi-Agent as the supervisor, similar to Broker’s mediation in distributed coordination. Plugs into Gateway Routing for efficient task distribution. Used in large-scale production; stacks like Salesforce Agentforce; enterprise clouds. Salesforce outlines for robust systems (https://architect.salesforce.com/fundamentals/enterprise-agentic-architecture).

Sub-Patterns/Components

Swarm Management delegates tasks to agents and aggregates responses, e.g., routing user queries to specialist agents then synthesizing—for instance, in CRM, orchestrates sales, support agents for holistic customer views (https://www.azilen.com/blog/agentic-ai-design-patterns/). This links to Router Agent for intent-based direction. Consensus Building resolves agent conflicts via voting or escalation; Load Balancing distributes for scalability. Variants include Sequential Orchestration for ordered flows.

Incomplete; nuanced like MCP (Multi-Agent Communication Protocol) for standardized interactions (https://www.linkedin.com/posts/rakeshgohel01_these-new-design-patterns-will-lead-ai-agents-activity-7404507762258280448-P-pc), and derivatives such as Orchestrator-Worker in hierarchical setups, as in 2025 AWS (https://aws.plainenglish.io/5-workflow-design-patterns-for-building-reliable-agentic-ai-systems-a789cfa3bf10).

Real-World Examples

  1. Salesforce Agentforce Orchestrator: Manages domain agents for business processes (https://architect.salesforce.com/fundamentals/enterprise-agentic-architecture). Fits enterprise coordination.
  2. Azure Agent Factory: Orchestrates custom agents for use cases like HR (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Exemplifies flexibility.
  3. Akka Actor Orchestration: Distributed agent management in Scala (https://akka.io/blog/agentic-ai-architecture). Matches actor models.
  4. IBM Watson Orchestrator: Coordinates in hybrid clouds for analytics (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026). Highlights integration.
  5. Google Vertex Orchestrator: Manages AI pipelines (https://docs.cloud.google.com/architecture/choose-design-pattern-agentic-ai-system). Demonstrates scale.

Hypothetical Integrations with Non-AI Patterns

Orchestrator mirrors Front Controller in MVC for centralizing agent requests. In Geode, orchestrates geographic agents. Hypothetically, with Microservices, acts as an intelligent orchestrator reasoning service compositions (from Pluralsight, https://www.pluralsight.com/resources/blog/ai-and-data/architecting-microservices-agentic-ai). In Broker, enhances with AI routing.

Usage Contexts

In operational AI (e.g., IT automation or supply chains); stacks like Akka for actors; distributed systems; Akka advocates for agentic designs (https://akka.io/blog/agentic-ai-architecture).

11. Event Sourcing for AI Pattern

Event Sourcing captures agent states and decisions as immutable events, enabling replay, auditing, and time-travel debugging. Neighbors Orchestrator by logging coordinated interactions, similar to Event-Driven’s append-only stores. Plugs into Saga for eventual consistency in agent transactions. Used in compliant, traceable AI; stacks like Kafka or EventStore; streaming platforms. AWS includes for agent reliability (https://docs.aws.amazon.com/prescriptive-guidance/latest/agentic-ai-patterns/introduction.html).

Sub-Patterns/Components

Event Append logs every reasoning step or action as events, e.g., “thought generated,” “tool called”—for example, in finance agents, replays trade decisions for compliance audits (https://www.shakudo.io/blog/5-agentic-ai-design-patterns-transforming-enterprise-operations-in-2025). This connects to Materialized View for querying current states from events. Replay Mechanism reconstructs past states for debugging; Snapshotting optimizes by periodic summaries. Variant: Multi-Agent Event Sourcing shares events across swarms.

Not exhaustive; derivatives like Agentic Memory layers events for contextual recall (https://appstekcorp.com/staging/8353/blog/design-patterns-for-agentic-ai-and-multi-agent-systems/).

Real-World Examples

  1. TD Bank Fraud Detection: Sources events for AI decisions in audits (https://podcast.emerj.com/governing-ai-for-fraud-compliance-and-automation-at-scale-with-naveen-kumar-of-td-bank). Fits regulatory needs.
  2. AstraZeneca AI Infrastructure: Tracks agent events in pharma research (https://podcast.emerj.com). Exemplifies science.
  3. Emerj AI Governance Tools: Uses sourcing for traceability (https://emerj.com). Matches consulting.
  4. Azure Event Sourcing Agents: Logs for compliance in finance (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Highlights cloud.
  5. IBM Hybrid AI: Sources events in multi-cloud setups (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026). Demonstrates enterprise.

Hypothetical Integrations with Non-AI Patterns

Event Sourcing for AI aligns with traditional Event Sourcing for state reconstruction. In Compensating Transaction, events enable rollbacks. Hypothetically, with Microservices, agents source events for distributed tracing (from IBM, https://www.ibm.com/think/news/ai-tech-trends-predictions-2026). In Pipe-Filter, events log pipeline stages.

Usage Contexts

In regulated sectors (e.g., banking or healthcare AI); stacks like EventStoreDB; streaming infra; IBM promotes for 2026 governance (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026).

12. Hierarchical Agents Pattern

Hierarchical Agents organize in levels, with supervisors overseeing workers for scalable autonomy. Postulated for 2026 scaling, neighbors Event Sourcing with structured event logs, similar to Orange’s kernel-slices for evolvability. Plugs into Multi-Agent for layered collaboration. Hypothetical but inspired by hybrids; stacks like LangGraph; graph-based systems. xAI explores for recursive self-improvement (https://twitter.com/jenslon_/status/2010402990666952868).

Sub-Patterns/Components

Level Decomposition assigns abstract goals top-down, e.g., executive agent sets strategy, managers break it down—for instance, in simulations, hierarchies manage complex swarms like city planning (https://www.milanjovanovic.tech/blog/what-is-a-modular-monolith). This ties to Project Manager for overseeing long-term goals. Supervision Layer monitors and adjusts lower levels; Feedback Propagation bubbles up results. Variant: Adaptive Hierarchy dynamically adds/removes levels.

Incomplete; nuanced like Worker-Orchestrator in repositories (https://github.com/FareedKhan-dev/all-agentic-architectures/).

Real-World Examples

  1. Cartesia Multimodal Hierarchies: Layers models for voice-video processing (https://twitter.com/ycombinator/status/2009671513931428244). Fits structured multimodal.
  2. YC Startup Agents: Hierarchical for startup simulations (https://www.youtube.com/watch?v=I3iMZuK8lIw). Exemplifies innovation.
  3. Clean Arch Hierarchical App: Layered agents in .NET for modularity (https://medium.com/@eda.belge/clean-architecture-with-modular-monolith-and-vertical-slice-896b7ee22e3e). Matches development.
  4. Azure Hierarchical Agents: Supervises in enterprise workflows (https://azure.microsoft.com/en-us/blog/agent-factory-the-new-era-of-agentic-ai-common-use-cases-and-design-patterns/). Highlights scale.
  5. IBM Watson Hierarchies: For complex decision trees in AI (https://www.ibm.com/think/news/ai-tech-trends-predictions-2026). Demonstrates governance.

Hypothetical Integrations with Non-AI Patterns

Hierarchical Agents mirror Class Table Inheritance for structured hierarchies. In Geode, distributes levels geographically. Hypothetically, with Microservices, top agents orchestrate service swarms (from DZone, https://dzone.com/articles/ai-agent-architectures-patterns-applications-guide). In Orange, hierarchies in slices for evolvable agents.

Usage Contexts

In large AI systems (e.g., enterprise simulations); stacks like GraphRAG; graph DBs; YC advocates for startup AI (https://twitter.com/agupta/status/2009674939062988846).

Glossary of Key Terms

  • Agentic AI: Autonomous systems that plan and act.
  • Prompt Engineering: Crafting inputs for optimal outputs.
  • ReAct: Reason-act-observe loop.
  • RAG: Retrieval-augmented generation.
  • Multi-Agent System: Collaborative agents.
  • Orchestrator: Manager of agents.
  • Reflection: Self-evaluation.
  • Tool Use: External capability invocation.
  • Planning: Task decomposition.
  • Few-Shot: Example-based learning.
  • Chain-of-Thought: Step-by-step reasoning.
  • Role Prompting: Persona adoption.

Out-of-Scope and Additional Sources

Focuses on agentic patterns, excluding non-AI like Serverless (https://serverlessland.com/patterns) or quantum AI (https://www.ibm.com/topics/quantum-safe). For more, see “Agentic AI Learning Path 2026” (https://www.analyticsvidhya.com/blog/2026/01/agentic-ai-expert-learning-path/), or ODSC podcasts (https://odsc.ai/blog/what-do-the-top-ten-episodes-of-odscs-ai-x-podcast-say-about-ai-today/).