Architectural Patterns
Builders choosing a multi-agent topology for their use case. If you already know which pattern fits, see the Selection Guide for scenario-to-pattern matching. If you haven't deployed anything yet, start with Get Started.
Multi-agent patterns supported by AgentCore and the Strands SDK. Choose based on your use case, complexity, and execution requirements.
Pattern Catalog
12 patterns organized into three tiers based on documentation maturity and production evidence. All are deployable on AgentCore Runtime.
Tier labels indicate where patterns are documented and evidenced, not their production readiness. Tier 1 patterns have official documentation in the Strands Agents SDK and AgentCore Samples. Tier 2 patterns have published customer evidence. Tier 3 patterns are well-known industry patterns applicable on AgentCore but without specific AgentCore documentation.
Tier 1 - Documented in Strands SDK and AgentCore Samples
Single Agent + Tools
One agent with multiple tools connected via AgentCore Gateway. The simplest production pattern - ideal for most initial deployments.
Example: BGL - NL-to-SQL Agent
Source: Strands SDK - Tools
Low ComplexityAgents-as-Tools (Subagents)
Parent/orchestrator invokes child agents as callable tools. Hierarchical delegation with the parent deciding which child to invoke.
Example: Thomson Reuters - Platform Hub
Source: Strands SDK - Agents-as-Tools
Medium ComplexityGraph Pattern
Developer-defined flowchart where the LLM decides the path at each node. Supports conditional logic, branching, and loops.
Example: Iberdrola - IT Ops
Source: Strands SDK - Multi-Agent Patterns
Medium ComplexitySwarm Pattern
Dynamic collaborative team where agents autonomously hand off tasks to each other. Emergent execution path - no predefined orchestration.
Source: Strands SDK - Multi-Agent Patterns
Medium-High ComplexityWorkflow Pattern (DAG)
Pre-defined task graph with deterministic execution. Independent tasks run in parallel. No cycles allowed - pure directed acyclic graph.
Source: Strands SDK - Multi-Agent Patterns
Medium ComplexityAgent-to-Agent (A2A Protocol)
Peer agents communicate via the open A2A protocol. Cross-platform, cross-framework interoperability for federated agent ecosystems.
Source: Strands SDK - Agent-to-Agent
High ComplexityTier 2 - Production-Proven Patterns (Customer Evidence)
Human-in-the-Loop (HITL)
Agent pauses execution for human approval on high-risk actions. Async event-driven — the agent yields, waits for approval via a callback mechanism (such as Step Functions callback tokens, Lambda Durable Functions callbacks, or session persistence), then resumes. See the implementation guide for working code across frameworks.
Example: Thomson Reuters
Medium ComplexityBot Factory / Platform
Reusable blueprint for standardized agent creation. Teams self-serve agent deployment using pre-approved templates, tools, and guardrails.
Example: AutoScout24 - Bot Factory
High ComplexityRAG-Augmented Agent
Retrieves enterprise data to ground responses in facts. Tool-use pattern where retrieval is one of several tools available to the agent.
Example: BGL - Knowledge-Grounded Agent
Low-Medium ComplexityTier 3 - Industry Patterns Applicable on AgentCore
Router / Dispatcher
Classification agent routes incoming requests to downstream specialist agents based on intent, channel, risk level, or domain.
Medium ComplexityPlan-Act-Reflect
Agent plans a multi-step approach, executes each step, reflects on results, and iterates. For complex tasks requiring strategic decomposition.
High ComplexityReflection / Self-Check
A second agent reviews the primary agent's output before returning it to the user. Quality gate for regulated industries.
Medium ComplexityHow Execution Paths Differ
Understanding how each pattern determines its execution path is key to selecting the right one.
| Pattern | Path Determined By | Cycles? | Parallelism? |
|---|---|---|---|
| Graph | LLM decision at each node | Yes | No |
| Swarm | Agents autonomously decide handoffs | Yes | No |
| Workflow (DAG) | Fixed dependency graph (DAG) | No | Yes |
| Agents-as-Tools | Parent agent decides | Yes (re-call) | Depends |
| A2A | Peer agents negotiate | Yes | Yes |
Patterns by Archetype
Which patterns are most relevant for each agent archetype.
| Pattern | Conversational | Event-Driven | Coding Agents |
|---|---|---|---|
| Single Agent + Tools | ✅ Core pattern | ✅ Trigger handler | ✅ IDE assistant |
| Agents-as-Tools | ✅ Multi-domain | ✅ Pipeline stages | ✅ Specialized sub-tasks |
| Graph | ✅ Complex flows | ✅ Decision trees | - Rare |
| Swarm | ✅ Collaborative | - Less common | ✅ Multi-file refactor |
| Workflow (DAG) | - Rare | ✅ Batch pipelines | ✅ CI/CD orchestration |
| A2A Protocol | ✅ Cross-platform | ✅ Federation | ✅ Tool marketplace |
| Human-in-the-Loop | ✅ Approvals | ✅ Escalation | ✅ Code review gate |
| Bot Factory | ✅ Platform teams | ✅ Standardization | - Less common |
| RAG-Augmented | ✅ Knowledge Q&A | ✅ Context enrichment | ✅ Codebase search |
| Router / Dispatcher | ✅ Intent routing | ✅ Event classification | - Rare |
| Plan-Act-Reflect | - Rare | - Rare | ✅ Complex tasks |
| Reflection / Self-Check | ✅ Regulated | ✅ Compliance | ✅ Code quality |
Further Reading
- Strands Multi-Agent Patterns — orchestrator, swarm, graph, workflow
- Strands A2A Docs — cross-framework agent communication
- Strands Agents-as-Tools — hierarchical delegation
- Strands Deploy Guide — deploying to AgentCore Runtime
- Well-Architected Agentic AI Lens — multi-agent reliability, cost, and security guidance
- Memory-Augmented Agents (Prescriptive Guidance) — patterns for the RAG-augmented pattern
- Step Functions Human Approval — callback mechanism for the HITL pattern
- Lambda Durable Functions — code-based durable callback mechanism for the HITL pattern