AWS blog sorts multi-agent coordination into deterministic and autonomous patterns
AWS published a guide on 16 November 2026 that splits multi-agent coordination into two tiers: developer-defined flows and model-chosen flows. Its default advice is to start with the developer-defined tier.
If you are deciding whether a use case needs several agents, the post gives a concrete order of operations: fixed workflows first, autonomy only when subtasks can't be known in advance. It also shows how quickly reliability drops as dependent steps pile up.

AWS published a post on its Machine Learning Blog on 16 November 2026 that groups multi-agent coordination into two tiers: flows the developer defines and flows the model decides at runtime. It also lists anti-patterns to avoid. The post is AWS's own guidance, labelled Advanced (300) and Best Practices.
What happened
The post argues that when enterprise multi-agent systems disappoint, the model is rarely the cause. In its framing, coordination between agents is a distributed systems problem, and many teams haven't yet built the habits that discipline requires. It cites a figure of about 88% of AI pilots never reaching production, and a Stanford HAI result that two collaborating models can do worse than either alone when coordination overhead outweighs the benefit.
The authors' practical rule: begin with Tier 1, where you define the path, and move a task to Tier 2, where the model picks the path, only when its subtasks emerge during the work. Tier 2 handles work you can't map in advance, at a higher cost in tokens, latency and debugging.
Key details
Why chaining agents gets risky
AWS offers an illustrative model: if every step in a straight chain is 95% reliable, overall reliability falls quickly. The authors note the model ignores retries, but say the direction holds, because each dependent handoff multiplies risk.
| Steps in the chain | Overall reliability |
|---|---|
| 10 | 59.9% |
| 20 | 35.8% |
Tier 1: you define the control flow
- Sequential pipeline: output of agent A feeds B, then C. The order is fixed at build time, so it is easy to debug and its cost is predictable. Suggested fits: document processing, ETL chains and warranty-claim triage.
- Conditional workflow: logic-based edges choose the next step. In the example, code is written, tested, then deployed on a pass. A failure loops back for up to N retries before escalating to a human. The post says an orchestration layer should enforce that cap, and names an AWS Step Functions iteration limit as one way, so the loop doesn't become the unbounded-iteration anti-pattern.
- Conditional router: a classifier sends each request down exactly one path. The example routes a plant supervisor's request to a Quality, Maintenance or Scheduling agent.
- Parallel workflow: a task splits into independent subtasks that run at once, then a fan-in step combines results. A failure retries only its own path. Latency equals the slowest single agent rather than the sum of all three.
Tier 2: the model decides the control flow
- Plan-based orchestration: one orchestrator keeps an explicit plan and hands each stateless worker only its slice of context. If a worker fails, only that worker is retried.
- Handoff: agents with limited local knowledge delegate peer to peer. Control passes together with validated task state, the supporting evidence and open questions. The post says a handoff that only moves through the conversation is not a real handoff.
- Conversation-driven (group chat): all agents see one shared conversation, and a selection mechanism picks the next speaker, either round-robin or model-driven. State lives implicitly in the history.
- Debate/consensus: agents evaluate the same input independently, and a majority, judge agent or escalation reconciles them. Because they don't see each other's reasoning first, disagreement stays informative. The post calls it the most expensive pattern and says it should be reserved for high-stakes, low-volume decisions. On perceptual tasks such as quality inspection, it says debate buys latency rather than accuracy.
Hybrids
The post says most production systems mix patterns: workflows for predictable parts, autonomous patterns where flexibility matters. The portion of the post reviewed here ends partway through this discussion. Its sections on manufacturing constraints (takt time, safety boundaries, edge data and shift cycles) are previewed in the introduction but not covered in that excerpt.
Why it matters
For developers, the useful part is the decision order. A fixed pipeline or router is cheaper to test and bound than an agent that plans its own steps, so autonomy has to earn its place. Possible uses of the guidance, not demonstrated in the post: put a retry cap in orchestration code rather than in a prompt, and pass structured state in handoffs instead of a chat summary.
The patterns are AWS's taxonomy, and the reliability figures come from an illustrative model, not a measured benchmark. For related AWS agent infrastructure, see the next-generation AgentCore runtime and a serverless MCP server for data lake access.
Checked claims
| Claim | Status | Evidence |
|---|---|---|
| AWS frames multi-agent coordination as a distributed systems problem rather than mainly a model problem. | confirmed | Multi-agent coordination is a distributed systems problem |
| AWS recommends starting with developer-defined flows and moving to model-chosen flows only when subtasks emerge during the work. | confirmed | The practical default is to start with Tier 1 and move a task to Tier 2 only when its subtasks emerge during the work. |
| In the parallel workflow, latency is set by the slowest agent, not the total of all agents. | confirmed | Latency equals the slowest single agent rather than the sum of all three. |
| The post says a handoff must carry state, not only conversation. | confirmed | A handoff that moves only through the conversation is not a handoff. |
| AWS describes debate/consensus as the most expensive of the patterns and advises sparing use. | confirmed | Debate is the most expensive pattern here |
| The post cites a figure that most AI pilots never reach production. | confirmed | ~88% of AI pilots never reach production |
Found a mistake? Use Report above; an editor reads every one. Editorial policy
Question for readersWhen you build agent systems, what made you move a step from a fixed workflow to letting the model choose the path, and did it pay off?
Discussion · 0
No comments yet. Start the discussion.
Sign in to join the discussion.