大模型·Agent架构面试题:什么时候该拆多Agent?
拆多 Agent 不是堆角色,而是一笔工程交易——用分工换取并行度与专注度,同时承担协作成本。当分工收益大于通信、治理成本时,才是拆分的时机。核心原则是:先让单 Agent 跑通,再定位真实瓶颈,瓶颈驱动拆分。
本页导览
- 拆不拆 → 核心判断:拆多 Agent 的本质 · 三个硬约束:什么时候该拆 · 反面判断:哪些情况明确不该拆
- 怎么编排 → 推荐架构:编排者 + 专业 Worker
- 选型深水区(LangGraph / MCP / A2A) → 编排 vs 互操作:LangGraph 还是 A2A
- 按边界不按公司 · 加节点 vs 走协议 · MCP 是手脚 / A2A 是头脑 · 临场一键选:LangGraph vs MCP vs A2A 决策链 · 澄清:LangGraph 不必然是一个进程 · 闭环:拆服务自造 RPC,何时轮到 A2A
- 踩坑 → 工程难点:拆开后踩过的 6 个坑
核心判断:拆多 Agent 的本质
拆多 Agent 不是简单”多请几个员工”,本质是一笔工程交易:
| 得到什么 | 付出什么 |
|---|---|
| 并行探索(多个方向同时推进) | 更多 Token 消耗 |
| 领域专注(每个 Agent 只做一件事,指令不被稀释) | 更多通信往返 |
| 权限隔离(高危操作单独隔开) | 更复杂的状态管理 |
| 独立重试与故障边界(一个环节挂了不至于整条链崩) | 更难的调试链路 |
默认策略: 先让单 Agent 跑通 → 定位瓶颈 → 针对性拆分。四个字:瓶颈驱动。
三个硬约束:什么时候该拆
同时出现以下三件事,才值得认真考虑拆分:
1. 上下文装不下
代码、文档、实时数据混在一个上下文里,信息互相干扰,检索与推理开始失焦。这是最核心的拆分理由,几乎没有之一。
2. 时间等不起
任务里存在多个互不依赖的探索分支,可以扇出并行再集中汇总。
举例:一个 Agent 串行做要 10 分钟,拆成 10 个并行,1 分钟出结果。这种任务拆了纯赚。
3. 权限分不开
高风险执行与低风险分析必须隔离,遵循最小权限与独立审核。
执行的 Agent 只拿最小权限,审核的 Agent 独立把关。这是合规问题,不是性能问题。
三条硬决策线: 上下文 · 并行度 · 权限边界
拆分信号:单 Agent 开始吃力的 5 个表现
- 大范围检索 — 多个资料方向可独立搜索、验证和归纳,天生适合拆分
- 专业角色分工 — 研究、编码、审核的目标和工具明显不同,硬塞进一个 prompt 会互相稀释
- 高风险操作 — 执行、审批、审计需要彼此独立,谁干活谁把关必须分开
- 可局部重试 — 一个子任务失败不应拖垮整条任务链,自己能重试就行
- 需要可观测性 — 出了问题得能定位到是哪一步、哪个工具出的问题
中了好几个,就大胆拆。
反面判断:哪些情况明确不该拆
- 强共享上下文 — 全程要维护同一份需求/代码状态,拆开反而丢信息
- 串行依赖很强 — 前一步不完成后一步没法开始,拆了也只是排队,还多通信开销
- 低延迟链路 — 通信往返的成本大于分工收益
- 以”写”为主 — 连续创作、统一代码风格更依赖整体一致性
业界共识:
- 读为主的任务 → 适合多 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 给不了的三大场景:
- 委派开放性目标:不一步步指挥,而是”这个子方向你自己规划、自己干完给我”。MCP 每次调用要求你知道自己要调什么;A2A 允许你把决策权交给对方。
- 长期异步 + 主动汇报:干到一半缺信息能反过来找你。MCP 是”你问它答”的请求-响应,没有对方主动推给你的通道。
- 对等协作/争议:双方各有判断,事务中协商(如 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 换取并行度与专注度。当这份收益大于通信、成本和治理复杂度时,才应该拆。
落地四步:
- 先让单 Agent 跑通
- 定位真实瓶颈
- 按上下文、并行、权限三个维度拆分
- 动手前先把每个 Agent 的输入、输出与失败预算定义清楚
记住:先别拆,想清楚再拆。
相关笔记
- AI 大模型 MOC · ↪ 返回 Agent/MOC 索引