What Are Agentic Design Patterns? 2026 Pattern Catalog

The agentic design pattern approach is a reusable architecture catalog for LLM systems because it provides a selection framework for organizing patterns and control models.

What Is an Agentic Design Pattern?

An agentic design pattern is a reusable solution to a recurring coordination problem that appears when LLM-driven systems make decisions at runtime rather than following fixed code paths. Traditional software design patterns assume deterministic actors and known control flow. Agentic patterns address what changes when the actor is a probabilistic model that can choose its next tool call, revise its own output, or hand work off to another agent.

The distinction matters for three practical reasons:

• Runtime decisions create new failure modes. Infinite reflection loops, hallucinated tool calls, and runaway token spend do not exist in deterministic systems. Agentic patterns name the controls that prevent them.
• Coordination becomes a first-class concern. Once more than one agent or step is involved, the system needs explicit patterns for delegation, evaluation, and handoff. The same problems exist in distributed systems, though the actors here are model calls rather than services.
• Auditability shifts from code to trajectory. With workflows, every step is traceable in the source. With agents, the trace lives in the run, which forces patterns around logging, bounded execution, and human approval.

Readers brand new to the topic can think of agentic patterns as the engineering vocabulary for "what controls do I add around a model that decides for itself." The rest of this catalog names those controls, groups them, and shows when each one is worth adopting.

The Pattern Fragmentation Problem

Engineering teams shipping agentic systems today often select patterns from partial taxonomies rather than a single shared catalog. One team reads Andrew Ng's four foundational patterns and builds a reflection loop. Another reads Anthropic's workflow taxonomy and implements prompt chaining. A third discovers a 21-pattern community catalog on GitHub and realizes both teams missed entire categories. Three teams end up working from three vocabularies for the same problem.

Pattern fragmentation changes selection decisions across latency, cost, auditability, and failure boundaries because workflows use predefined execution paths while agents decide next steps at runtime. The vocabulary has expanded across vendor guides, practitioner catalogs, and academic taxonomies. This catalog walks through the taxonomy, the workflow-versus-agent boundary, selection criteria, framework implementations, anti-patterns, a worked example, and lifecycle fit.

Augment Cosmos is the unified cloud agents platform with shared context and memory that compounds across the team and the software development lifecycle, so the patterns below map directly to a production runtime rather than staying as theory.

Workflows vs. Agents: The Architectural Boundary

The workflows-versus-agents boundary separates two control models: predefined execution order in code, and runtime delegation by the model. Anthropic's December 2024 "Building Effective AI Agents" post highlighted the distinction that informs many pattern selection decisions.

Both qualify as agentic systems, though the engineering implications differ by control model. Workflows provide predictability through predefined execution paths, which makes every step traceable. Agents provide flexibility through runtime decision-making, which increases the need for trajectory logging and execution controls.

The 12 Foundational Agentic AI Design Patterns

Foundational agentic AI design patterns come from multiple taxonomies: four patterns from Andrew Ng, five workflow patterns from Anthropic, and three additional patterns that clarify control, topology, and implementation choices. The sections below cover each in turn before consolidating them into a single reference table.

Andrew Ng's Four Core Patterns (2024)

Andrew Ng's four core patterns define one early agentic framework with four distinct mechanisms for output revision, tool access, task decomposition, and coordination. Andrew Ng named and published these four foundational agentic AI patterns in The Batch newsletter at DeepLearning.AI:

1. Reflection. The agent generates an initial output, critiques it for errors or quality gaps, then produces a revised output across multiple iterations. Ng describes Reflection as a pattern in which the LLM examines its own work to improve it. One specific research architecture in this family is the Reflexion paper, which adds episodic memory across trials beyond same-turn critique.

2. Tool Use. The agent calls external APIs for information missing from model weights: current information, code execution, and proprietary data sources. Tool Use is the most established execution pattern in this catalog and serves as a building block for many other patterns.

3. Planning. The agent breaks large tasks into smaller subgoals and handles complex tasks through decomposition, including self-criticism and refinement over past actions. Ng explicitly flagged Planning as "less mature, less predictable" than Reflection and Tool Use.

4. Multi-Agent Collaboration. Multiple specialized agents, each with its own prompt, LLM, tools, and custom code, work together on problems that exceed single-agent capabilities. The mechanism combines role specialization with coordination across agents, extending beyond a single prompt loop.

Anthropic's Five Workflow Patterns (2024)

Anthropic's five workflow patterns are structured orchestration patterns for multi-step processes that define the sequence and conditions under which agents execute tasks. Anthropic formalized five named workflow patterns in its engineering guide. The five-pattern framing reflects the original December 2024 post; some newer Anthropic materials group the same ideas under a smaller set of higher-level workflow shapes (for example, sequential, parallel, and evaluator-optimizer), so readers may encounter different counts depending on which document they reference.

5. Prompt Chaining. Output of one LLM call becomes input of the next in a deterministic pipeline. Use when tasks decompose "easily and cleanly into fixed subtasks."

6. Routing. Classifies input and directs it to specialized downstream processes. Enables separation of concerns across distinct task categories.

7. Parallelization. Multiple LLM calls run simultaneously with outputs aggregated programmatically. Two sub-variants exist: sectioning, which runs independent subtasks in parallel, and voting, which runs the same task multiple times.

8. Orchestrator-Workers. A central LLM dynamically delegates tasks to worker LLMs and synthesizes results.

9. Evaluator-Optimizer. One LLM generates, another evaluates against predefined criteria. The generator and evaluator have explicitly separated roles, which distinguishes this pattern from single-LLM Reflection.

Three Additional Foundational Patterns

The Ng and Anthropic taxonomies cover output revision, tool access, decomposition, and orchestration, but they leave gaps around approval gates, communication structure, and concrete reasoning loops. Human-in-the-Loop, topology patterns, and ReAct fill those gaps and round out the foundational set used throughout the rest of this catalog. ReAct predates Ng's 2024 framing by roughly two years and appears here as an earlier foundational reference. Together, these three patterns make the broader taxonomy easier to apply in production systems.

10. Human-in-the-Loop. A cross-cutting modifier insertable into any pattern as an approval gate, with "stopping conditions (such as a maximum number of iterations) to maintain control".

11. Topology Patterns (Chain/Star/Mesh). Recent academic literature on agentic community design describes three communication topologies for multi-agent systems: chain, star, and mesh.

12. ReAct (Reasoning + Acting). A concrete reasoning-and-acting approach, originally introduced in 2022, that supports dynamic plan creation and adjustment.

Consolidated Taxonomy

The consolidated taxonomy groups 12 foundational patterns by tier, year, and control role, which simplifies comparison across workflow patterns, agent patterns, guardrails, and implementation choices in one view.

Emergent Patterns from the 2025-2026 Catalog

Beyond the 12 foundational patterns, the 2025-2026 literature adds a wave of emergent patterns that address production constraints through context management, bounded execution, layered safety controls, memory, and meta-level orchestration. Pattern maturity varies across the set, so this section flags maturity alongside the mechanism. The three highlighted entries below are the most actionable today; the remaining patterns appear in the second table for completeness.

Highlighted Emergent Patterns

Each highlighted pattern has a primary reference. LangChain's writeup on context engineering for agents details the Context Engineering pattern. Bounded Execution and Circuit Breaker patterns appear in recent arXiv work on agent reliability. Microsoft's AI agent design patterns guide on Azure Architecture Center covers Guardrail Layering.

Context Engineering (P3) improves multi-agent operation through selection, compression, and isolation of context. Bounded Execution (P10) caps work within defined limits and reduces operational risk. Guardrail Layering (P11) places controls at four execution points (user input, tool calls, tool responses, and final output), giving teams multiple points to catch failures before they reach end users.

Additional Emergent Patterns

The patterns below appear repeatedly in 2025-2026 catalogs but have less converged naming or interfaces than the three highlighted above. They are still worth knowing about because each addresses a distinct production failure mode.

Teams evaluating these coordination approaches often benchmark them against current multi-agent orchestration platforms before deciding what to build versus what to adopt.

Pattern Selection: Five Tradeoff Dimensions

Pattern selection works best when teams match the observed failure mode to the minimum control mechanism that resolves it, because each additional pattern in the tradeoff matrix adds latency, cost, or coordination overhead. Anthropic's guidance sets the baseline: start simple, evaluate carefully, and add agentic structure only when simpler solutions fall short. The matrix below summarizes how the four core patterns compare across five dimensions.

Five Decision Rules

These five decision rules map common task shapes to the smallest useful pattern, which keeps teams clear of unnecessary coordination overhead and preserves controllability.

1. If the task resolves with a single LLM call plus tools, use Tool Use alone.
2. If output quality needs verification against objective, externally verifiable criteria, add Reflection.
3. If the task requires multi-step dependencies that cannot be pre-specified, use Planning (ReAct) with explicit iteration limits.
4. If the task genuinely requires specialized roles that exceed a single context, consider Multi-Agent.
5. Before adding any pattern, verify the benefits justify the costs by responding to observed failure modes more than anticipated requirements.

The combined effect of these rules is a smaller surface area to debug, observe, and govern as teams scale agentic work.

Worked Example: Selecting Patterns for an Automated PR Triage Agent

The decision rules are easier to apply against a concrete task. Consider a realistic engineering scenario: a team wants to ship an agent that triages incoming pull requests, applies labels, suggests reviewers, and flags PRs that look risky based on the files touched and the test coverage of the changed code.

Step 1: Start with Tool Use. The agent needs to read PR metadata, list changed files, and query coverage data. All three are deterministic API calls. A single LLM call plus three tools (get_pr, list_files, get_coverage) handles the labeling and reviewer suggestion. Rule 1 applies, so no further pattern is needed yet.

Step 2: Add Reflection only when verification fails. Initial evaluation shows the agent occasionally suggests reviewers who left the team. The failure mode is verifiable against an external source (the active members list), so Rule 2 applies. Reflection compares the suggested reviewers against the active list and revises if needed. Stop here unless something else breaks.

Step 3: Skip Planning unless dependencies emerge. The task does not have multi-step dependencies that change at runtime; the steps are known in advance. Rule 3 does not apply. Adding Planning here would add latency and loop risk without solving a real failure.

Step 4: Skip Multi-Agent unless roles diverge. Risk-flagging could plausibly become its own role (security review, performance review, compliance review), but for the current scope, a single agent with the right tools and one reflection step covers the work. Rule 4 does not apply yet. Multi-Agent becomes justified only when the team needs distinct reviewers, distinct prompts, and distinct evaluation criteria that cannot share one context.

Step 5: Layer in emergent patterns as guardrails. Before shipping, the team adds three emergent patterns: Bounded Execution (cap at five tool calls per PR), Guardrail Layering (validate tool inputs and outputs), and Trajectory Logging (record every decision for later evaluation). These are required in production, since they catch the failures the core patterns cannot.

The result is a working agent built from Tool Use, Reflection, and three emergent guardrails, with Planning and Multi-Agent held in reserve. The same step-by-step application of the rules works for most production tasks: start at Tool Use, climb only when a real failure mode forces the next pattern.

Framework Support Matrix

Framework support determines how directly a pattern maps into implementation primitives, and that mapping affects how much custom code teams must write. This matrix shows where common agentic patterns map cleanly to current frameworks and where teams should expect implementation overhead.

Legend: ✅ Native/first-class | ⚠️ Requires custom code | ❌ Not supported

Human-in-the-loop support varies by framework and typically appears as interrupts, checkpoints, guardrails, or approval and review workflows.

Note: Microsoft's AutoGen project is now in maintenance mode, and Microsoft's official recommendation for new projects is the Microsoft Agent Framework, which consolidates the AutoGen and Semantic Kernel lineages under one supported codebase. Separately, the AG2 0.9 release is a community fork maintained outside Microsoft for teams that want to stay on the original AutoGen API surface. For practitioner-grade comparisons of these frameworks in production, see this roundup of open-source agent orchestrators.

State of the Field: What's Production-Ready in 2026

Framework maturity moves quickly, so a pillar reference should orient readers on what is stable enough to standardize on versus what is still experimental. The table below summarizes the current state of the major frameworks and pattern categories as of mid-2026.

The overall pattern from this view: foundational patterns and the three highlighted emergent patterns are safe to standardize on, while memory and meta-level patterns warrant active monitoring with careful adoption.

Seven Anti-Patterns That Break Production Agentic Systems

Seven production anti-patterns break agentic systems through control gaps, weak safety placement, missing governance, and poor evaluation discipline. The recurring failure modes below show where otherwise capable agentic systems break once they face real tools, real costs, and real operational constraints.

The God Prompt and Over-Agentification draw on practitioner guidance, with the monolith-to-sub-agent decomposition pattern documented in Google's writeup on refactoring a monolithic AI agent. Output-Only Guardrails inverts the layered guardrail pattern recommended by Microsoft. The Berkeley CLTC agentic AI risk management standards profile addresses both Agent Sprawl and Governance as Afterthought, arguing for documentation, escalation pathways, and continuous monitoring from day one. Vibe-Checking as Testing aligns with Anthropic's eval recommendations.

Agent Sprawl deserves particular attention because scaling multi-agent systems increases coordination drift as more roles, prompts, and handoffs accumulate. Threat-specific patterns covering prompt injection, data exfiltration, and adversarial inputs sit outside this catalog and warrant their own treatment.

Agentic Patterns Across the Software Development Lifecycle

Agentic patterns map unevenly across software development lifecycle phases because some phases already fit deterministic workflows such as prompt chaining, routing, and CI-oriented review, while others still rely on emerging multi-agent coordination. Pattern maturity ranges from production-ready workflow patterns to emerging spec-driven orchestration and more experimental agentic DevOps and requirement agents.

The table below maps specific SDLC phases to the patterns that fit them best today, alongside the maturity of agentic adoption in each phase.

The lifecycle fit is uneven in three recurring ways:

• Deterministic workflows fit phases that already decompose cleanly into fixed subtasks (implementation, CI, release, documentation).
• CI-oriented review aligns more naturally with prompt chaining and routing than with open-ended delegation.
• Emerging multi-agent coordination appears more often in spec-driven orchestration, agentic DevOps, and requirement agents, where the structure is still being worked out in practice.

Match Each Pattern to the Problem Before Scaling Agent Complexity

Matching each pattern to the actual failure mode is the practical next step, because extra loops, handoffs, and worker roles increase coordination cost before they improve outcomes. Teams that follow the decision rules above stay on the minimum control mechanism for each failure mode, adding Reflection only when output verification fails, Planning only when multi-step dependencies emerge, and Multi-Agent only when the work exceeds a single role, context window, or service boundary.

For teams ready to put these patterns into production, Augment Cosmos is a unified cloud agents platform with shared context and memory that compounds across the team and the software development lifecycle. It is one option among the broader multi-agent orchestration platforms covered in the related listicle below, and readers should evaluate it against the rest of that landscape.

FAQ

Related

1. 7 Multi-Agent Orchestration Platforms: Build vs Buy in 2026
2. 9 Open-Source Agent Orchestrators for AI Coding (2026)
3. 7 Best AI Agent Observability Tools for Coding Teams in 2026
4. 9 Best AI Coding Agent Desktop Apps in 2026
5. 8 Best AI Coding Assistants (Updated May 2026)