Taxonomy of multi-agent design patterns, anti-patterns, and lessons from manufacturing

AWS's Machine Learning Blog published a taxonomy of multi-agent design patterns, anti-patterns and architecture guidance drawn from manufacturing, aimed at enterprise teams whose early multi-agent deployments have fallen short. The post's central claim is that the model is rarely the culprit: multi-agent coordination is a distributed systems problem, and many teams adopting it have not yet built distributed systems instincts.
The supporting numbers are stark. Roughly 88% of AI pilots never reach production, and the post cites Stanford HAI work showing two models can perform worse collaborating than either does alone when coordination overhead exceeds the benefit. It offers an illustrative reliability model: ten steps at 95% reliability each yield 59.9% end-to-end reliability, and twenty steps yield 35.8%. That model assumes a strictly sequential chain with no retries, but the direction is the point — every dependent handoff multiplies risk.
The taxonomy splits patterns by who controls the flow. In Tier 1, the developer defines the path; in Tier 2, the model chooses it at runtime. Tier 2 buys flexibility for work whose steps cannot be specified in advance, at higher token cost, latency and debugging burden. The recommended default is to start in Tier 1 and promote a task to Tier 2 only when its subtasks genuinely emerge during execution.
Tier 1 contains four patterns. The sequential pipeline runs A to B to C with the order fixed at build time, suiting document processing, ETL chains and warranty-claim triage, and is easy to test with predictable cost. The conditional workflow routes on logic, so a write-code then test-code loop can return passing work to deploy and send failures back for up to N retries before escalating to a human; that cap can be enforced by the orchestration layer, for example an AWS Step Functions iteration limit. The conditional router classifies input at the entry point and runs exactly one path — say, sending parts-spec questions to a quality agent and shift changes to a scheduling agent. The parallel workflow fans work out to independent handlers on their own data and fans in when all complete, so latency equals the slowest branch rather than the sum, and a failed branch retries alone.
Tier 2 hands control to the model. Plan-based orchestration casts one agent as a project manager holding an explicit plan with assignments and dependencies; workers are stateless and see only their slice, so one failure does not contaminate the others and only the failed worker is retried. The handoff pattern uses peer-to-peer delegation among agents with limited local knowledge, and the post is emphatic that control must pass with validated task state, supporting evidence and open questions — a transfer that moves only conversation is not a handoff. The conversation-driven or group-chat pattern lets orchestration emerge from turn-taking, with every agent seeing all messages and state living implicitly in the history; turn order can be round-robin for predictability or model-selected. Debate and consensus has independent agents evaluate the same input without seeing each other's reasoning, then reconcile by majority, a judge agent or escalation, which is what makes disagreement informative. It is the most expensive pattern and, the post says, buys latency rather than accuracy on perceptual tasks, so it should be reserved for high-stakes, low-volume decisions.
In practice, the post argues most production systems mix patterns by task decomposition: deterministic workflows for well-understood components, autonomous patterns where adaptation matters, consistent termination and delegation handling across all types, and hierarchical compositions where different layers use different patterns. The governing principle is pattern-to-task alignment rather than forcing everything through one approach.
Five anti-patterns get called out. The god agent assigns one prompt fifteen or more tools across overall equipment effectiveness analysis, PLC diagnostics and maintenance, degrading tool selection and making failures hard to attribute; the fix is bounded agents with five tools or fewer. Unbounded iteration lets an agent loop on retry with no hard stop, multiplying coordination failures rather than fixing them; limits belong in infrastructure — iteration ceilings, per-agent token caps and budget alarms wired to an automatic stop — because the model will not stop itself. Natural-language contracts pass free-text prose between agents with no schema, so interpretation hardens at each hop, with the drift concentrated where tracing is weakest. Premature multi-agent adds a coordination tax that is not linear, with gains flattening around four agents; the bar is at least two different models, different tool access, concurrent execution and real interdependency, and the test is whether one agent could handle the phases by switching tools. Unguarded customer contact lets agents trigger emails, service visits or machine parameters with no approval, and the fix is defense in depth from recommendation through Amazon Bedrock Guardrails, schema validation, business rules and human approval to execution.
The architecture decision reduces to four questions: whether the task requires action beyond text generation, whether the solution path is known in advance, whether the work needs genuinely distinct expertise, and whether the solution emerges only through exploration. The first two generally land on a direct model call or a single agent with tools; Tier 2 earns its overhead only when subtasks themselves are discovered mid-work. The manufacturing section adds four constraints that sharpen the arithmetic. Production-line latency converts directly to lost revenue — automotive body shops often run at 60 jobs per hour with 60-second takt times across more than 40 stations, so latency should be budgeted at p99, the tail that stops the line, with a sub-second deterministic fallback matched to risk. Safety has physical consequences, including OT/IT state desync and hallucinated safety boundaries, so agents should observe, analyze and recommend rather than actuate, with safety constraints held in an external deterministic service and approvals graded from autonomous resolution to operator click, engineer decision or management sign-off. Data lives at the edge: a single stamping press can generate 50+ GB per day whose value decays in milliseconds, favouring hybrid edge-cloud deployments such as AWS IoT Greengrass where the edge agent recommends and the PLC acts.
Why it matters: teams building agentic products now have a concrete default — start with a single agent or a Tier 1 workflow, enforce retry and token limits in code, and use schemas at every agent boundary — which reframes multi-agent design as reliability engineering rather than prompt craft. This suggests the near-term winners may be teams that can reason about coordination cost and tail latency, since, by inference, the same coordination overhead that erodes reliability also erodes margins and on-time performance. The open question the post leaves is measurement: knowing when a task has crossed the threshold into Tier 2 requires instrumentation most teams are only beginning to build.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
Multi-agent coordination is a distributed systems problem, not a model problem. This post gives a field-tested taxonomy of multi-agent design patterns and anti-patterns, a framework for deciding when multiple agents are warranted, and how to build cost-efficient, reliable systems on AWS.