AIsaAIsaStudio English 打开 AIsa Studio

AWS 架构师解析多智能体设计模式、反模式与制造业落地经验

原标题:Taxonomy of multi-agent design patterns, anti-patterns, and lessons from manufacturing

AWS 解决方案架构师团队给出多智能体设计模式分类:Tier 1 确定性控制流(顺序管线、条件工作流、路由、并行扇出)与 Tier 2 模型自主控制流(计划编排、交接、群聊、辩论),并总结 God agent、无界迭代、自然语言契约等五个烧钱反模式及架构选择决策树。文章以汽车制造业为例,说明节拍时间延迟、物理安全边界、边缘数据和班次周期如何约束架构,并映射到 Amazon Bedrock AgentCore 等服务。

为什么值得看

文章给出一套多智能体协作模式的分类、五个常见反模式及架构选择决策树,读者可按此判断用例是否真的需要多智能体并选择协调模式。

阅读原文 ↗11月17日 AI 日报

本页的摘要、推荐理由与解读出自 AIsa Studio 的 AI 风向智能体,原文版权归原作者所有。

深度解读

发生了什么

AWS 机器学习团队发布了一篇面向企业团队的架构师指南,针对正在构建多智能体系统的从业者。文章的核心论点是:当早期实现效果不佳时,原因很少出在模型本身——「多智能体协调是一个分布式系统问题」,而许多团队尚未建立分布式系统的直觉。

关键细节

文章引用的数据令人警醒:约 88% 的 AI 试点项目从未进入生产环境。Stanford HAI 的研究表明,当协调开销超过收益时,两个模型协作的表现可能比单个模型更差。依赖链的数学非常残酷:10 个各 95% 可靠性的步骤,端到端可靠性只有 59.9%;20 步则降至 35.8%。

作者将协调模式分为两层:

  • Tier 1(确定性):开发者预定义流程——顺序管道、条件工作流、路由器、并行扇出/扇入
  • Tier 2(模型驱动):LLM 在运行时决定控制流——基于计划的编排、点对点移交、对话驱动群聊、辩论/共识

文章重点剖析了五种反模式:拥有过多工具的「上帝智能体」、无上限的重试循环、导致语义漂移的自然语言契约、过早的多智能体拆分,以及无防护的客户接触——后者会让幻觉触发不可逆的真实世界动作。

为什么重要

文章强烈主张架构上的保守主义。推荐的做法是以 Tier 1 模式为默认起点,只为真正探索性的工作保留 Tier 2 自主性。一个关键的检验标准:如果一个智能体切换工具就能完成各阶段任务,那它根本不是多智能体问题。

对制造业而言,文章详细说明了四项重塑架构权衡的约束——产线延迟(即使 2% 的吞吐损失也意味着可观的收入影响)、安全边界(幻觉出的焊接参数可能导致结构性缺陷)、边缘侧传感器数据生成,以及需要限定智能体记忆的班次周期。

对谁有影响

主要受众包括正在评估或构建多智能体系统的工程团队、需要在「构建与简化」之间做决策的平台架构师,以及汽车和工业领域的制造技术负责人。

对从业者而言,最具操作性的指导是决策框架:以直接的模型调用为基线,只在有测量依据时才引入编排,并牢记每一次智能体之间的移交都会放大风险。五种反模式可作为现有设计的实用审查清单。

全文翻译

以下翻译只覆盖原文的前一部分,其余内容请看下方原文。

企业团队正在构建多智能体系统,而当早期实现未能达到预期时,原因很少出在模型本身。多智能体协调是一个分布式系统问题,许多承担这一任务的团队尚未建立起对分布式系统的直觉。

数据在不同来源中保持一致:约 88% 的 AI 试点项目从未进入生产环境。斯坦福 HAI(Human-Centered Artificial Intelligence)的研究表明,当协调开销超过收益时,两个模型协作的表现可能比单独使用任一模型更差。模式很清晰:团队增加复杂性的速度快于他们建立理解的速度。十个可靠性各为 95% 的步骤串联起来,端到端的可靠性仅为 59.9%,而二十个步骤则降至 35.8%。这个说明性模型假设是一个严格顺序且无重试的链式结构,但方向是一致的:每个依赖性的交接都会成倍增加风险。

在本文中,你将学习如何判断用例是否需要多个智能体、选择一种协调模式,并尽早发现昂贵的反模式。你还将了解节拍时间(takt time)、安全边界、边缘数据和班次周期如何塑造架构。

多智能体协调模式

协调模式分为两个层级,基于谁控制流程。在 Tier 1(第一层)中,由你定义路径。

在 Tier 2(第二层),模型在运行时选择路径。这种灵活性可以处理那些步骤无法预先定义的工作,但代价是更高的令牌消耗、延迟和调试难度。实际的默认做法是从 Tier 1 开始,仅当子任务在工作过程中浮现时,才将任务移至 Tier 2。

Tier 1:模式(确定性控制流)

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:并行扇出到专家智能体,随后是综合和排名结果的扇入步骤

Tier 2:自主模式(LLM 确定的控制流)

在自主模式中,控制流由 AI 模型在运行时确定,而非由开发人员预定义。智能体读取任务状态,推理需要什么,并通过共享上下文进行协调,而不是固定的路径,涵盖从结构化编排到完全涌现行为的范围。

2.1 基于计划的编排

在基于计划的编排中,单个编排智能体充当项目经理。编排者维护一个明确的任务计划,包含分配和依赖关系,看到所有上下文,而每个工作者仅接收其切片,根据当前计划动态分发工作,并在中央监控进度。关键设计选择是工作者是无状态且独立的。如果一个失败,它不会污染其他工作者。编排者仅重试失败的工作者,而不是整个工作流。

下图展示了规划者智能体如何将任务分解为明确的计划,并将每个步骤分派给工作者智能体。每个步骤都发送给专门的工作者(一个研究智能体、一个分析智能体和一个报告智能体),每个工作者仅看到其分配的切片。

基于计划的编排,其中规划者智能体将步骤分派给研究、分析和报告工作者

图 5:基于计划的编排,规划者智能体将每个步骤分配给无状态工作者智能体

2.2 交接模式

智能体拥有有限、局部的知识,并通过点对点委托进行协调。每个智能体根据任务和它所知道的智能体,本地决定何时及向谁转移控制权。控制权随状态传递:每次转移都携带经过验证的任务状态、其背后的证据以及任何未解决的问题,以便接收智能体继续处理,而不是重新解释摘要。仅通过对话进行的交接不是真正的交接。

在下图中,客户服务智能体将其上下文一起将控制权转移给技术支持智能体或计费智能体,技术支持可以进一步移交给高级工程师。每个智能体只知道它可以移交的一小部分同行。

交接模式,其中客户服务智能体将控制权转移给技术支持或计费智能体

图 6:交接模式,通过本地委托在同行智能体之间传递经过验证的状态

2.3 对话驱动模式

在对话驱动模式(也称为群聊模式)中,所有智能体参与一个共享对话,编排通过轮流发言涌现,而不是显式计划或结构化交接。这类似于人类团队协作,每个人都能看到讨论并在适当时候贡献。

在下图中,一个智能体选择机制决定轮到谁,智能体 A、B 和 C 各自向一个共享对话中添加内容,其中每一轮都是一个消息加上一个工具调用。选择机制设定轮流顺序,状态隐式地存在于对话历史中。

对话驱动模式,其中选择机制在共享对话中给予智能体 A、B 和 C 轮流机会

图 7:对话驱动模式,轮流选择下一个智能体,状态存在于对话中

控制流特征:

  • 可见性:广播所有智能体都能观察到共享对话中的所有消息。
  • 决策制定:基于对话上下文选择下一个发言者,而非预定的计划。
  • 状态管理:隐式存在于对话历史中。
  • 轮流发言:由选择机制决定(轮询、AI 驱动)
    • 轮询。智能体按照固定、重复的顺序轮流发言,直到满足终止条件,这使其具有可预测性。
    • AI 驱动。模型根据对话上下文选择下一个发言者,而不是固定顺序。

2.4 辩论/共识

多个智能体独立评估相同的输入,它们的结论通过多数决、由裁判智能体裁决或在意见不一致时升级来进行调和。与对话驱动模式不同,智能体在承诺立场之前看不到彼此的推理,这使得分歧具有信息量,而不是社会性趋同。

谨慎使用。辩论是这里最昂贵的模式,在感知任务上,它购买的是延迟而不是准确性(见后文反模式 3 中的质量检查案例)。将其保留用于高风险、低频率的决策,其中犯错的成本高于深思熟虑的成本。

混合方法

在实践中,大多数生产系统根据任务分解组合几种模式:

  • 对于可预测、已充分理解的组件,使用_工作流模式_。
  • 在需要灵活性和适应性的地方应用_自主模式_。
  • 在所有编排类型中一致地实施_任务管理模式_(终止、委派)。
  • 设计_分层组合_,其中复杂智能体在不同层内部使用不同的模式。

治理原则:模式与任务对齐。将编排方法与每个任务的固有特性以及系统的可靠性要求相匹配,而不是强行将所有内容通过单一模式处理。

反模

查看原文

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.

Sequential pipeline: input flows through extract, transform, and validate agents to output

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.

Conditional workflow where passing work from the test agent deploys and failing work loops back to the write agent

Figure 2: Conditional workflow that retries failures up to N times before escalating to a human

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.

Conditional router sending each request down a single classified processing path

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.

Parallel workflow fanning out to financial, geopolitical, and logistics agents that run concurrently

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.

Plan-based orchestration where a planner agent dispatches steps to research, analysis, and report workers

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.

Handoff pattern where a customer service agent transfers control to a technical support or billing agent

Figure 6: Handoff pattern passing validated state between peer agents through local delegation

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.

Conversation-driven pattern where a selection mechanism gives turns to agents A, B, and C in a shared conversation

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.

Decision tree for choosing an architecture based on whether a task needs actions, a known path, distinct expertise, or exploration

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.

Chart comparing the patterns by when to use them, control flow, determinism, and build cost

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

原文版权归 AWS Machine Learning 及原作者所有,本站转载仅供阅读。如需删除,请联系 support@aisa.one。