知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Multi-Agent 协作系统设计 > 导读:本文从"一个 Agent 既当规划者又当执行者还当裁判,结果上下文爆炸、注意力稀释、一把梭失败"这个痛点出发,把编排模式、通信协议、角色与能力设计、冲突解决、状态共享、任务分解、失败处理以及生产落地考量逐项讲透,最后给出工程实践与踩坑。适合正在设计多 Agent 平台、或准备 Agent 系统设计面试的同学。  *图:多 Agent 协作——协调者、消息传递与共享状态* ## 一、先建立全局认知 ### Q:单 Agent 到底会在哪里撞墙? A:结论先行——五个天花板:**上下文窗口、注意力稀释、单点故障、串行瓶颈、角色冲突**。 | 局限 | 原因 | 真实影响 | |---|---|---| | 上下文窗口天花板 | 一个会话只能塞有限 token;复杂任务需要大量工具定义、中间结果、多轮交互 | 128K 窗口看起来大,但工具定义 5K + 中间检索结果 20K + 10 轮思考 30K → 很快耗尽 | | 注意力稀释 | System Prompt 越长,LLM 对关键指令的遵循度越低(Lost-in-the-Middle,中间信息被忽略效应) | 一个 Agent 同时要懂财务、法律、代码、设计 → 各方面都不精 | | 单点故障 | 一次 LLM 幻觉或工具调用失误 → 整条链路报废 | 关键业务不能接受"一把梭失败就重来" | | 串行瓶颈 | ReAct 循环严格串行:Think → Act → Observe → Think… | 很多子任务天然可并行(同时查 A、B 两家公司财报),单 Agent 无法并发 | | 角色冲突 | 同一个 Agent 既做规划又做执行还要做校验 | "裁判"和"选手"是同一个人,缺乏制衡 | ### Q:多 Agent 的收益和代价分别是什么? A:结论先行——收益是**分工专精、并行加速、质量制衡、故障隔离、可组合、上下文分区**;代价是**延迟增加、成本上升、协调复杂度、一致性风险、调试困难**。  *图:单 Agent 模式与多 Agent 模式的对比* ```text 单 Agent 模式: ┌──────────────────────────────────┐ │ Agent(一个大脑 + 所有工具) │ │ 规划 → 执行 → 校验 → 纠错 │ │ 全在一个 context 里 │ └──────────────────────────────────┘ 多 Agent 模式: ┌──────┐ ┌──────┐ ┌──────┐ │规划者│ → │执行者│ → │校验者│ │Agent │ │Agent │ │Agent │ └──────┘ └──────┘ └──────┘ ↑ 各自独立 context,专注单一职责 ↓ ``` | 收益 | 机制 | |---|---| | 分工专精 | 每个 Agent 的 System Prompt 短而聚焦,LLM 遵循度大幅提升 | | 并行加速 | 独立子任务分配给不同 Agent 并发执行 | | 质量制衡 | 一个 Agent 生成、另一个审查;投票/辩论提高输出质量 | | 故障隔离 | 一个子 Agent 失败不影响其他;可以换 Agent 重试 | | 可组合性 | 不同 Agent 团队可组合应对不同任务类型 | | 上下文分区 | 每个 Agent 独立上下文窗口,总有效容量 = N × 单个窗口 | 代价必须清醒认识: | 代价 | 说明 | 缓解策略 | |---|---|---| | 延迟增加 | 多 Agent 之间需要通信、协调、等待 | 并行化、异步通信、超时熔断 | | 成本上升 | 多个 LLM 调用叠加;中转消息也消耗 token | 小模型做简单子任务;结构化通信减少 token | | 协调复杂度 | 怎么传消息、谁等谁、失败怎么传播 | 定义清晰的编排协议和状态机 | | 一致性风险 | 多个 Agent 对同一事实产生矛盾认知 | 全局上下文总线、冲突仲裁机制 | | 调试困难 | 链路变长,一次失败要排查 N 个 Agent | 全链路追踪、每个 Agent 独立日志 |  *图:从单 Agent 到多 Agent 专业团队* ### Q:什么时候不该上多 Agent? A:结论先行——**能用一个 Agent 做好的事,不要强行拆分**;多 Agent 适用于"任务天然可分解、子任务异构性强、质量要求高于延迟要求"的场景。 这条"第一性原则"是面试里最容易被追问的判断题。反过来说,如果一个任务的任务分解需要大量人工设计、子任务之间强耦合、或者对延迟极其敏感,那么拆成多 Agent 只会把简单问题变复杂。 ## 二、编排模式 ### Q:有哪几种主流编排模式,分别适合什么场景? A:结论先行——六种:**顺序管道、并行分发、辩论/竞争、投票/集成、层级委派、黑板模式**。 | 模式 | 数据流 | 适用场景 | 主要代价 | |---|---|---|---| | 顺序管道 Sequential | 上一个输出是下一个输入 | 步骤明确有先后依赖:代码生成→审查→测试→文档;ETL | 完全串行,延迟是各阶段之和;任一阶段失败后续全阻塞;上游错误层层放大 | | 并行分发 Parallel | 拆分→并发→汇总(Map-Reduce) | 多独立数据源查询、批量处理、多视角分析 | 汇总可能成瓶颈;子任务间缺乏信息共享;不适用有依赖的场景 | | 辩论/竞争 Debate | 各自出答案→交叉审查→多轮→裁判 | 高准确性(数学证明、逻辑推理)、需要多视角批判、事实核查 | 延迟极高(N×M 次调用)、成本高、可能不收敛 | | 投票/集成 Voting | 独立出答案→投票选最终 | 分类/标注、安全敏感决策、事实性问答 | 成本 N 倍;若所有 Agent 有相同系统性偏差则投票无法纠正;开放式生成投票意义不大 | | 层级委派 Hierarchical | Supervisor 拆解→派发 Worker→汇总 | 复杂多步骤项目、需要动态调整、异构团队 | Supervisor 成瓶颈与单点;对其能力要求高;上下文管理难 | | 黑板 Blackboard | 共享黑板,各 Agent 自主读写 | 多领域专家协作、增量式求解、Agent 可动态加入退出 | 缺乏明确流程控制,难预测何时结束;黑板结构设计难;调度策略影响大 |  *图:多 Agent 编排模式*  *图:主从协作模式*  *图:层级委派架构*  *图:对等协作模式* ### Q:顺序管道和并行分发,实现上要注意什么? A:结论先行——**管道的核心是"上下文在阶段间传递 + 单步超时 + 错误是否中断",并行的核心是"子任务独立 + 单任务超时 + 失败不扩散"**。 ```python @dataclass class PipelineContext: task_id: str data: dict = field(default_factory=dict) metadata: dict = field(default_factory=dict) errors: list = field(default_factory=list) class SequentialPipeline: def __init__(self, agents: list, stop_on_error: bool = True): self.agents = agents self.stop_on_error = stop_on_error async def run(self, initial_ctx: PipelineContext) -> PipelineContext: ctx = initial_ctx for agent in self.agents: step_start = time.time() try: ctx = await asyncio.wait_for(agent.process(ctx), timeout=120) ctx.metadata[f"{agent.name}_latency_ms"] = (time.time() - step_start) * 1000 except Exception as e: ctx.errors.append({"agent": agent.name, "error": str(e)}) if self.stop_on_error: break # 是否中断由配置决定 return ctx ``` 并行分发用 `asyncio.gather` 一次性并发: ```python class ParallelDispatcher: async def run(self, subtasks: list) -> list: async def execute_one(subtask): agent = self.agents.get(subtask.assigned_agent) if not agent: return SubtaskResult(subtask.id, "unknown", None, error=f"Agent {subtask.assigned_agent} not found") try: result = await asyncio.wait_for(agent(subtask.payload), timeout=60) return SubtaskResult(subtask.id, subtask.assigned_agent, result) except Exception as e: return SubtaskResult(subtask.id, subtask.assigned_agent, None, str(e)) return list(await asyncio.gather(*[execute_one(st) for st in subtasks])) ``` 关键点解读:并行分发的 "单任务超时 60s" 和管道的 "单步超时 120s" 是不同量级——**并行场景下整体延迟由最慢的子任务决定,所以单任务超时必须收紧**,否则一个慢任务会拖住整个批次。 ### Q:辩论模式和投票模式,怎么选? A:结论先行——**答案可客观评分选投票,答案需要推理碰撞选辩论**。  *图:按问题特征选择多 Agent 编排模式* ```text 你要解决的问题是? ├── 步骤明确、先后有序? → 顺序管道 ├── 子任务完全独立、可并行? → 并行分发 ├── 需要多个答案中选最优? │ ├── 答案可客观评分 → 投票模式(分类标注、安全决策) │ └── 答案需要推理碰撞 → 辩论模式(逻辑推理、战略分析) ├── 任务复杂、需要灵活协调? → 层级委派 ├── 多专家松耦合协作? → 黑板模式 └── 都不完全匹配? → 组合使用 (例如"层级委派"的 Supervisor 内部用"投票"做关键决策) ``` 辩论模式的编排骨架: ```python class DebateOrchestrator: def __init__(self, agents, judge, max_rounds: int = 3, convergence_threshold: float = 0.9): ... async def run(self, question: str) -> dict: positions = {} for name, agent in self.agents.items(): positions[name] = await agent(question) # 各自独立初始答案 for rnd in range(1, self.max_rounds + 1): critiques = {} for name, agent in self.agents.items(): others = {k: v for k, v in positions.items() if k != name} critiques[name] = await agent( f"问题:{question}\n你的当前答案:{positions[name]}\n" f"其他 Agent 的答案:{others}\n" f"请指出其他答案中的问题,并决定是坚持还是修正你的答案。") if self._check_convergence(positions): break # 收敛则提前结束 for name, agent in self.agents.items(): positions[name] = await agent( f"问题:{question}\n你的答案:{positions[name]}\n批评意见:{critiques}\n" f"请综合所有信息,给出你修正后的最终答案。") return await self.judge(question, positions, critiques) # 裁判裁决 ``` 投票模式的四种策略必须记住: ```python class VoteStrategy(Enum): MAJORITY = "majority" # 简单多数 WEIGHTED = "weighted" # 加权投票 UNANIMITY = "unanimity" # 全票通过 SUPER_MAJORITY = "super" # 超多数(如 2/3) ``` 关键点解读:`UNANIMITY` 和 `SUPER_MAJORITY` 在"存在分歧"时返回 `conflict=True` 而不是强行给答案——**这正是它们用于安全敏感决策的原因**:宁可升级人工,也不要让一个 60% 的多数票去批准一个危险操作。另外注意"5 个 80% 准确率的 Agent 投票,理论准确率可达 94%+"这个经典结论成立的前提是**各 Agent 的错误相互独立**;如果它们都基于同一个有偏差的数据源,投票只会放大偏差。  *图:多 Agent 辩论流程* ## 三、Agent 通信协议  *图:Agent 通信协议* ### Q:Agent 之间用什么载体传信息? A:结论先行——**结构化 JSON 为首选,自然语言为补充(需解释推理的场景),共享内存为性能优化(高频状态同步)**。  *图:Agent 之间的信息载体:三种选择* ```text ┌──────────────┬──────────────────┬────────────────────┐ │ 结构化 JSON │ 自然语言文本 │ 共享内存/黑板 │ ├──────────────┼──────────────────┼────────────────────┤ │ 强类型 │ 灵活、类人 │ 最低延迟 │ │ 可自动校验 │ 信息密度低 │ 隐式通信 │ │ 上下游解耦 │ 下游需要理解 │ 状态一致性难保证 │ │ 适合机器消费 │ 适合人类阅读 │ 适合高频读写 │ │ 不够灵活 │ 难以自动校验 │ 耦合度最高 │ └──────────────┴──────────────────┴────────────────────┘ ``` ### Q:消息信封要包含哪些字段? A:结论先行——除了 **id、类型、收发方、负载**,最容易漏但最关键的三个是 `correlation_id`(请求-响应配对)、`protocol_version`(向前兼容)、`ttl_seconds`(消息有效期)。 ```python class MessageType(Enum): TASK_ASSIGN = "task_assign" # Supervisor → Worker:分配任务 TASK_RESULT = "task_result" # Worker → Supervisor:返回结果 TASK_PROGRESS = "task_progress" # 进度更新 QUERY = "query" # 信息查询 RESPONSE = "response" # 对 Query 的回复 CRITIQUE = "critique" # 辩论模式:批评意见 PROPOSAL = "proposal" # 辩论模式:新提案 BLACKBOARD_WRITE = "bb_write" BLACKBOARD_READ = "bb_read" HEARTBEAT = "heartbeat" ERROR = "error" HUMAN_ESCALATION = "escalation" # 升级到人类 @dataclass class AgentMessage: message_id: str = field(default_factory=lambda: str(uuid.uuid4())) msg_type: MessageType = MessageType.QUERY sender: str = "" receiver: str = "" # "*" 表示广播 correlation_id: str = "" # 关联消息 ID(请求-响应配对) timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat()) protocol_version: str = "1.0" # 向前兼容 payload: dict = field(default_factory=dict) summary: str = "" # 自然语言摘要(方便 LLM Agent 理解) priority: int = 5 # 1-10,10 最高 ttl_seconds: int = 300 # 消息有效期 requires_ack: bool = False # 是否需要确认 ``` 关键点解读:`summary` 字段是一个很巧妙的折中——**负载用结构化 JSON 保证机器可解析,同时附一句自然语言摘要方便 LLM 理解**,兼顾了两种载体的优点。另外 `receiver="*"` 表示广播,这是黑板和事件驱动模式的基础。  *图:事件驱动通信架构* ### Q:同步通信还是异步通信? A:结论先行——**混合使用**:短任务(期望 < 30s)用同步、长任务用异步消息队列、横向通信用异步事件总线、黑板读写用同步共享存储、心跳用异步周期推送。 | 维度 | 同步(请求-响应) | 异步(消息/事件驱动) | |---|---|---| | 延迟 | 调用方阻塞等待 | 不阻塞,通过回调/轮询取结果 | | 可靠性 | 调用方立刻感知故障 | 需要超时 + 重试 + 确认机制 | | 实现复杂度 | 简单 | 较高(消息队列、事件总线) | | 适用场景 | Supervisor 直接调用 Worker、短任务 | 长任务、广播通知、黑板模式 | | 背压处理 | 调用方自然限流 | 需要消息队列缓冲 + 消费者限流 |  *图:按任务长短与交互场景选择同步或异步* ```text Supervisor 分配任务给 Worker: → 同步 HTTP/gRPC 调用(短任务,期望 < 30s) → 异步消息队列(长任务,允许 > 30s) Worker 之间横向通信: → 异步事件总线(解耦) 黑板读写: → 同步读写共享存储(Redis/DB) 心跳/监控: → 异步周期推送 ``` 事件总线的实现要点是"**发布-订阅 + 消息日志**",日志的意义在于支持迟加入的 Agent 补课: ```python class AgentEventBus: def __init__(self): self._subscribers: dict[MessageType, list] = defaultdict(list) self._message_log: list[AgentMessage] = [] def subscribe(self, msg_type: MessageType, handler): self._subscribers[msg_type].append(handler) async def publish(self, message: AgentMessage): self._message_log.append(message) handlers = self._subscribers.get(message.msg_type, []) tasks = [asyncio.create_task(h(message)) for h in handlers] if tasks: await asyncio.gather(*tasks, return_exceptions=True) def query(self, sender: str = None, msg_type: MessageType = None, since: str = None) -> list[AgentMessage]: """查询历史消息(用于迟加入的 Agent 补课)""" results = self._message_log if sender: results = [m for m in results if m.sender == sender] if msg_type: results = [m for m in results if m.msg_type == msg_type] if since: results = [m for m in results if m.timestamp > since] return results ``` ## 四、角色与能力设计 ### Q:一个 Agent 的角色应该由哪些维度定义? A:结论先行——三个维度:**职责边界(负责什么)、能力画像(擅长什么)、行为约束(不能做什么)**。 ```python @dataclass class AgentRole: role_id: str role_name: str # 维度 1:职责边界 responsibility: str # 一句话描述职责 scope_of_work: list # 具体工作范围 authority: list # 权限列表(能做什么操作) # 维度 2:能力画像 expertise: list # 专业领域 ["Python", "Django", "PostgreSQL"] skill_level: dict # 各技能熟练度(1-10) known_limitations: list # 已知局限 # 维度 3:行为约束 forbidden_actions: list # 禁止操作 escalation_policy: str # 超出能力范围时怎么办 max_autonomy: str # "low" | "medium" | "high" ``` ### Q:角色定义有哪些最佳实践? A:结论先行——四条:**单一职责、能力边界清晰(会说"我不会什么"比"我会什么"更重要)、System Prompt 短而精(500~2000 tokens)、重叠能力 + 不同视角优于完全不重叠**。 ```text ✅ 单一职责:一个 Agent 只做一类事 ❌ "能做代码审查也能写前端还能管数据库" ✅ "专门做 Python 后端代码审查" ✅ 能力边界清晰:明确说"我不会什么"比"我会什么"更重要 ✅ "我是前端专家,不了解后端数据库设计" ✅ System Prompt 短而精:500-2000 tokens 最佳 ❌ 把大量领域知识塞进 System Prompt ✅ 领域知识放外部工具(RAG),System Prompt 只定义角色行为 ✅ 重叠能力 + 不同视角 > 完全不重叠 适当的能力重叠可以形成交叉验证 ``` 关键点解读:第四条"适度的能力重叠"和第一条"单一职责"看起来矛盾,其实不矛盾——单一职责约束的是"**这个 Agent 的目标和权限**",能力重叠提供的是"**交叉验证的冗余**"。评委和选手不能是同一个人,但两个评委可以都懂财务。 ### Q:Agent 怎么被"发现"和"选中"? A:结论先行——用**注册中心(AgentRegistry)+ 能力矩阵**做静态匹配,用**动态能力管理(DynamicCapabilityManager)+ 健康检查**做运行时选择。 ```python class AgentRegistry: def register(self, role: AgentRole, instance): self._agents[role.role_id] = role self._instances[role.role_id] = instance def find_by_capability(self, required_skill: str, min_level: int = 5) -> list[str]: return [rid for rid, role in self._agents.items() if required_skill in role.expertise and role.skill_level.get(required_skill, 0) >= min_level] def list_capabilities(self) -> dict: """生成能力矩阵,供 Supervisor 做决策""" ... class DynamicCapabilityManager: def get_best_agent(self, required_skill: str, min_level: int = 5): """找到技能匹配且当前负载最低的 Agent""" candidates = self.registry.find_by_capability(required_skill, min_level) best, best_load = None, float("inf") for cid in candidates: health = self._health_cache.get(cid, {"online": True, "load": 0}) if health["online"] and health["load"] < best_load: best, best_load = cid, health["load"] return best ``` 关键点解读:`find_by_capability` 只做技能过滤,`get_best_agent` 才叠加"在线 + 负载最低"——**把"能不能做"和"该不该现在做"分成两层**,这个分层让调度策略可以独立演进(例如后续加入成本、延迟、历史成功率等维度)。 ## 五、冲突解决 ### Q:多 Agent 会产生哪几类冲突? A:结论先行——四类:**事实冲突、判断冲突、行动冲突、规划冲突**。 | 冲突类型 | 场景 | 示例 | |---|---|---| | 事实冲突 | 不同 Agent 声称不同事实 | A:"数据库有 100 万条记录";B:"50 万条" | | 判断冲突 | 同一问题的不同主观评价 | A:"这代码质量 8/10";B:"4/10" | | 行动冲突 | 提议互相矛盾的操作 | A:"应该扩容缓存";B:"应该优化查询" | | 规划冲突 | Supervisor 和 Worker 对下一步有分歧 | Supervisor 想先做 A;Worker 认为先做 B | ### Q:冲突解决应该按什么顺序? A:结论先行——按"**从确定到灵活、从自动到人工**"分层:规则引擎 → 投票 → Agent 自协商 → Supervisor 仲裁 → 升级人工。 ```text Level 1: Agent 自协商(辩论,交换论据) 耗时 中 可靠性 中 Level 2: 投票仲裁(多数/加权/历史准确率) 耗时 低 可靠性 中高 Level 3: Supervisor 仲裁 耗时 低 可靠性 取决于 Supervisor Level 4: 规则引擎(如安全 Agent 有否决权) 耗时 极低 可靠性 高(确定性场景) Level 5: 升级到人工 耗时 极高 可靠性 最高 ``` ```python async def resolve(self, conflict: Conflict) -> dict: # Level 4: 规则引擎(最快、最确定) if conflict.conflict_type in self.rule_engine: result = self.rule_engine[conflict.conflict_type](conflict) if result: self._record(conflict, "rule_engine", result) return result # Level 2: 投票(对于有明确多数的情况) if conflict.conflict_type in (ConflictType.FACT, ConflictType.JUDGMENT): vote_result = self._voting_resolve(conflict) if vote_result["confidence"] > 0.8: # 置信度不够就不采纳 self._record(conflict, "voting", vote_result) return vote_result # Level 3: Supervisor 仲裁 if self.supervisor_fn and conflict.severity in ("medium", "high"): decision = await self.supervisor_fn(conflict) self._record(conflict, "supervisor", decision) return decision # Level 5: 升级人工 if conflict.severity in ("high", "critical") and self.escalate_fn: decision = await self.escalate_fn(conflict) self._record(conflict, "human", decision) return decision # 兜底:拒绝做出决策 return {"decision": None, "reason": "无法解决冲突,需要人工介入", "conflict": conflict} ``` 关键点解读:**注意执行顺序和上面列表的编号不完全一致——先跑"最确定"的规则引擎和投票(便宜且快),再跑"最灵活"的自协商和 Supervisor(贵且慢)**。这是典型的"先便宜后昂贵"的短路策略。同时兜底返回的是 `decision=None` 而不是随便给一个答案,这个"拒绝自动决策"的默认值很关键。 ### Q:什么是"否决权模式"? A:结论先行——某些角色(如安全 Agent、合规 Agent)对特定操作拥有**一票否决权**,无论其他 Agent 投票结果如何。 ```python class VetoPolicy: def __init__(self): self.policies = { "safety_agent": { "can_veto": ["deploy_to_production", "delete_data", "modify_schema"], "veto_reason_required": True, }, "compliance_agent": { "can_veto": ["share_pii", "export_data"], "veto_reason_required": True, }, } def check_veto(self, agent_role: str, proposed_action: str) -> tuple[bool, str]: policy = self.policies.get(agent_role, {}) if proposed_action in policy.get("can_veto", []): return True, f"{agent_role} 对此操作拥有否决权" return False, "" ``` 关键点解读:否决权的存在意味着**投票不是纯粹的"少数服从多数"**——这是安全设计对抗"群体盲思"的机制。注意 `veto_reason_required=True`:否决必须给理由,否则 Agent 无法从拒绝中学习,只会反复重试。 ## 六、状态共享与记忆  *图:分区式共享状态* ### Q:状态应该共享还是隔离? A:结论先行——**两个极端都有硬伤,推荐"分区式共享"**:全局上下文放共享事实与决策,私有上下文放各自中间推理。 | 维度 | 完全隔离 | 全局共享 | |---|---|---| | 上下文窗口 | 各 Agent 独立、充裕 | 共享窗口,容易膨胀 | | 信息一致性 | 可能矛盾 | 单一数据源,一致 | | 隐私/安全 | 敏感信息不泄露 | 所有 Agent 可见 | | 协作效率 | 需要显式通信 | 隐式感知,效率高 | | 耦合度 | 低 | 高 | | 推荐场景 | 隐私敏感、独立任务 | 需要紧密协作、信息对称 |  *图:全局上下文与各 Agent 的私有上下文* ```text ┌────────────────────────────────────────────────┐ │ 全局上下文(Global Context) │ │ • 用户原始请求 │ │ • 任务整体目标与截止时间 │ │ • 共享的事实基线("到目前为止我们已知…") │ │ • 已经做出的关键决策 │ └──────────────┬─────────────────────────────────┘ ┌──────────┼──────────┬──────────┐ ▼ ▼ ▼ ▼ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │Agent1│ │Agent2│ │Agent3│ │Agent4│ │私有 │ │私有 │ │私有 │ │私有 │ │上下文│ │上下文│ │上下文│ │上下文│ └──────┘ └──────┘ └──────┘ └──────┘ 全局上下文:所有 Agent 可读写,但要遵循写入规范 私有上下文:仅本 Agent 可见(中间推理、草稿、临时变量) ``` ### Q:共享状态最容易出的问题是什么?怎么解? A:结论先行——**同一 key 被不同 Agent 写入不同值(事实冲突)**;解法是"带来源标记 + 冲突检测 + 决策日志"。 ```python class SharedStateManager: def __init__(self): self.global_context: dict = {} self.private_contexts: dict[str, dict] = {} self.decisions_log: list = [] self._lock = RLock() # 并发写入保护 def add_fact(self, key: str, value, source_agent: str) -> bool: """向全局上下文添加事实(带来源标记与冲突检测)""" with self._lock: if key in self.global_context.get("known_facts", {}): existing = self.global_context["known_facts"][key] if existing["value"] != value: # 冲突:同一 key 被写入不同值 → 记录冲突,拒绝覆盖 self.global_context.setdefault("_conflicts", []).append({ "key": key, "existing": existing, "new": {"value": value, "source": source_agent}, }) return False self.global_context.setdefault("known_facts", {})[key] = { "value": value, "source": source_agent, "timestamp": datetime.utcnow().isoformat(), } return True def get_global_summary(self) -> str: """生成全局上下文摘要(用于发给新加入的 Agent)""" facts = self.global_context.get("known_facts", {}) decisions = self.global_context.get("key_decisions", []) summary = f"任务:{self.global_context.get('user_request', '')}\n\n已知事实:\n" for k, v in facts.items(): summary += f" - {k}: {v['value']} (来源: {v['source']})\n" summary += "\n关键决策:\n" for d in decisions: summary += f" - [{d['made_by']}] {d['decision']} (原因: {d['reason']})\n" return summary ``` 关键点解读:`add_fact` 遇到冲突时**返回 False 并记录冲突,而不是覆盖**——这是"事实基线不可静默篡改"的设计。`get_global_summary` 则是"迟加入 Agent 的 onboarding 材料":新 Worker 不需要重放全部历史,读一段摘要就能对齐上下文。 ## 七、任务分解与分配 ### Q:好的任务分解有哪些原则? A:结论先行——四条:**独立性最大化、粒度适中(30s~5min/子任务)、天然边界对齐、可验证**。 ```text 1. 独立性最大化:子任务之间依赖越少越好 ✅ 并行执行机会多,故障传播少 2. 粒度适中: ❌ 太细 → 协调开销 >> 执行开销 ❌ 太粗 → 失去多 Agent 优势,退化为单 Agent ✅ 每个子任务 Agent 可独立完成,耗时 30s-5min 3. 天然边界对齐: ✅ 按领域拆分(前端、后端、数据) ✅ 按阶段拆分(设计、实现、测试) ❌ 按技术步骤拆分(先写 import,再写 class…) 4. 可验证性:每个子任务有明确的完成标准和输出格式 ✅ "输出一个包含 3 个 API 端点的 OpenAPI 规范文档" ❌ "优化一下性能" ``` 关键点解读:第 3 条"不要按技术步骤拆分"是多 Agent 分解里最容易被违反的原则——把"写 import → 写 class → 写方法"拆给不同 Agent,只会制造大量依赖和通信,收益为负。 ### Q:Planner 生成的依赖关系一定要校验吗? A:结论先行——**必须校验,且要用拓扑排序检测环**,因为 LLM 生成的依赖图完全可能自相矛盾。 ```python def _validate_dag(self, subtasks: list): """检测依赖是否有循环(拓扑排序)""" task_ids = {t.task_id for t in subtasks} in_degree = {t.task_id: len([d for d in t.dependencies if d in task_ids]) for t in subtasks} queue = [tid for tid, deg in in_degree.items() if deg == 0] visited = set() while queue: tid = queue.pop(0) visited.add(tid) for t in subtasks: if tid in t.dependencies and t.task_id not in visited: in_degree[t.task_id] -= 1 if in_degree[t.task_id] == 0: queue.append(t.task_id) if len(visited) != len(subtasks): raise ValueError("任务依赖关系存在循环!") ``` 配套的 `SubTask` 字段要包含:`required_capabilities`(所需能力)、`dependencies`(依赖任务)、`output_format`(输出格式)、`acceptance_criteria`(验收标准)、`estimated_tokens`、`priority`。Planner 的 prompt 必须要求"输出的所有子任务完成后可以组合成最终结果"——**这是分解正确性的最终判据**。 ### Q:Worker 怎么分配?失败了怎么办? A:结论先行——分配逻辑是"**先按单项技能找最优 Agent;没有单个 Agent 覆盖全部技能时,找覆盖最多的**";失败则走重分配并排除已失败的 Agent。 ```python async def assign(self, subtask: SubTask) -> str: for skill in subtask.required_capabilities: agent_id = self.capability_mgr.get_best_agent(skill) if agent_id: self.assignments[subtask.task_id] = agent_id return agent_id # 没有单个 Agent 覆盖所有技能 → 找覆盖最多的 best_agent, best_coverage = None, 0 for agent_id, role in self.registry._agents.items(): coverage = len(set(subtask.required_capabilities) & set(role.expertise)) if coverage > best_coverage: best_coverage, best_agent = coverage, agent_id if best_agent and best_coverage > 0: self.assignments[subtask.task_id] = best_agent return best_agent raise ValueError(f"没有 Agent 可以执行任务 {subtask.task_id}") ``` ## 八、失败处理 ### Q:多 Agent 系统有哪些失败模式? A:结论先行——六类:**Agent 崩溃、工具调用失败、质检不通过、依赖失败、通信失败、Supervisor 失败**,其中 Supervisor 失败影响面最大(整个任务失败)。  *图:多 Agent 协作的失败类型、典型原因与影响范围* ```text ┌─────────────────┬────────────────────────┬──────────────────────────┐ │ 失败类型 │ 典型原因 │ 影响范围 │ ├─────────────────┼────────────────────────┼──────────────────────────┤ │ Agent 崩溃 │ LLM 返回无效格式、超时、OOM│ 仅该 Agent 的当前子任务 │ │ 工具调用失败 │ API 不可用、参数错误 │ 当前 step 可重试 │ │ 质检不通过 │ 输出不符合验收标准 │ 需要该 Agent 重新生成 │ │ 依赖失败 │ 上游 Agent 失败 │ 所有下游 Agent 阻塞 │ │ 通信失败 │ 消息丢失、超时 │ Agent 之间失去协调 │ │ Supervisor 失败 │ 规划错误、Supervisor 崩溃 │ ⚠️ 整个任务失败 │ └─────────────────┴────────────────────────┴──────────────────────────┘ ``` ### Q:失败处理策略怎么设计? A:结论先行——六种策略按"**同 Agent 重试 → 换 Agent 重试 → 降级 → 补偿 → 中止 → 升级人工**"递进,配合**指数退避 + 失败计数**。 ```python class FailureStrategy(Enum): RETRY_SAME = "retry_same" # 同 Agent 重试 RETRY_DIFFERENT = "retry_different" # 换一个 Agent 重试 DEGRADE = "degrade" # 降级(跳过该子任务,部分成功) COMPENSATE = "compensate" # 补偿(用备用方案完成) ABORT = "abort" # 中止任务 ESCALATE = "escalate" # 升级人工 class FailureHandler: def __init__(self, config: dict = None): self.config = config or { "max_retries_same": 2, # 同一 Agent 最多重试几次 "max_retries_different": 1, # 最多换几个 Agent "retry_delay_base": 1.0, # 重试退避基数(秒) "abort_on_critical": True, # 关键任务失败是否直接中止 } self.failure_counts: dict[str, int] = {} async def handle(self, task_id, error, task, context) -> tuple[FailureStrategy, dict]: fail_count = self.failure_counts.get(task_id, 0) + 1 self.failure_counts[task_id] = fail_count severity = self._assess_severity(error) if severity == "critical" and self.config["abort_on_critical"]: return FailureStrategy.ABORT, {"reason": f"关键错误: {error}"} if fail_count <= self.config["max_retries_same"]: delay = self.config["retry_delay_base"] * (2 ** (fail_count - 1)) # 指数退避 return FailureStrategy.RETRY_SAME, {"delay": delay, "attempt": fail_count} if fail_count <= self.config["max_retries_same"] + self.config["max_retries_different"]: return FailureStrategy.RETRY_DIFFERENT, { "reason": f"同一 Agent 重试 {self.config['max_retries_same']} 次后仍失败", "failed_agent": context.get("agent_id"), } if task.priority <= 3: # 低优先级任务可降级 return FailureStrategy.DEGRADE, {"reason": "低优先级任务,降级跳过"} return FailureStrategy.ESCALATE, {"reason": f"已重试 {fail_count} 次"} ``` 关键点解读:**"换 Agent 重试"之所以比"同 Agent 重试"更强,是因为它利用了多 Agent 的异构性**——如果是 Agent 本身的能力问题,重试再多次也没用。另外"降级"只允许作用于低优先级任务(`priority <= 3`),这是"不能为了完成率而牺牲关键结果"的体现。 ### Q:什么是"部分成功",为什么要支持它? A:结论先行——因为生产环境里"**全部成功或全部失败**"的二值逻辑不现实;已完成的子任务结果必须保留,只重试/补偿失败的部分。 ```python @dataclass class RunResult: run_id: str status: str # success | partial_success | failed completed_tasks: dict # 成功的子任务结果 failed_tasks: dict # 失败的子任务及原因 skipped_tasks: list # 因依赖失败而跳过的子任务 summary: str = "" class PartialSuccessHandler: def __init__(self, min_completion_rate: float = 0.6): self.min_completion_rate = min_completion_rate def evaluate(self, plan, results, errors) -> RunResult: total, completed = len(plan), len(results) # 找出因依赖失败而跳过的任务 skipped, failed_ids = [], set(errors.keys()) for task in plan: if task.task_id not in results and task.task_id not in failed_ids: if any(dep in failed_ids for dep in task.dependencies): skipped.append(task.task_id) completion_rate = completed / total if total > 0 else 1.0 if completion_rate >= 1.0: status = "success" elif completion_rate >= self.min_completion_rate: status = "partial_success" else: status = "failed" return RunResult(run_id=str(uuid.uuid4()), status=status, completed_tasks=results, failed_tasks=errors, skipped_tasks=skipped, summary=f"完成率: {completion_rate:.1%} ({completed}/{total})") ``` 关键点解读:`status` 有**三态而不是两态**,`partial_success`(示例阈值 60%)这个中间态是非常实用的工程折中:它让下游系统能区分"完全失败(别用)"和"部分可用(可以给用户看,但要说清缺什么)"。 ## 九、工程实践与踩坑 ### Q:多 Agent 的架构分几层? A:结论先行——四层:**接入层、编排层(编排引擎 + Planner + Supervisor)、执行层(Worker Pool)、基础设施层(注册中心 + 共享状态 + 事件总线 + 冲突仲裁 + 失败处理 + Checkpoint)**,另有外部依赖(LLM、工具服务、人工审核)。  *图:多 Agent 协作五层架构与 Worker 分组* ```text 接入层:API Gateway │ 编排层:OrchestrationEngine ├── Planner Agent(任务分解) └── Supervisor Agent(任务调度与仲裁) │ 执行层:Worker Pool ├── 代码 Agent × 3 ├── 审查 Agent × 2 ├── 测试 Agent × 2 └── 安全 Agent × 1 │ 基础设施层:Agent Registry / Shared State Manager / Event Bus Conflict Resolver / Failure Handler / Checkpoint Store │ 外部:LLM Provider(GPT / Claude / Gemini)、Tool Services、Human Review ``` 编排引擎的 `run` 流程固定为五步:`初始化运行状态 → 任务分解 → 按编排模式执行(hierarchical/pipeline/parallel)→ 评估结果(部分成功判定)→ 持久化最终状态`;如果传入 `checkpoint_id` 则走 `_resume_from_checkpoint` 恢复。**支持三种编排模式可切换、并复用同一套分解与评估逻辑**,是这个设计的关键抽象。 Worker 基类的 `execute` 也是标准 ReAct 循环:构建 System Prompt(注入角色职责/专长/限制/禁止操作)→ 注入全局上下文摘要 → 最多 15 步循环(调用 LLM → 执行工具 → 回填结果);工具执行前先检查 `forbidden_actions` 权限。 ### Q:可观测性要做到什么程度? A:结论先行——三个层面都要:**Agent Run 级别(run_id、状态、耗时、子任务完成率)、Agent 通信级别(消息收发日志、通信延迟 P50/P95/P99)、LLM 调用级别(token、耗时、模型、Prompt/Response 脱敏内容、工具成功率)**。 核心手段是分布式追踪:`start_run` 记录起点,`record_llm_call` / `record_message` / `record_error` 记录各维度事件,`finish_run` 收尾并算出 `duration_ms` 与最终状态。 关键点解读:多 Agent 系统里**"消息级追踪"是单 Agent 没有的必需项**——排查一个多 Agent 故障,往往要从"谁给谁发了什么、什么时候发的、对方处理了多久"这条链路入手。 ### Q:成本和延迟怎么控? A:结论先行——成本靠**模型分级 + 缓存 + 并行 + 提前终止 + token 预算**;延迟靠**并行、流式、预热、小模型、异步、结果缓存**。 ```text 成本优化策略: 1. 模型分级 Planner/Supervisor → 强模型(贵但聪明) Worker / 校验 Agent → 小模型(便宜且够用) 2. 缓存工具调用结果(相同参数返回缓存结果,设置合理 TTL) 3. 并行执行减少等待成本 4. 提前终止 投票模式:前 3 票已达成绝对多数 → 不再调用剩余 Agent 辩论模式:连续 2 轮无实质改进 → 提前终止 5. Token 预算管理 每子任务设置最大 token 预算,超预算则降级或中止 整个 Run 设置总 token 预算上限 ``` ```python class CostController: def __init__(self, max_total_tokens: int = 500_000, max_tokens_per_task: int = 50_000): self.max_total_tokens = max_total_tokens self.max_tokens_per_task = max_tokens_per_task self.total_tokens_used = 0 self.task_tokens: dict[str, int] = {} def check_budget(self, task_id: str, estimated_tokens: int) -> bool: if self.task_tokens.get(task_id, 0) + estimated_tokens > self.max_tokens_per_task: return False if self.total_tokens_used + estimated_tokens > self.max_total_tokens: return False return True ``` | 延迟优化策略 | 效果 | 代价 | |---|---|---| | 并行子任务执行 | 总延迟 ≈ max(T₁, T₂, …) 而非 ΣT | 需要子任务无依赖 | | 流式响应 | 用户感知延迟大幅降低 | 实现复杂度增加 | | 预热 Agent 实例 | 首次调用延迟降低 | 资源占用增加 | | 小模型做简单任务 | 单次调用延迟显著降低 | 复杂任务质量下降 | | 异步通信 | Supervisor 不阻塞等待 | 需要额外超时和协调逻辑 | | 结果缓存 | 相同查询近乎 0 延迟 | 需要缓存失效策略 | ### Q:上线前要过哪些检查? A:结论先行——见清单,重点盯**编排模式选择、角色边界、通信兼容、冲突升级路径、失败降级、工具幂等、Checkpoint、租约、可观测、成本预算、安全否决权、灰度**。 ```text □ 编排模式:是否根据任务特征选择了合适的编排模式? □ Agent 角色定义:职责边界是否清晰?System Prompt 是否 ≤ 2000 tokens? □ 通信协议:消息格式是否结构化?是否考虑了向前兼容(protocol_version)? □ 冲突仲裁:是否有明确的冲突升级路径(自动 → Supervisor → 人工)? □ 失败处理:是否支持部分成功?重试策略是否合理?有降级方案吗? □ 工具幂等:有副作用的工具调用是否支持幂等(tool_call_id)? □ Checkpoint:是否支持中断恢复?是否区分了 stable 和 partial checkpoint? □ 租约管理:分布式环境下同一 run 是否只有 1 个 Worker 执行? □ 可观测性:是否有 Run 级别、消息级别、LLM 调用级别的追踪? □ 成本控制:是否有 token 预算上限?是否做了模型分级? □ 安全:安全敏感操作是否有否决权机制?是否支持人工审核? □ 测试:是否有单 Agent 测试?集成测试?端到端测试? □ 灰度发布:新 Agent 或新编排模式是否通过灰度逐步放量? ``` ### Q:常见反模式有哪些? A:结论先行——五个典型反模式:**为了多 Agent 而多 Agent、System Prompt 塞满领域知识、Agent 之间传大段自然语言、没有统一冲突升级路径、Supervisor 承担所有决策**。 1. **为了多 Agent 而多 Agent**:能用单 Agent 做好的事拆成 5 个 Agent,协调开销直接超过收益; 2. **System Prompt 塞领域知识**:正确的做法是把领域知识放 RAG/工具,System Prompt 只定义角色行为; 3. **Agent 之间传大段自然语言**:token 成本高、无法校验、容易歧义,应优先结构化 JSON + 简短摘要; 4. **没有统一冲突升级路径**:冲突靠"谁先说话算谁",会导致结果不可复现; 5. **Supervisor 承担所有决策**:既成瓶颈又成单点,应该把可下放的决策下放到 Worker 或规则引擎。 ### Q:和主流框架怎么对照理解? A:结论先行——这些框架本质上都是前述模式的具体实现: - **LangGraph**:StateGraph + Checkpoint + 多 Agent Subgraph 机制,是实现"层级委派 + 黑板模式"的工业级框架; - **CrewAI**:预定义 Agent 角色(Role)+ 任务(Task)+ 顺序/层级编排,是"层级委派 + 管道模式"的开箱即用封装; - **AutoGen**:强调 Agent 之间的对话驱动协作,是"辩论模式 + 黑板模式"的实现; - **OpenAI Swarm**:极简多 Agent 实验框架,手递手(handoff)模式,本质是轻量级"层级委派"。 具体框架的 API、配置项与默认行为需结合版本确认。理解原理后,框架只是工具选择问题——本文的设计模式是框架无关的。 ## 小结 - 单 Agent 的五个天花板(上下文、注意力、单点、串行、角色冲突)是多 Agent 的**存在理由**,而延迟、成本、协调、一致性、调试是它的**必然代价**; - 六种编排模式各有适用场景,选型用决策树,必要时组合(层级委派内部用投票做关键决策); - 通信优先结构化 JSON,务必带 `correlation_id` / `protocol_version` / `ttl`;长短任务分别用同步和异步; - 角色三要素是职责边界、能力画像、行为约束;System Prompt 控制在 500~2000 tokens; - 冲突解决按"规则引擎 → 投票 → 自协商 → Supervisor → 人工"分层;安全/合规 Agent 保留否决权; - 状态用"分区式共享":全局放事实与决策、私有放中间推理,写入要带来源并做冲突检测; - 任务分解讲究独立性、粒度(30s~5min)、天然边界、可验证,依赖图必须拓扑校验; - 失败处理要**支持部分成功**(三态 status),重试遵循"同 Agent → 换 Agent → 降级 → 升级"; - 七条设计原则:简单优先、分工专精、故障隔离、优雅降级、显式通信、人机协作、可观测优先。 ## 思考题 1. 如果让你给一个"代码评审"场景设计多 Agent 系统,你会选辩论还是投票?如果两个都选,怎么组合才能既控制成本又不牺牲质量? 2. 投票模式的理论准确率提升依赖"错误独立",但实际中几个 Agent 可能共用同一个有偏差的检索源。你会怎么检测并缓解"相关性偏差"? 3. 分区式共享里,私有上下文的信息什么时候应该"升迁"到全局?如果 Agent 忘记写入关键事实导致下游重复劳动,你会怎么从设计上减少这种遗漏? 4. Supervisor 是单点,怎么降低它的故障影响?提出至少两种方案,并说明各自的代价。 5. 部分成功的阈值设成 60%,如果业务方要求"必须 90% 以上才算成功",会对你的重试与降级策略产生什么影响?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入