大模型·Agent架构面试题:什么时候该拆多Agent?

拆多 Agent 不是堆角色,而是一笔工程交易——用分工换取并行度与专注度,同时承担协作成本。当分工收益大于通信、治理成本时,才是拆分的时机。核心原则是:先让单 Agent 跑通,再定位真实瓶颈,瓶颈驱动拆分。


本页导览


核心判断:拆多 Agent 的本质

拆多 Agent 不是简单”多请几个员工”,本质是一笔工程交易:

得到什么付出什么
并行探索(多个方向同时推进)更多 Token 消耗
领域专注(每个 Agent 只做一件事,指令不被稀释)更多通信往返
权限隔离(高危操作单独隔开)更复杂的状态管理
独立重试与故障边界(一个环节挂了不至于整条链崩)更难的调试链路

默认策略: 先让单 Agent 跑通 → 定位瓶颈 → 针对性拆分。四个字:瓶颈驱动。


三个硬约束:什么时候该拆

同时出现以下三件事,才值得认真考虑拆分:

1. 上下文装不下

代码、文档、实时数据混在一个上下文里,信息互相干扰,检索与推理开始失焦。这是最核心的拆分理由,几乎没有之一。

2. 时间等不起

任务里存在多个互不依赖的探索分支,可以扇出并行再集中汇总。

举例:一个 Agent 串行做要 10 分钟,拆成 10 个并行,1 分钟出结果。这种任务拆了纯赚。

3. 权限分不开

高风险执行与低风险分析必须隔离,遵循最小权限与独立审核。

执行的 Agent 只拿最小权限,审核的 Agent 独立把关。这是合规问题,不是性能问题。

三条硬决策线: 上下文 · 并行度 · 权限边界


拆分信号:单 Agent 开始吃力的 5 个表现

  1. 大范围检索 — 多个资料方向可独立搜索、验证和归纳,天生适合拆分
  2. 专业角色分工 — 研究、编码、审核的目标和工具明显不同,硬塞进一个 prompt 会互相稀释
  3. 高风险操作 — 执行、审批、审计需要彼此独立,谁干活谁把关必须分开
  4. 可局部重试 — 一个子任务失败不应拖垮整条任务链,自己能重试就行
  5. 需要可观测性 — 出了问题得能定位到是哪一步、哪个工具出的问题

中了好几个,就大胆拆。


反面判断:哪些情况明确不该拆

  1. 强共享上下文 — 全程要维护同一份需求/代码状态,拆开反而丢信息
  2. 串行依赖很强 — 前一步不完成后一步没法开始,拆了也只是排队,还多通信开销
  3. 低延迟链路 — 通信往返的成本大于分工收益
  4. 以”写”为主 — 连续创作、统一代码风格更依赖整体一致性

业界共识:

  • 读为主的任务 → 适合多 Agent
  • 写为主的任务 → 更适合单 Agent + 强工具

Google 常被引用的数据:约 64% 的场景下,单 Agent 和多 Agent 表现基本持平,多 Agent 平均只提升 2.1% 准确率,但成本直接翻倍。

更好的起点: 单 Agent + 强工具调用 + 检索增强 + 上下文工程,往往更简单、更稳定。先解决真实瓶颈,再增加协作节点。


推荐架构:编排者 + 专业 Worker

Orchestrator → Workers → Review & Synthesis
  • Orchestrator(主控): 识别任务类型 → 决定是否拆分 → 分配预算与权限
  • Workers(专业工人): 检索的管检索、编码的管编码、分析的管分析,每个 Agent 只处理清晰的部分
  • Review & Synthesis(评审汇总): 结构化汇总、交叉校验、输出统一结果

关键: 不是固定”多 Agent”,而是通过路由动态决定”单跑”还是”扇出”——静态拆死不如动态路由。

生态趋势: 跨 Agent 协作协议正在推进(工具层看 MCP,Agent 之间看 A2A),互操作生态越来越成熟。


编排 vs 互操作:LangGraph 还是 A2A

面试嘴仗:“为什么选 A2A 而不是 LangGraph?” 别中套——它俩根本不在一个层面,不是二选一。

一句话分层:

  • LangGraph = 编排框架:管”一个应用内部(同进程)多 Agent 怎么跑”,图状态、分支、重试、Human-in-the-loop。
  • A2A = 互操作协议:管”跨系统/跨进程/跨组织”的 Agent 怎么发现彼此、交换任务与结果,走 HTTP + JSON + 异步 Task 生命周期。

记忆钩子:LangGraph 是”一个房子里的房间布局”;A2A 是”房子与房子之间的电话线”——另一栋房子是谁盖的、用什么语言都行,只要它愿意用同一套电话线。

同一进程 = 随便加节点;跨边界 = 只能走协议

“其他成熟 Agent 接入?那我给 LangGraph 加个 NODE/EDGE 不就完了?” —— 这假设成立时需要满足:能拿到源码、能 import 进同一进程、一起编译发版、愿意共享故障与安全域。

你的前提崩塌时 → 为什么加节点失效,只剩 A2A
我能拿到源码对方是商业 Agent / 黑盒服务 / SaaS,只有 API,没有代码可 import
能放同一进程它是 Java/C++/Go 写的,你是 Python——不同运行时,编译链接都过不去
一起编译发版它有自己的发版节奏、SLA、缩扩容,加节点 = 重新编译整张图、一改全动
共享状态=共享故障LangGraph 节点进程内共享崩溃;独立部署的 Agent 该有自己的故障域和安全边界

关键区分:LangGraph 加节点 = 代码级耦合(拥有代码和编译产物);A2A 连 Agent = 运行时级耦合(只交换任务和结果,其余全隔离)。能 import 就加节点,只能调用就走 A2A。

按”边界”选,不按”公司”选

A2A 不是”公司级才用”,而是”必须跨墙握手时才用”。 判断顺序:

先问:这些 Agent 要跨 团队 / 部署 / 安全域 / 外部 吗?
 ├─ 不跨(同团队、同进程、同代码库)→ LangGraph 或 单Agent+工具,就够 ✅
 └─ 跨   → 内部紧耦合的用 LangGraph;跨边界的接口用 A2A ✅

MCP 是”手脚”,A2A 是”头脑”

对方若是别人的 Agent,用 MCP 当工具接入不可以吗? —— 可以,但只在你不把决策权交给它时成立。分界线就一条:对方有没有自己对等的思考循环与决策控制权。

维度MCP(当工具接)A2A(当 Agent 接)
谁在思考只有你思考,对方无脑执行你调的原子函数双方各有 agent 循环/意图,对方能自己判断
粒度暴露一个个 operation(能力碎片)暴露整个 Task 目标(“把这件事办成”)
方向单向:你调它 → 返回结果完事双向/对等:可回调、可汇报、可返工
任务形态偏同步 “输入→输出”异步 Task 生命周期:接单→跑→状态更新→流式→完成通知
能力发现Agent Card 列”我有哪些工具”Agent Card 列”我能接哪种任务”

A2A 独有的、MCP 给不了的三大场景:

  1. 委派开放性目标:不一步步指挥,而是”这个子方向你自己规划、自己干完给我”。MCP 每次调用要求你知道自己要调什么;A2A 允许你把决策权交给对方。
  2. 长期异步 + 主动汇报:干到一半缺信息能反过来找你。MCP 是”你问它答”的请求-响应,没有对方主动推给你的通道。
  3. 对等协作/争议:双方各有判断,事务中协商(如 Agent 供数、Agent 审计,互相校验)。

一句话记法:MCP 是”工具之间的协议”——让工具被调用;A2A 是”Agent 之间的协议”——让 Agent 被委派。一个把别人当手脚,一个把别人当头脑。

临场一键选:LangGraph vs MCP vs A2A 决策链

上面是知识,这条是轮到选型时从上往下走、命中第一条就停的流程:

① 所有 Agent 能待进同一进程/代码库、一起编译发版、共享状态?
   ├─ 是 → LangGraph(强状态机 / checkpointer / Human-in-the-loop)✅ 停
   └─ 否 ↓
② 对方是"运行中的 Agent 服务",但只给它原子工具、不交决策权?
   ├─ 是 → MCP(当工具接,最轻)✅ 停
   └─ 否 ↓
③ 你要把决策权/主动性交给对方(开放性目标 / 异步长任务 / 对等协商)?
   ├─ 是 → A2A(协议边)✅ 停
   └─ 否 ↓
④ 拿不准 → 回 LangGraph,别引入跨系统复杂度 ✅

本质是三种控制权:

  • LangGraph 的”多 Agent” = 同一张图里的多个执行体,控制权在你的主图 → 同进程共享状态用。
  • MCP 的”多能力” = 对方只是手脚,控制权还在你 → 外部系统提供确定能力时用。
  • A2A 的”多 Agent” = 多个独立生命周期自治体,控制权在对方 → 委派目标、异步找我、协商返工时用。

同一句”多 Agent”,两种全然不同的多。先看”进程/边界”,再看”要不要交控制权”——能 import 就 LangGraph,只调能力就 MCP,必须交球权才 A2A。默认 LangGraph,A2A 不做默认。

澄清:LangGraph 不必然是一个进程

常被反问:“LangGraph 的多 Agent 还是一个进程啊——不能各自发版、故障无法隔离、租户/权限也隔离不了,这不就逼我上 A2A 吗?”

这一刀要切准:

  • 那三个问题(各自发版 / 故障隔离 / 租户权限隔离)——是”塞同一个进程/单体部署”这个动作造成的,不是 LangGraph 的错。
  • LangGraph 只是默认最简单模式是同进程,并不强制。它支持把每个 Agent 拆成独立部署的服务(LangGraph Platform / 把 subgraph 单独起成 HTTP 服务)。一旦拆开,1/2/3 大多消失:各服务独立版本、独立故障域、基础设施层(K8s namespace、独立 RBAC)天然隔离。
  • 所以真正决定”能不能隔离”的是你 deploy 时拆没拆,不是选没选 A2A。

既然 LangGraph 也能拆多服务,它和 A2A 到底差在哪? 差的不在”进程”,在两个字:

LangGraph 拆成多服务A2A
跨进程独立部署✅ 可以✅ 当然
独立发版 / 故障隔离 / 租户隔离✅ 拆了就有✅ 协议层就为这个而设计
跨框架❌ 全是同一套 LangGraph✅ 任意实现都能互通
跨所有者/组织❌ 都得归你掌控&信任✅ 别人公司/黑盒的 Agent 也能接
能力发现 + 任务协商你自己的内部 RPC,自己定标准 Agent Card + Task 生命周期协议

一句话澄清:“LangGraph 的多 Agent 不必然是一个进程——拆成多个服务后,独立发版、故障隔离、租户隔离全都有。它和 A2A 真正的分界线不是进程,而是:这些 Agent 是不是都在你掌控下的同一套框架。全是你自己的 LangGraph,拆服务就够;要接你掌控不到、还用着别的框架的 Agent,才轮到 A2A。”

也需要同步微调决策链第①条(把”同一进程”放宽成”同一框架且归你掌控”):

① 所有 Agent 能放进同一套 LangGraph、代码家族归你掌控?
   ├─ 是 → 用 LangGraph(要隔离?把 subgraph 拆成独立服务就有了)✅ 停
   └─ 否(要接别人 / 别框架的 Agent)→ MCP(当工具)或 A2A(交球权)✅ 停

多 Agent 独立部署服务示例(同框架、拆进程实现隔离,反衬 A2A 的差别):

【一个编排应用,3 个 LangGraph Agent 各一个 HTTP 服务】

                    ┌───────────────┐
                    │  orchestrator │  独立服务 #1(主控制图)
                    │  /invoke      │  版本 v1.4,独立部署 & RBAC
                    └───────┬───────┘
                            │ 内部 RPC(自定义协议)
              ┌─────────────┼──────────────┐
              ▼             ▼              ▼
       ┌──────────┐ ┌──────────┐ ┌──────────┐
       │ research │ │  coding  │ │  review  │  各自独立进程 / 独立版本 / 独立故障域
       │ /invoke  │ │  /invoke │ │  /invoke │  各自独立部署在独立 namespace
       └──────────┘ └──────────┘ └──────────┘
       这些还是同一套 LangGraph:跨框架❌ / 跨组织❌  / 协议私有⚠️
       要接进来 Google 的 Agent?→ 上 A2A,Orchestrator 开一个 A2A 端点就够了

对比要点: 上面的独立服务已经拿到”独立发版 + 故障隔离 + 租户隔离”,单靠 LangGraph 就到这。只有当你要接一个不属于你掌控、不是 LangGraph 编写的 Agent(比如第三方/外部系统)时,才需要 A2A 的那条标准协议边。

闭环:拆服务自造 RPC,何时轮到 A2A

反问升级:“可拆成独立服务后,还得自己内部做 RPC 通信,是不是不如直接用 A2A 方便?”

这步说对了——拆 LangGraph 服务拿到进程级隔离,代价是通信层要自己造:

  • 消息格式 → 自定义 JSON Schema
  • 调用/响应模型、错误码 → 自己规定
  • 异步长任务 → 自建轮询/webhook + 任务状态
  • 鉴权 / 谁能调谁 → 自己接
  • 对方干一半回来找你 → 回调协议自设计

LangGraph 给的是”图/节点”的编排 API;“服务与服务之间怎么通”这一步没有内置标准,全要你手搭内网 RPC。你感觉”不如现成协议”,正是这一点。

但”A2A 是否更省”取决于是否归你掌控:

场景谁更省
只有 2-3 个自己的 LangGraph Agent,内网互通❌ A2A 不占优——自己写 20 行 RPC 就够了,上 A2A 反而重
Agent 多了、要标准化异步任务/协商✅ 开始值得,A2A 省掉自造协议的重复劳动
要接外部 / 第三方 / 他人所属的 Agent✅✅ A2A 几乎唯一干净选择——别人的协议没得谈

记法: “拆服务拿到的是进程隔离,代价是自造协议喊话;A2A 放弃一点进程编排度,换来大家都听得懂的通用话。”

完整闭环:

进程隔离  ←靠部署(把 subgraph 拆成独立服务)
协议隔离  ←才轮 A2A(自造 RPC 只在自己边界内有效)
自造 RPC  ←只在"全归你掌控"时成立;一涉及外人/异构,就必须 A2A

工程难点:拆开后踩过的 6 个坑

1. 上下文膨胀

完整历史层层传递,Token 蹭蹭涨,关键信息反而被淹没。

解法: 传摘要,不传全文;子 Agent 按需去共享库里查。

2. 通信漂移

Agent 之间靠自然语言传话,传着传着就歪了。

解法: 结构化 Schema + 校验机制,消息格式定死。

3. 成本失控

多轮协作、失败重试、死循环,几分钱的任务能滚成几十块。

解法: Token 预算、步数上限、超时熔断。

4. 调试困难

链路变长后,出错不知道哪个环节。

解法: 全链路 Tracing,能回放每个 Agent 的输入、工具与输出;回归评估。

5. 状态冲突

并发 Worker 同时写共享信息,互相覆盖或产生矛盾。

解法: 版本控制;或只读共享 + 主控汇总写入。

6. 局部最优

每个 Agent 都觉得活干完了,拼起来的整体答案稀碎。

解法: 统一目标定义 + 独立评审 Agent 把关。


面试收束:一句话答案

拆多 Agent 的本质,是用 Token 换取并行度与专注度。当这份收益大于通信、成本和治理复杂度时,才应该拆。

落地四步:

  1. 先让单 Agent 跑通
  2. 定位真实瓶颈
  3. 按上下文、并行、权限三个维度拆分
  4. 动手前先把每个 Agent 的输入、输出与失败预算定义清楚

记住:先别拆,想清楚再拆。


相关笔记