Amazon Web Services published a multi-agent coordination taxonomy on November 16, 2026, arguing that when enterprise agent pilots stall, the bottleneck is usually orchestration, not the foundation model. The AWS Machine Learning blog post blends distributed systems framing with manufacturing constraints like takt time, safety boundaries, and shift cycles.
If you are wiring Amazon Bedrock Agents, Step Functions, or third-party harnesses on AWS, this is the closest official pattern language we have seen for when to add a second agent.
TL;DR
| Question | Answer |
|---|---|
| Core claim | Multi-agent coordination is a distributed systems problem |
| Tier 1 | Developer-defined flows: pipeline, conditional, router, parallel |
| Tier 2 | LLM-chosen flows: planner, handoff, conversation |
| Reliability math | 10×95% steps ≈ 59.9% end-to-end without retries |
| Default advice | Start Tier 1; move to Tier 2 only when steps are unknowable upfront |
Why AWS borrowed manufacturing language
Shop floors already live with handoffs, safety interlocks, and cycle-time budgets. The AWS authors map those instincts onto LLM agents instead of treating every workflow as a free-form group chat.
That choice matters for readers comparing this to generic agent framework marketing. Manufacturing forces bounded loops, human escalation, and one-path-per-ticket routing, which are the same guardrails production teams need when agents touch live systems.
The post opens with a blunt statistic shape readers have seen elsewhere: a large share of AI pilots never reach production, and Stanford HAI experiments where two models underperform either alone when coordination tax dominates. AWS does not ask you to avoid multi-agent designs; it asks you to earn them with a pattern pick and retry budget.
Tier 1 patterns you can diagram in Step Functions
Sequential pipeline
AWS sequential pipeline diagram for multi-agent extract transform validate flows in manufacturing
Image: Amazon Web Services
Sequential pipelines run A → B → C with no runtime branching: extract, transform, validate. AWS highlights predictable cost and straightforward tests. Warranty-claim triage and document ETL are canonical fits.
This is the pattern most teams should prototype first inside Amazon Bedrock AgentCore evaluation playbooks before adding autonomy.
Conditional workflow with bounded retries
The conditional workflow adds pass/fail gates. Code flows to test, failures loop to author agents up to N tries, then human escalation. AWS explicitly recommends Step Functions iteration limits so the loop cannot become an unbounded iteration anti-pattern.
That mirrors how explainx.ai covered Claude for Manufacturing skills: structured approvals beat open-ended agent chatter when money and safety are on the line.
Conditional router
A router classifies once and sends work down exactly one specialist path. The blog's plant-supervisor example routes quality, maintenance, or scheduling intents without running all three chains.
Use routers when intents are enumerable but processing differs. Do not use them when the user needs multi-specialist synthesis in one answer; that is a parallel fan-out job.
Parallel workflow
Parallel patterns fan out to independent analysts, then fan in with conflict resolution. Latency tracks the slowest branch, not the sum, which is how research and incident-response squads already work.
Conductor shape coordinating several agents, suggesting parallel fan-out before synthesis
Tier 2 patterns when the path is not knowable upfront
Tier 2 lets the LLM choose control flow. AWS warns this buys flexibility at the cost of tokens, latency, and debuggability.
Plan-based orchestration keeps a planner with global context assigning stateless workers. Failed workers retry individually, not entire workflows.
Handoffs move validated state between peers. AWS stresses that handing off conversation summaries without structured state is not a handoff.
Conversation-driven patterns emulate group chat turn-taking. They can work for creative tasks but explode context unless you enforce compaction policies like those in our prefix cache guide with Together AI.
Reliability budgeting: the 95% chain
The illustrative math is worth tattooing on your runbook:
| Steps | Per-step success | End-to-end (no retry) |
|---|---|---|
| 10 | 95% | 59.9% |
| 20 | 95% | 35.8% |
Real systems add retries, circuit breakers, and human gates, but AWS uses the table to argue against ten-agent chains unless each step is cheap to verify.
Pair this with Amazon Quick agentic primitives taxonomy: triggers should fire short graphs unless telemetry proves otherwise.
Tier 2 extras: debate, hybrids, and shop-floor timing
AWS goes beyond the three autonomous patterns to debate/consensus, where agents do not see each other's reasoning before committing. The post warns this is expensive and can buy latency without accuracy on perceptual tasks. Reserve it for low-volume, high-stakes calls where being wrong costs more than tokens.
Hybrid compositions mix Tier 1 DAG pieces with Tier 2 islands. Example: a router sends warranty photos to a vision tool chain, while an escalation planner only spins up when the classifier confidence drops.
Manufacturing readers should map takt time onto agent SLAs: if a conditional workflow must finish before the next line pulse, your iteration cap is not negotiable. That is why AWS keeps pointing to Step Functions limits instead of hoping the LLM stops.
Anti-patterns AWS names explicitly
The post warns against:
- Unbounded loops without escalation caps
- Conversation-only handoffs missing structured state
- Parallel agents when tasks are actually sequential and audit-sensitive
- Tier 2 planning on workflows with a known DAG
Manufacturing readers will recognize these as the agent version of bypassing interlocks or running parallel QA on a single serial line.
God agent
One agent with fifteen tools for OEE, PLC diagnostics, and maintenance drafting sounds efficient until tool selection degrades and failures become untraceable. AWS recommends bounded agents with five tools or fewer, each with a narrow charter.
Unbounded iteration
A retry loop with no hard stop can burn token budgets silently. AWS insists infrastructure enforces ceilings because models will not stop themselves. Wire budget alarms to automatic escalation.
Natural-language contracts
Passing prose summaries between agents lets "could indicate wear" become "confirmed wear" and then a maintenance order. Use schemas at trust boundaries.
Premature multi-agent
If one agent can switch tools across phases, you do not need four costumes on the same model. AWS wants evidence of different models, different tool access, concurrency, and real interdependency before you pay coordination tax.
Unguarded customer contact
Agents that email customers or change machine parameters without human approval move hallucinations into the physical world. AWS lists Guardrails, schema validation, business rules, then human sign-off before execution.
Mapping patterns to AWS services
The blog is vendor-aligned but still useful off AWS:
| Pattern | AWS-shaped implementation | Portable idea |
|---|---|---|
| Sequential pipeline | Step Functions + Bedrock agents | DAG with typed IO |
| Conditional router | Classifier Lambda + branches | Single dispatch path |
| Parallel fan-out | Map state + fan-in reducer | Slowest-branch latency |
| Planner/worker | Supervisor agent + stateless workers | Retry single worker only |
| Handoff | Structured payload store | No summary-only transfers |
If you already run OpenAI Codex on Bedrock, treat AgentCore gateways as the trust boundary where schemas must attach.
Choosing a pattern: AWS decision tree
AWS includes a decision tree figure asking whether work needs actions, a known path, distinct expertise, or exploration. Practically:
- If steps are fixed, build Tier 1 in infrastructure-as-code.
- If only routing is fuzzy, use a router plus specialists, not a planner.
- If discovery is the product, adopt Tier 2 with observability and budget caps.
Edge data, safety boundaries, and shift cycles
AWS ties manufacturing lessons to edge data freshness and safety interlocks. Agents that recommend parameter changes on a line must respect human-in-the-loop rules when safety PLCs are involved. Shift handoffs need structured state so the night crew does not inherit a conversation summary missing lot numbers.
Digital twin feeds and historian tags should enter agents through typed tools, not pasted CSV dumps, to keep Tier 1 graphs testable.
Evaluation playbook for multi-agent pilots
Before production:
- Single-agent baseline on the same eval set with identical tools.
- Chaos tests that kill one worker mid-flight; planners should retry only failed workers.
- Token budgets per work order with automatic escalation at 80% spend.
- Schema validators on every handoff payload.
- Incident replay from Step Functions execution history, not chat logs alone.
Document which pattern each workflow uses in your runbook. Future you will forget why a fourth agent exists.
How to apply this on AWS this week
- Sketch your workflow as a DAG before picking agent personas.
- Implement iteration caps in Step Functions even if the LLM begs for more tries.
- Store handoff payloads as JSON schema, not prose, when crossing trust boundaries.
- Measure p95 latency per hop; manufacturing takt thinking applies to token time too.
- Compare against a single-agent baseline on the same eval set before celebrating architecture.
Related reading
- Amazon Quick agentic primitives taxonomy
- Claude for Manufacturing plugin skills
- Bedrock AgentCore evaluation playbook
- OpenAI Codex on Bedrock and AgentCore gateway setup
- Google Orchestra multi-agent research writing
- Envisioning agentic robotics survey
- Together AI prefix caching for long agent sessions
Sources: AWS ML blog taxonomy.
