Agent Architecture Patterns: 2026 taxonomy.

Agent architecture vocabulary stabilized in 2024-2026 around eight canonical patterns. The patterns span four quadrants — single-agent, collaborative multi-agent, competitive multi-agent, and orchestration topology — and most production agent systems are compositions of two or three from across those quadrants.

This taxonomy reference walks the eight patterns with reference papers, when-to-use guidance, failure modes, and framework support across LangGraph, AutoGen, CrewAI, OpenAI Agents SDK, and Microsoft Agent Framework.

Use it as the architecture-decision document when you scope a new agent project. Most teams over-engineer toward multi-agent topologies before single-agent reaches its quality ceiling. The taxonomy clarifies when escalation is warranted.

One model orchestrating its own loop. The default starting point for agent design.

Pattern 1: ReAct (Reasoning + Acting). Yao et al. (2022). The model alternates a "thought" trace with an "action" call, using each observation to update its next thought. The canonical agent loop and still the right default for general-purpose agents.

When to use: general agent tasks where reasoning and tool use interleave naturally; tasks under ~30 steps without complex coordination.

Failure modes: long-horizon coherence loss past ~50 steps; repeated identical mistakes when no reflection mechanism is added; cache invalidation in long runs.

Mitigations: add Reflexion for repeat-failure issues; add re-anchor checkpoints at ~40 steps to manage cache invalidation.

Pattern 2: Reflexion. Shinn et al. (2023). ReAct plus an explicit self-critique step after each iteration; the critique is appended to context as guidance for the next attempt. Reduces repeated failure modes on long-horizon coding and reasoning tasks.

When to use: tasks where the model has been observed to repeat the same mistake across attempts; coding and math reasoning workloads.

Failure modes: latency tax (extra model call per step); over-correction can cause oscillation; critique quality degrades on subjective tasks.

Mitigations: bound the critique-revise cycle to 2-3 attempts; pair with rubric-based critique for subjective tasks.

Multiple agents working together toward shared goal. Adds coordination overhead in exchange for parallelism or specialization.

Pattern 3: Plan-and-execute. Two-phase loop: planner agent emits an ordered plan; executor agent (often a different, cheaper model) walks the plan one step at a time. Cheaper at scale; brittle when plans need mid-run adaptation.

When to use: predictable workflows with known structure; tasks where planning time can be amortized across many similar runs.

Failure modes: plan brittleness when the world changes mid-execution; planner-executor capability mismatch; over-optimization for plan completion versus user goal.

Mitigations: add re-plan triggers on execution failures; use planner with stronger reasoning model than executor; bound plan length.

Pattern 4: Supervisor-worker. Hierarchical multi-agent. Supervisor agent decomposes tasks into sub-tasks routed to specialized worker sub-agents. Each worker runs its own loop; supervisor aggregates and decides whether the overall task is complete.

When to use: tasks decomposable into clear sub-tasks (research with topic-specific subagents, multi-domain reasoning); workloads benefiting from worker specialization.

Failure modes: coordination overhead can dominate simple tasks; supervisor drift; sub-task conflicts not surfaced to supervisor.

Mitigations: set explicit interface contracts between supervisor and workers; require structured outputs from workers; bound sub-task budgets.

Multiple agents in tension or critique relationship. Used for quality and safety improvement, not parallel work.

Pattern 5: Multi-agent debate. Two or more agents argue different positions; a separate judge or synthesizer agent draws the conclusion. Used for decisions where multiple perspectives matter or where adversarial stress-testing improves output.

When to use: high-stakes decisions where considering counter-positions matters; safety-critical evaluations; brainstorming where divergent thinking is desired.

Failure modes: agents converge prematurely; adversarial agents weaken on long debates; judge bias toward verbose arguments.

Mitigations: bound debate rounds; require structured arguments; rotate judge identity to reduce bias.

Pattern 6: Verifier-critic. A generator agent produces output; a critic agent scores or annotates the output against a rubric; the generator revises based on critique. Standard pattern for catching hallucinations and policy violations in production.

When to use: outputs requiring high accuracy or policy compliance; safety filtering; quality regulation in content generation.

Failure modes: critic-generator collusion when both use same model; over-correction on edge cases; critique quality degrades on subjective dimensions.

Mitigations: use different models for generator and critic when possible; cap critique-revise cycles; pair with human review for low-confidence outcomes.

How multi-agent systems are wired together. The topology governs coordination overhead, fault tolerance, and observability.

Pattern 7: Graph orchestration. Agents arranged as nodes in a directed graph with explicit edges for control flow. LangGraph and Microsoft Agent Framework implement this canonically. Strong observability; deterministic flow.

When to use: structured workflows with defined decision points; production systems requiring trace-level debugging; conditional logic across multiple agents.

Failure modes: graph complexity grows fast; edge cases not covered; cyclic execution requires careful termination.

Mitigations: bound graph node count; require terminal nodes; instrument every edge with metrics.

Pattern 8: Swarm / blackboard. Peer-agent topology with no supervisor. Agents post and read from a shared blackboard or message bus. OpenAI's swarmreference and AutoGen's group chat fall under this pattern.

When to use: exploratory tasks where the right decomposition isn't known up front; research and brainstorming; systems with naturally peer-equivalent agents.

Failure modes: goal drift without supervisor anchor; coordination dead-locks; debugging difficulty.

Mitigations: add a coordinator role even if not full supervisor; instrument the message bus heavily; bound agent budget to prevent runaway.

How the canonical patterns map across the major agent orchestration frameworks as of Q2 2026.

LangGraph. LangChain's graph orchestration framework. Strong on Pattern 7 (graph) by design. Supports ReAct, Reflexion, plan-and-execute via prebuilt patterns. Supervisor-worker via subgraphs.

AutoGen. Microsoft Research's multi-agent framework. Strong on Patterns 4 (supervisor-worker), 5 (debate), 8 (swarm via group chat). ReAct and Reflexion via single-agent mode.

CrewAI. Role-based multi-agent framework. Strong on Pattern 4 (supervisor-worker) via crew/task metaphor. Supports verifier-critic via task chains.

OpenAI Agents SDK. Native multi-agent primitives in the OpenAI SDK. Supports Patterns 1, 2, 4, 7 via Handoff and tool calling. Swarm via the swarm reference implementation.

Microsoft Agent Framework. .NET- and Python-native agent framework. Strong on graph orchestration; supports all canonical patterns.

How to pick the right pattern for a given workload. Decision-tree style: start with the simpler option; escalate only when measurement justifies.

Step 1: Start with ReAct. Build a single-agent ReAct baseline. Measure success rate, tool-call accuracy, latency, and cost on your evaluation set.

Step 2: Add Reflexion if failures repeat. If your eval shows the agent making the same mistake across multiple runs, add Reflexion. Latency increases by ~30%; quality typically improves 10-30% on the failure-mode subset.

Step 3: Add re-anchor if loops exceed 30 steps. For long-running agents, add re-anchor checkpoints to manage cache invalidation. Prevents the silent prefix-cache miss that can spike costs 5-10×.

Step 4: Add verifier-critic for high-stakes outputs. If output quality matters (legal, financial, code), add a verifier-critic loop. Doubles inference cost on the verified subset; cuts critical errors.

Step 5: Move to multi-agent only when single-agent caps out. Multi-agent adds coordination overhead. Justify with measured gain on a specific failure mode that single-agent can't address (parallel work, role specialization, perspective diversity).

Step 6: Choose hierarchy or graph for production multi-agent. Avoid swarm in production; use it in research mode only. Hierarchy when task decomposition is clear; graph when control flow is conditional and needs observability.