多智能体设计模式分类、反模式与制造业经验

企业团队正在构建多智能体系统,而当早期实现效果不佳时,原因很少出在模型上。多智能体协调是一个分布式系统问题,而许多着手解决这一问题的团队尚未建立起分布式系统的直觉。
各方数据一致:约 88% 的 AI 试点从未进入生产环境。Stanford HAI 证明,当协调开销超过收益时,两个模型协作的表现可能比各自单独运行更差。模式很清楚:团队增加复杂度的速度快于他们建立理解的速度。十个每一步可靠率为 95% 的步骤,端到端可靠性只有 59.9%,而 20 个步骤则为 35.8%。这个示例模型假设不存在重试的严格串行链路,但方向成立:每一次依赖式交接都会放大风险。
在本文中,你将了解如何判断一个用例是否需要多个智能体、选择协调模式,并及早识别代价高昂的反模式。你还将看到节拍时间、安全边界、边缘数据和班次周期如何塑造架构。
协调模式根据由谁控制流程分为两个层级。在第 1 层,路径由你定义。
在第 2 层,模型在运行时选择路径。这种灵活性可以处理你无法提前定义步骤的工作,但代价是更高的 Token、延迟和调试成本。实际默认做法是从第 1 层开始,只有当任务的子任务在工作中才显现出来时,才将其移到第 2 层。
1.1 顺序流水线:实现线性执行的编排模式,其中每个节点的输出馈入下一个节点(A -> B -> C),支持具有可预测执行时序的有序处理
在下面的示意图中,输入流向智能体 A(提取),再流向智能体 B(转换),然后流向智能体 C(校验),最后输出。这一顺序由用户在构建时定义,运行时不做任何决策。因此,该流水线易于调试和测试,成本也可预测。典型的适用场景包括文档处理、提取、转换与加载(ETL)链路,以及保修索赔分诊。
图 1:顺序流水线,每个智能体的输出馈入下一个智能体,从提取到转换再到校验
1.2 条件工作流:基于逻辑的边通过条件选择下一个节点,因此工作流可以分支,让每个案例走不同的路径。
在下面的示意图中,用户请求先发给智能体 A(编写代码),再发给智能体 B(测试代码)。通过/失败检查会将通过的工作发送给智能体 D(部署)。失败的工作会循环回智能体 A 重试,最多 N 次,之后升级给人工处理。编排层会强制执行这一上限,例如通过 AWS Step Functions 的迭代次数限制,从而避免该循环演变为本文后文所述的无界迭代反模式。
图 2:条件工作流在失败时最多重试 N 次,然后升级给人工处理
1.3 条件路由器:
分类步骤会检查输入,并将其导向相应的处理路径。每个请求只执行一条路径。最适合意图驱动的分发、质量门禁决策、客户咨询路由和异常分诊。
下图展示了工厂主管的请求被分类器读取,并只发送给一个专家智能体。关于零件是否符合规格的问题交给质量智能体,逾期的设备维护交给维护智能体,班次调整交给排班智能体。这一决策在入口处完成。
图 3:条件路由器,每个请求只运行一条路径,并在升级至人工处理前进行有界重试
1.4 并行工作流:一个任务拆分为若干独立子任务,在各处理器上同时运行,每个子任务处理自己的数据。当所有处理器完成后,由扇入步骤汇总结果;某条路径失败时只重试该路径。最适合多源分析、批处理,以及可分解为相互独立片段的工作。
在下图中,一个研究编排器将任务分解,并派发给三个并发运行的专家智能体:金融数据智能体、地缘政治智能体和物流智能体,各自分析自己的数据源。一个汇总步骤等待三者全部完成,然后综合结果、解决冲突并对发现进行排序。延迟等于最慢的单个智能体,而不是三者之和。
图 4:向专家智能体并行扇出,随后由扇入步骤对结果进行综合与排序
在自主模式中,控制流在运行时由 AI 模型自身决定,而非由开发者预先定义。智能体读取任务状态,推理所需内容,并通过共享上下文进行协调,而不是沿着固定路径——其形态覆盖从结构化编排到完全涌现式行为的整个谱系。
在基于计划的编排中,单个编排器智能体充当项目经理。编排器维护一份包含任务分配与依赖关系的显式任务计划,掌握所有上下文,而每个 worker 只收到属于自己的那一部分;它依据当前计划动态分配工作,并集中监控进度。关键的设计选择在于:worker 是无状态且相互独立的。若其中一个失败,不会污染其他 worker。编排器只重试失败的 worker,而不是整个工作流。
下图展示了规划器智能体如何把一个任务分解为一份显式计划,并将每个步骤派发给一个 worker 智能体。每个步骤都交给专用的 worker(研究智能体、分析智能体和报告智能体),它只能看到分配给自己的一部分。
图 5:基于计划的编排——由规划器智能体把每个步骤分配给无状态的 worker 智能体
智能体在有限的局部知识下运行,并通过点对点委派进行协调。每个智能体依据任务以及它所认识的智能体,就何时移交控制权、移交给谁做出局部决策。控制权转移时携带状态:每次移交都会带上经过验证的任务状态、支撑该状态的证据,以及任何尚未解决的问题,这样接收方智能体是接着继续推进,而不是重新解读一份摘要。只在对话中流转的交接算不上真正的交接。
下图中,客服智能体将控制权连同其上下文一并移交给技术支持智能体或计费智能体,而技术支持还可以进一步移交给高级工程师。每个智能体只知道自己能够移交的那一小部分同级智能体。
图 6:交接模式——通过局部委派在平级智能体之间传递经过验证的状态
在对话驱动模式(也称为群聊模式)中,所有智能体都参与同一场共享对话,编排通过轮流发言自然涌现,而非依赖显式计划或结构化交接。这与人f团队的协作方式相似:每个人都能看到讨论内容,并在适当的时候做出贡献。
在下面的示意图中,智能体选择机制决定轮到谁发言,智能体 A、B、C 各自向同一场共享对话中追加内容,每个轮次都是一条消息加一次工具调用。选择机制设定轮流发言的顺序,状态则隐式地存在于对话历史中。
图 7:对话驱动模式——由轮流发言选出下一个智能体,状态存在于对话之中
控制流特征:
多个智能体各自独立评估相同的输入,其结论通过多数表决、由评判智能体裁定,或在出现分歧时逐级上报来加以协调。与对话驱动模式不同,这些智能体在表明立场之前看不到彼此的推理过程——正因如此,分歧才具有信息价值,而不是社交性的趋同。
谨慎使用。辩论是这里最昂贵的模式,而且在感知类任务上,它换来的是延迟而非准确率(参见后文反模式 3 中的质检案例)。应将其保留给高风险、低频次的决策——在这类决策中,出错的代价高于反复斟酌。
在实践中,大多数生产系统会基于任务分解组合使用多种模式:
指导原则:模式与任务相匹配。让编排方式契合每项任务的内在特征以及系统的可靠性要求,而不是强行让所有任务都套用同一种模式。
以下五种反模式在设计阶段看起来都很合理,但之后每一种都会以虚高的 Token 成本、错失的节拍时间窗口,或一项已悄然与车间实际脱节的决策的形式暴露出来。
一个智能体在单个提示词下配有 15 个或更多工具,负责设备综合效率(OEE)分析、可编程逻辑控制器(PLC)诊断和维护。随着工具增多,工具选择能力会下降,故障也变得难以归因。
解决方案:使用工具不超过五个的受限智能体,例如 OEE 分析师、故障诊断师和维护起草员。
原文较长,译文为节选;译文由英文原文机器翻译,术语按行业惯例统一,可在文末展开原文核对。
查看英文原文(Taxonomy of multi-agent design patterns, anti-patterns, and lessons from manufacturing)
Enterprise teams are building multi-agent systems, and when early implementations fall short, the cause is rarely the model. Multi-agent coordination is a distributed systems problem, and many teams taking it on haven’t yet built distributed systems instincts.
The numbers are consistent across sources: ~88% of AI pilots never reach production. Stanford HAI demonstrated that two models can perform worse collaborating than either alone when coordination overhead exceeds the benefit. The pattern is clear: teams are adding complexity faster than they build understanding. Ten steps that are each 95 percent reliable deliver only 59.9 percent end-to-end reliability, and 20 steps deliver 35.8 percent. This illustrative model assumes a strictly sequential chain with no retries, but the direction holds: each dependent handoff multiplies risk.
In this post, you learn how to decide whether a use case needs multiple agents, choose a coordination pattern, and spot costly anti-patterns early. You also see how takt time, safety boundaries, edge data, and shift cycles shape the architecture.
Multi-agent coordination patterns
Coordination patterns fall into two tiers, based on who controls the flow. In Tier 1, you define the path.
In Tier 2, the model chooses the path at runtime. That flexibility handles work whose steps you can’t define in advance, at a higher cost in tokens, latency, and debugging. The practical default is to start with Tier 1 and move a task to Tier 2 only when its subtasks emerge during the work.
Tier 1: Patterns (deterministic control flow)
1.1 Sequential Pipeline: Orchestration patterns that implement linear execution where each node’s output feeds into the next node (A -> B -> C) supporting ordered processing with predictable execution timing
In the following diagram, input flows to agent A (extract), then agent B (transform), then agent C (validate), and then output. The user defines that order at build time, and nothing is decided at runtime. As a result, the pipeline is straightforward to debug and test, and its cost is predictable. Typical fits include document processing, extract, transform, and load (ETL) chains, and warranty-claim triage.
Figure 1: Sequential pipeline where each agent’s output feeds the next, from extract to transform to validate
1.2 Conditional Workflow: Logic-based edges select the next node by condition, so the workflow can branch and send each case down a different path.
In the following diagram, a user request goes to agent A (write code) and then to agent B (test code). A pass/fail check sends passing work to agent D (deploy). Failing work loops back to agent A for a retry, up to a maximum of N times, and then escalates to a human. The orchestration layer enforces that cap, for example through an AWS Step Functions iteration limit, which keeps the loop from becoming the unbounded iteration anti-pattern described later in this post.
1.3 Conditional Router:
A classification step examines the input and directs it to the appropriate processing path. Only one path is executed per request. Best for intent-driven dispatch, quality-gate decisions, customer inquiry routing, and anomaly triage.
The following diagram shows a plant supervisor’s request being read by a classifier and sent to exactly one specialist. Questions about whether parts meet spec go to the Quality Agent, overdue equipment services go to the Maintenance Agent, and shift changes go to the Scheduling Agent. This decision is made at the entry point.
Figure 3: Conditional router that runs one path per request, with bounded retries before human escalation
1.4 Parallel Workflow: A task splits into independent subtasks that run simultaneously across handlers, each on its own data. A fan-in step combines the results when all handlers complete, and a failure in one path retries only that path. Best for multi-source analysis, batch processing, and work that decomposes into independent pieces.
In the following diagram, a research orchestrator decomposes the task and dispatches it to three specialist agents that run concurrently: a financial data agent, a geopolitical agent, and a logistics agent, each analyzing its own source. A combined step waits for all three, then synthesizes the results, resolves conflicts, and ranks the findings. Latency equals the slowest single agent rather than the sum of all three.
Figure 4: Parallel fan-out to specialist agents followed by a fan-in step that synthesizes and ranks the results
Tier 2: Autonomous patterns (LLM-determined control flow)
In autonomous patterns, control flow is determined at runtime by the AI model itself, not predefined by developers. Agents read task state, reason about what’s needed and coordinate through shared context rather than fixed paths spanning a spectrum from structured orchestration to fully emergent behavior.
2.1 Plan-based orchestration
In plan-based orchestration, a single orchestrator agent acts as a project manager. The orchestrator maintains an explicit task plan with assignments and dependencies, sees all context while each worker receives only its slice, distributes work dynamically against the current plan, and monitors progress centrally. Key design choice is that the workers are stateless and independent. If one fails, it doesn’t contaminate others. The orchestrator retries only the failed worker, not the entire workflow.
The following diagram shows how a planner agent decomposes a task into an explicit plan and dispatches each step to a worker’s agent. Each step goes to a dedicated worker (a research agent, an analysis agent, and a report agent) that sees only its assigned slice.
Figure 5: Plan-based orchestration with a planner agent assigning each step to a stateless worker agent
2.2 Handoff pattern
Agents operate with limited, local knowledge and coordinate through peer-to-peer delegation. Each makes local decisions about when and to whom to transfer control, based on the task and the agents it knows. Control passes with state: each transfer carries validated task state, the evidence behind it, and any unresolved questions, so the receiving agent continues rather than reinterpreting a summary. A handoff that moves only through the conversation is not a handoff.
In the following diagram, a customer service agent transfers control, together with its context, to either a technical support agent or a billing agent, and technical support can hand off further to a senior engineer. Each agent knows only the small set of peers it can transfer to.
2.3 Conversation-driven pattern
In conversation-driven patterns (also known as group chat patterns), all agents participate in a shared conversation where orchestration emerges through turn-taking rather than explicit plans or structured handoffs. This mirrors human team collaboration where everyone can see the discussion and contribute when appropriate.
In the following diagram, an agent-selection mechanism decides whose turn it is, and agents A, B, and C each add to one shared conversation, where every turn is a message plus a tool call. The selection mechanism sets the turn-taking, and state lives implicitly in the conversation history.
Figure 7: Conversation-driven pattern where turn-taking selects the next agent and state lives in the conversation
Control flow characteristics:
- Visibility: Broadcast all agents observe all messages in the shared conversation.
- Decision making: Next speaker selected based on conversation context, not predetermined plans.
- State management: Implicit in the conversation history.
- Turn-taking: Determined by selection mechanisms (round-robin, AI-driven)
- Round-robin. Agents take turns in a fixed, repeating order until a termination condition is met, which keeps it predictable.
- AI-driven. A model selects the next speaker from the conversation context rather than a fixed order.
2.4 Debate/consensus
Multiple agents independently evaluate the same input, and their conclusions are reconciled by majority, by a judge agent, or by escalation when they disagree. Unlike a conversation-driven pattern, the agents do not see each other’s reasoning before committing to a position, which is what makes disagreement informative rather than socially convergent.
Use it sparingly. Debate is the most expensive pattern here, and on perceptual tasks it buys latency rather than accuracy (see the quality-inspection case in anti-pattern 3 that follows). Reserve it for high-stakes, low-volume decisions where being wrong costs more than deliberating.
Hybrid approaches
In practice, most production systems combine several patterns based on task decomposition:
- Use workflow patterns for predictable, well-understood components.
- Apply autonomous patterns where flexibility and adaptation are essential.
- Implement task management patterns (termination, delegation) consistently across all orchestration types.
- Design hierarchical compositions where complex agents internally use different patterns at different layers.
The governing principle: pattern-to-task alignment. Match the orchestration approach to each task’s inherent characteristics and your system’s reliability requirements rather than forcing everything through a single pattern.
Anti-patterns that burn budget
Each of the following five anti-patterns looks reasonable at design time, and each surfaces later as an inflated token cost, a missed takt-time window, or a decision that has quietly drifted out of sync with the plant floor.
1. God agent
One agent owns overall equipment effectiveness (OEE) analysis, programmable logic controller (PLC) diagnostics, and maintenance behind a single prompt with 15 or more tools. Tool selection degrades as tools grow, and failures become hard to attribute.
The fix: Bounded agents of five tools or fewer, such as an OEE analyst, a fault diagnostician, and a maintenance drafter.
2. Unbounded iteration
The agent loops on “try again” with no hard stop. A four-agent system can burn a significantly higher number of tokens before a single retry, and no one call trips an alarm. Retries multiply coordination failures rather than fixing them.
The fix: Hard iteration ceiling in code, per-agent token ceiling, budget alarm wired to an automatic stop. Infrastructure enforces limits. The model will not stop itself.
3. Natural-language contracts
Agents hand each other free-text prose with no schema. Interpretation hardens at every hop: “could indicate wear” becomes “confirmed wear” becomes a maintenance order. The drift happens between agents, where tracing is thinnest.
4. Premature multi-agent
Multi-agent where one agent with tool groups would do. Each agent adds a coordination tax that is not linear, and the gains flatten around four. Most “specialists” are one model in different costumes.
The fix: Needs at least two different models, different tool access, concurrent execution, and real interdependency. Fewer than two, and one agent with action groups does it.
The test: can one agent handle the phases by switching tools? Then it is not a multi-agent problem.
5. Unguarded customer contact
The agent triggers real-world actions (email, service visits, machine parameters) with no approval step. Hallucinations cross into the physical world, irreversible actions compound, and liability escalates from a refund to product liability.
The fix: Defense in depth: recommendation → Amazon Bedrock Guardrails → schema validation → business rules → human approval → execution.
Every point where agent output reaches a customer, or a safety system is a trust boundary.
Choosing an architecture
With the patterns and anti-patterns in view, the architecture choice comes down to a short sequence of questions.
- Does the task require action beyond text generation? Treat a direct model call as the baseline and add orchestration only for a measured reason. Summarizing documents or generating code from a specification rarely supplies one.
- Is the solution path known in advance? If you can write down what happens in what order, you don’t have a “how many agents” decision at all. Your real choice is simpler: a single agent that calls tools, or a Tier 1 workflow.
- Does the work require genuinely distinct expertise? Separate domains with established handoffs justify specialized agents. A single domain belongs to one agent, no matter how many tools it needs.
- Does the solution emerge only through exploration? When the action sequence is known and can run as an act-and-validate loop, it belongs to a single agent, even one that plans its steps dynamically. Tier 2 earns its added cost, latency, and debugging burden only when the subtasks themselves are discovered in the course of the work.
The following decision tree turns these four questions into a path you can follow from top to bottom.
Figure 8: Decision tree for choosing the simplest architecture, from a single model call to a Tier 2 multi-agent pattern
The tree starts by asking whether the task requires actions beyond text generation. If it doesn’t, a simple model call is enough. If it does, the tree asks whether the solution is well known and can be expressed as a workflow. On the known solution side, work that benefits from specialized expertise or domain separation go to a Tier 1 multi-agent workflow (a pipeline, fan-out, or router). Everything else goes to a single agent with tools and action groups. On the unknown-solution side, only tasks that involve exploration or significant side effects go to Tier 2 for autonomous multi-agent patterns. The rest stays with a single agent. The guiding principle is to choose the simplest architecture that meets your requirements.
The following chart compares the patterns on four things: when to reach for each one, how control flows between agents, how deterministic the result is, and what it costs to build and operate. Build cost is a relative scale, not an estimate.
Figure 9: Comparison of the patterns by use case, control flow, determinism, and relative build cost
Tier 1 patterns score high on determinism at low to moderate build cost. Tier 2 patterns give more of the path to the model, and plan-based orchestration costs the most to build. If you can draw the control flow on a whiteboard before runtime, start with Tier 1.
Applied: Mapping patterns to manufacturing use cases
| Use Case | Pattern | Rationale |
| Shift handoff summarization | Sequential Pipeline | Linear: raw logs → summary → report |
| Multi-station root-cause analysis | Plan-Based Orchestrator | Dynamic: subtasks discovered during analysis |
| Real-time quality gate | Conditional Router + Edge Agent | In-cycle: local model decides. Agent reasoning off path |
| Predictive maintenance scheduling | Parallel Fan-Out/Fan-In | Independent models per asset class |
| Engineering change order impact | Debate/Consensus | High stakes: adversarial review justified |
| Supplier communication drafting | Sequential + Human Gate | Must not auto-send (see Unguarded Customer Contact) |
| Cross-plant optimization | Plan-Based Orchestrator | Multi-source: dynamic queries. Solver does allocation |
The manufacturing lens: Four constraints that change the calculus
Manufacturing is not a generic enterprise IT environment, and four constraints make that arithmetic unforgiving.
Constraint 1: Production-line latency = direct revenue loss
Automotive body shops, where robots weld the vehicle body together, typically run at 60 jobs per hour. Each of their over 40 stations has a 60-second takt time before the line advances. Inference latency that sits on a station’s cycle path eats into those 60 seconds, and a delay at the bottleneck station slows the whole line. Even a 2 percent throughput reduction can translate to significant annual revenue impact.
Architecture implication: budget latency at p99, not average. The tail is what stops the line. Give every agent a sub-second deterministic fallback, and match it to the risk:
- Advisory/quality-flagging: Pass the part with a flag for end-of-line review.
- Safety-critical: Containment or a deterministic stop, not continuation.
- Decide this mapping per station before deployment.
Constraint 2: Safety has physical consequences
A hallucinated chatbot causes embarrassment. A hallucinated welding parameter causes structural defects that surface in crash testing or field failure and can lead to a safety recall. Two failure modes recur:
- OT/IT boundary state desync: An agent reads the manufacturing execution system (MES) as Station 12 running Part #A, but a manual PLC override already switched it to Part #B, so it tunes parameters for the wrong part.
- Hallucinated safety boundary: A maintenance agent reasons about lockout/tagout from scratch and declares Station 7 accessible while adjacent Station 6 runs, breaking the interlock zone.
Architecture implication:
The boundary: keep the deterministic core unchanged, including PLCs, supervisory control and data acquisition (SCADA) systems, and the MES, and wrap an advisory layer around it.
- Agents observe, analyze, and recommend. They do not actuate.
- Safety constraints live as deterministic guardrails in an external service that agents query rather than reason about. They’re never embedded in prompts, where they can be argued away.
Validation and approval: A recommendation passes schema validation and physics simulation, checked against the OT source of truth immediately before actuation, never against OT state cached beyond one cycle. It’s then approved at a level matched to its scope:
- Level 0: Agent resolves autonomously.
- Level 1: Operator confirms with one click.
- Level 2: Engineer decides from the presented analysis.
- Level 3: Management evaluates a line-stop recommendation.
Only then does a validated command interface pass permitted commands to deterministic control. The large language model (LLM) proposes. The physics engine and the human operator dispose.
Constraint 3: Data lives at the edge
A single stamping press generates 50+ GB/day of sensor data whose value decays in milliseconds. Shipping it to the cloud costs more in bandwidth than compute, and by the time the cloud answers, the press has moved on.
Architecture implication: hybrid edge-cloud is the practical default, and the Constraint 2 boundary holds at the edge too.
- Edge (AWS IoT Greengrass): sub-takt anomaly detection, threshold monitoring, and stop-or-continue signals at the source: the edge agent recommends, the PLC acts.
- Cloud: What the edge can’t do: cross-shift analytics, trend correlation across plants, and model retraining on fleet data. The edge distills and transmits only what matters.
Constraint 4: Shift-aligned agent lifecycle
Unbounded context makes an agent drift as stale observations crowd out current reality. A full reset loses continuity between shifts. Manufacturing already solves this for humans with structured shift handoffs, and agents need the same discipline.
Architecture implication: Bound agent memory to the shift cycle.
- Initialize: Shift context, including the crew roster, production targets, and the prior shift handoff.
- Accumulate: Working memory within the shift window only.
- Hand off: Emit a shift-end summary of open issues, flagged anomalies, and recommendations that seed the next crew, mirroring the human ritual without unbounded context growth.
Building on AWS
The following managed services map to the concerns raised earlier in this post. Each row names the mechanism, not just the service.
| Need | Service | Mechanism |
| Runtime | AgentCore runtime, a capability of Amazon Bedrock AgentCore | Where agents run, their control flow is determined or model determined. Bring Strands, LangGraph, or CrewAI. |
| Shift-bounded memory | AgentCore memory, a capability of Amazon Bedrock AgentCore | Managed short-term and long-term context, so the shift-scoped memory from Constraint 4 is configuration rather than custom state plumbing. |
| Typed handoffs | AgentCore Gateway, a capability of Amazon Bedrock AgentCore | Converts APIs and AWS Lambda functions into Model Context Protocol (MCP) tools with validated schemas, so handoffs carry typed fields rather than prose. |
| Agent permissions | AgentCore Identity, a capability of Amazon Bedrock AgentCore | A unique, verifiable identity for each agent with fine-grained access control. It’s the enforcement point for which agent can reach which system, and on whose behalf. |
| Tracing between agents | AgentCore Observability, a capability of Amazon Bedrock AgentCore | Spans and traces across runtime, memory, gateway, and tools, through Amazon CloudWatch Transaction Search and AWS Distro for Open Telemetry (ADOT). Handoffs are the least observable part of a multi-agent system and where untyped contracts fail silently. |
| Human approval surface | AWS Quick | Where the escalation tiers land. AWS Quick Automate runs approval workflows with one-click approval in Slack, and its action connectors can invoke Amazon Bedrock AgentCore agents. |
| Tiered model selection | Amazon Bedrock | One API across model families, so cost tiering is configuration: a small model for a router’s classification and a stronger one for an orchestrator synthesis. |
Conclusion
Multi-agent systems change how automotive manufacturers orchestrate intelligence at scale, but only when built on the right foundations.
The patterns and anti-patterns here come from real deployments where poor architecture shows up as runaway token costs, takt-time violations, and, at worst, physical safety risks. The economics at plant scale are unforgiving, because token volume grows with every agent, robot, and shift. Tiered model selection, context compression, and edge-cloud distribution are the main levers for delivering the same value at a fraction of that cost.
The recommendation here is to start with Tier 1 patterns, prove value, and then expand. Most manufacturing use cases, such as shift handoff summarization, quality-gate decisions, and predictive maintenance, are well served by deterministic workflows. Reserve autonomous orchestration for genuinely open-ended problems where dynamic subtask discovery justifies the added cost, latency, and debugging complexity.
About the authors
Kamlesh Mariwala
Kamlesh is a Senior GenAI ML Solutions Architect at AWS, focused on the automotive and manufacturing industries. He helps customers design scalable, secure, and cost-effective architectures that use AWS agentic AI, and machine learning to solve complex business problems and speed up time to value.
Malini Sethi
Malini is a Solutions Architect at Amazon Web Services (AWS), specializing in the Automotive and Manufacturing sector. She works with large automotive and industrial customers to design and implement cloud-native solutions that accelerate their digital transformation of AI adoption, AWS Generative AI. Before her current role, she served as an AWS ProServe Consultant, working closely with customers to turn complex technical challenges into scalable, production-ready systems. She studied Machine Learning at MIT.
Deepesh Koppunuru
Deepesh is a Senior GenAI ML Solutions Architect at AWS, where he partners with large enterprise customers to unlock innovation through AWS Generative AI services. With a passion for demonstrating the transformative power of AI, Deepesh helps organizations reimagine their business processes and achieve measurable outcomes that drive real impact.
Sandy Hsieh
Sandy is a Senior Data & AI Specialist within the AWS Worldwide Specialist organization supporting Automotive and Manufacturing customers in adopting generative AI, agentic AI, and Physical AI solutions. Sandy brings over 10 years of global automotive industry experience in areas of supply chain, vehicle planning, and infotainment. She holds a master’s degree in Mechanical Engineering from Carnegie Mellon University.
正文保留英文原文,标题与摘要由机器翻译。
原文发布于 AWS Machine Learning(Taxonomy of multi-agent design patterns, anti-patterns, and lessons from manufacturing),标题、摘要与正文由机器翻译,术语按行业惯例统一,未经人工逐句校订。

