AWS Lays Out When to Use Multi-Agent Systems, and When One Agent Will Do
AWS sorts multi-agent work into Tier 1 and Tier 2, names five costly anti-patterns, and adds factory rules plus Duco and MoEngage results you can reuse.
Enterprise teams do not fail at multi-agent systems because the model is weak. They fail because coordination is a distributed systems problem, according to a new AWS taxonomy of multi-agent design patterns. The post gives builders a practical decision path: start with the simplest architecture that works, add orchestration only for a measured reason, and reserve autonomous agents for work where subtasks emerge during the run.
The stakes are high. The taxonomy cites about 88 percent of AI pilots never reaching production, plus Stanford HAI work showing two models can perform worse together than alone when coordination cost exceeds benefit. Its reliability example is blunt: ten steps at 95 percent reliability each yield only about 59.9 percent end to end, and twenty steps yield about 35.8 percent, assuming a strict sequential chain with no retries. Every dependent handoff multiplies risk, so pattern choice is cost control.
Tier 1: define the path yourself
Tier 1 covers deterministic control flow where you define the path at build time. It is cheaper in tokens, latency, and debugging, and the post urges it as the default.
| Pattern | How it runs | Best fit |
|---|---|---|
| Sequential pipeline | Extract to transform to validate in fixed order | Document processing, ETL, warranty triage |
| Conditional workflow | Branch and loop with a hard retry cap, then escalate | Code to test to deploy with human fallback |
| Conditional router | Classify once, run exactly one path | Intent dispatch, quality gates, ticket routing |
| Parallel fan-out and fan-in | Split independent work, join when all finish | Multi-source analysis, batch work |
Latency in parallel work equals the slowest branch rather than the sum, which is why this tier suits well understood components. If you can draw the control flow on a whiteboard before runtime, the guidance is to stay here.
Tier 2: let the model choose the path
Tier 2 covers autonomous patterns where the model determines control flow at runtime. It handles work whose steps cannot be defined in advance, at higher token, latency, and debugging cost.
Plan-based orchestration uses a planner that holds the full plan while stateless workers see only their slice, so a failed worker can be retried without contaminating others. Handoff passes validated state and open questions peer to peer, with each agent knowing only a small set of transfer targets. Conversation-driven group chat shares one history and selects the next speaker by round robin or model choice. Debate has independent agents commit first and then reconciles by majority, judge, or escalation.
Debate is the most expensive option here. The post warns to reserve it for high stakes, low volume decisions where being wrong costs more than deliberating, not for perceptual checks where it buys latency rather than accuracy. Most production systems hybridize: workflows for predictable parts, autonomy where flexibility is essential, consistent termination handling, and layered composition.
Five anti-patterns that burn budget
- God agent: one prompt with 15 or more tools for unrelated jobs. Fix with bounded agents of five tools or fewer.
- Unbounded iteration: looping on try again with no hard stop. Fix with code-enforced iteration ceilings, per-agent token caps, and budget alarms wired to automatic stop.
- Natural-language contracts: free-text handoffs where could indicate wear hardens into confirmed wear. Fix with typed schemas through validated Model Context Protocol tools.
- Premature multi-agent: splitting one-model work into specialists. The test is whether one agent switching tool groups can do the phases, and whether you truly need different models, different tool access, concurrent execution, and interdependency.
- Unguarded customer contact: triggering emails, visits, or machine parameters without approval. Fix with defense in depth from recommendation to guardrails to schema validation to business rules to human approval to execution.

The capture above shows the source AWS taxonomy page that defines these tiers and fixes. Its decision tree asks four questions in order: do you need actions beyond text, is the solution path known, does the work need genuinely distinct expertise, and does the solution emerge only through exploration. Only exploration with discovered subtasks earns Tier 2.
What manufacturing changes
The factory lens makes the tradeoffs unforgiving. Automotive body shops run about 60 jobs per hour with about a 60 second takt time per station, so inference sitting on the cycle path directly eats throughput. The post advises budgeting latency at p99, not average, with sub-second deterministic fallbacks mapped by risk: flag and continue for advisory work, containment or deterministic stop for safety.
Safety has physical consequences. Examples include manufacturing execution system state desync after a manual override, and hallucinated lockout guidance breaking an interlock zone. The recommended boundary keeps PLCs, SCADA, and MES unchanged while agents observe, analyze, and recommend. Safety constraints live as deterministic guardrails in an external service agents query, never as prompt text that can be argued away. Recommendations pass schema and physics checks against fresh operational truth, then clear a four level approval from autonomous to operator confirm to engineer decision to management review. The model proposes, the physics engine and human dispose.
Two more constraints shape the architecture. A single stamping press can generate over 50 GB per day of sensor data whose value decays in milliseconds, favoring edge sub-takt anomaly detection with cloud for cross-shift analytics and retraining. And unbounded context drifts, so the post bounds agent memory to the shift cycle: initialize with crew and targets, accumulate only within the shift, then emit a structured handoff of open issues and anomalies.
Production proof you can reuse
Two companion deployments show the same ideas at scale. Duco on Bedrock AgentCore processes 20 billion transactions monthly for more than 200 clients with strict per-tenant isolation, one runtime and gateway per tenant, and JWT scoped identity. Facing about 200,000 tokens of tool descriptions from 300 to 400 tools, it moved descriptions to on-demand skill resources with three meta tools for load, find, and invoke, cutting main context from about 200,000 to about 20,000 tokens with no infrastructure change. Results include 10 times faster reconciliation deployment, 70 percent lower onboarding cost at one global bank, and over 20 percent higher straight-through processing.
MoEngage on Bedrock AgentCore took a different reuse path: generate Model Context Protocol tools directly from existing OpenAPI 3.0 specs with FastMCP, keep workspace identity in headers the model cannot edit, and isolate each session. The pattern is small and portable:
import httpx
from fastmcp import FastMCP
spec = httpx.get(MOENGAGE_OPENAPI_URL).json()
client = httpx.AsyncClient(base_url=MOENGAGE_API_BASE)
mcp = FastMCP.from_openapi(openapi_spec=spec, client=client, name="moengage")
if __name__ == "__main__":
mcp.run(transport="streamable-http", host="0.0.0.0", port=8000)
Merlin AI agents shared that foundation across copy, segments, analytics, and journeys. The company reports one customer reaching campaign go-live 50 percent faster with a 38 percent push click-through uplift, 60 to 70 percent less manual effort on channel and timing decisions, and over 50 percent lower inference infrastructure cost versus self-hosted models.
For teams running fleets, compare this with operational controls described in AgentCore CLI Hits 1.0: A Supported Terminal Path for Building and Operating AWS Agents. The takeaway is consistent: choose the cheapest deterministic pattern that fits, enforce typed handoffs and retry budgets in code, and expand to autonomy only when production evidence shows subtasks must be discovered at runtime.
Sources
- Taxonomy of multi-agent design patterns, anti-patterns, and lessons from manufacturing | Artificial Intelligence
- How Duco transforms financial data automation with Amazon Bedrock AgentCore | Artificial Intelligence
- How MoEngage built agentic customer engagement on Amazon Bedrock AgentCore | Artificial Intelligence