AI Agent 架构设计与多 Agent 协作系统搭建：工具选型别只比较参数

AI Agent 架构设计与多 Agent 协作系统搭建：工具选型别只比较参数

1. 业务并发拉起来之后，Agent 怎么突然死锁了

在大型系统或复杂工作流场景中，当多 Agent 协作系统面对高并发场景与复杂代码审查任务时，经常面临吞吐量骤降与协作链条死锁的瓶颈。例如在 50 个并发 Session 下，多个 Agent 协同完成代码审查与自动化补丁生成时，如果控制流设计缺乏确定性约束，系统吞吐量可能在短时间内下跌，CPU 占用居高不下，而下游 LLM API 调用量却降到了零。

通过分布式 Trace 链路诊断可以发现，此类现象的根源在于数百个 Agent 协程陷入相互等待 Response 的死锁状态：Agent A 正在等待 Agent B 补充参数，Agent B 认为请求格式不合规抛出 Retry 提示，Agent C 则在中间盲目转发这两个 Agent 的中间状态，导致整条协作链条进入死循环。

[Agent A] ---> (请求补充上下文) ---> [Agent B]
   ^                                  |
   |                                  v
[Agent C] <--- (格式校验未通过) <--- [中间状态]

在单 Agent 场景下，通常只需关注 Prompt 的 Prompt-Response 闭环。但一旦引入多 Agent 协作，选型就从单纯的 API 调用演变成了分布式状态机设计。市场上 AutoGen、LangGraph 和 CrewAI 这三个开源框架，虽然都提供 Agent 协作能力，但底层的控制流、状态调度逻辑以及处理死锁的方式截然不同。如果在选型阶段仅参考 GitHub Star 数或 Demo 演示，线上高并发场景容易引发严重的系统停滞。

2. 三大开源 Agent 框架的状态调度机制对比

为了分析相同业务逻辑在不同框架下的运行差异，需要拆解各框架的底层调度引擎与状态模型。

AutoGen：对话驱动与 Actor 模型的隐患

AutoGen 采用基于消息传递的 Actor 模型。在 AutoGen 的架构中，所有 Agent 均作为独立的对话实体，通过收发 Text Message 驱动状态推进。这种设计的优势在于开发门槛低，可以通过较少代码建立 UserProxyAgent 与 AssistantAgent 之间的交互。

然而，该模型在节点扩展时存在明显的控制力不足问题。当协作节点超过 3 个时，AutoGen 缺乏强约束的状态机图（DAG）。Agent 之间的消息流向完全由 LLM 自行决策，一旦其中某个 Agent 生成带有歧义的响应，消息就会在节点之间反复传递。若未设置硬性的 max_consecutive_auto_reply 参数，不仅 Token 预算会被迅速消耗，还会引发协程堆积与死锁。

LangGraph：图状态机与确定性节点转换

与 AutoGen 的对话驱动方式不同，LangGraph 采用基于图（Graph）的显式状态机模型。在 LangGraph 架构中，状态（State）作为集中管理的共享结构体存在，每一个 Agent 仅作为图中的一个节点（Node），节点间的转移过程由显式的条件边（Conditional Edge）进行约束。

这种设计在工程层面具备显著优势。状态流转不再完全依赖 LLM 的输出意愿，开发者可以通过 Python 代码编写强类型的状态校验函数。当 Agent B 返回的数据未达到预期标准时，条件边能够将其精准路由至人工干预节点或预设的异常处理节点，从结构上消除了消息在节点间无限游荡的可能性。

CrewAI：基于角色与任务队列的线性抽象

CrewAI 采用了“角色（Role）- 任务（Task）- 团队（Crew）”的高层抽象模式。其底层调度依托任务队列，支持 Sequential（顺序）和 Hierarchical（层级）两种执行模式。

在结构明确、步骤固定的轻量级业务场景中，CrewAI 能够提供较高的开发效率。但其局限在于运行时调整能力偏弱。在复杂的多轮博弈或动态分支场景下，CrewAI 较难在运行期动态变更任务拓扑图。一旦上游 Task 发生阻塞或无限重试，整个 Crew 线程池的资源都将处于被占用状态，背压控制的实施难度较高。

3. 防死锁与自愈能力的工程代码实现

在生产级系统建设中，不能将稳定性寄托于 LLM 的随机输出。下文展示的代码基于状态机与超时抢占机制构建多 Agent 安全调度拦截器，能够自动识别节点死循环、上下文膨胀以及死锁状态，并执行确定性的降级方案。

import time
import hashlib
import logging
from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")

@dataclass
class AgentState:
    session_id: str
    current_node: str
    context_data: Dict[str, Any] = field(default_factory=dict)
    history_hashes: List[str] = field(default_factory=list)
    step_count: int = 0
    token_usage: int = 0

class AgentExecutionError(Exception):
    pass

class AgentLoopDetectedException(AgentExecutionError):
    pass

class AgentTimeoutException(AgentExecutionError):
    pass

class SafeAgentScheduler:
    def __init__(self, max_steps: int = 15, max_budget_tokens: int = 10000, node_timeout_sec: float = 5.0):
        self.max_steps = max_steps
        self.max_budget_tokens = max_budget_tokens
        self.node_timeout_sec = node_timeout_sec
        self.nodes: Dict[str, Callable[[AgentState], AgentState]] = {}
        self.edges: Dict[str, Callable[[AgentState], str]] = {}

    def register_node(self, node_name: str, handler: Callable[[AgentState], AgentState]):
        self.nodes[node_name] = handler

    def register_conditional_edge(self, from_node: str, edge_router: Callable[[AgentState], str]):
        self.edges[from_node] = edge_router

    def _compute_state_hash(self, state: AgentState) -> str:
        """根据当前节点和核心上下文计算哈希，用于检测死循环"""
        raw_str = f"{state.current_node}:{sorted(state.context_data.items())}"
        return hashlib.sha256(raw_str.encode('utf-8')).hexdigest()[:16]

    def step(self, state: AgentState) -> AgentState:
        if state.step_count >= self.max_steps:
            raise AgentExecutionError(f"Exceeded max steps threshold ({self.max_steps})")

        if state.token_usage >= self.max_budget_tokens:
            raise AgentExecutionError(f"Exceeded token budget limit ({self.max_budget_tokens})")

        state_hash = self._compute_state_hash(state)
        # 检测最近 4 步内是否存在完全相同的状态重复出现（死循环迹象）
        if state.history_hashes.count(state_hash) >= 2:
            raise AgentLoopDetectedException(f"Loop detected at node [{state.current_node}] with state hash {state_hash}")

        state.history_hashes.append(state_hash)
        if len(state.history_hashes) > 10:
            state.history_hashes.pop(0)

        handler = self.nodes.get(state.current_node)
        if not handler:
            raise AgentExecutionError(f"Node [{state.current_node}] is not registered")

        # 带有计时与超时的节点执行
        start_time = time.time()
        updated_state = handler(state)
        elapsed = time.time() - start_time

        if elapsed > self.node_timeout_sec:
            raise AgentTimeoutException(f"Node [{state.current_node}] execution timed out ({elapsed:.2f}s > {self.node_timeout_sec}s)")

        updated_state.step_count += 1
        
        # 计算下一步路由
        router = self.edges.get(updated_state.current_node)
        if router:
            updated_state.current_node = router(updated_state)
        else:
            updated_state.current_node = "__END__"

        return updated_state

    def run(self, initial_state: AgentState) -> AgentState:
        state = initial_state
        while state.current_node != "__END__":
            try:
                logging.info(f"Executing step {state.step_count} at node [{state.current_node}]")
                state = self.step(state)
            except AgentLoopDetectedException as e:
                logging.warning(f"Intercepted Loop: {e}. Triggering fallback recovery...")
                state.context_data["error_fallback"] = True
                state.current_node = "fallback_node"
            except AgentTimeoutException as e:
                logging.error(f"Intercepted Timeout: {e}. Degrading execution...")
                state.context_data["timeout_degraded"] = True
                state.current_node = "__END__"
            except Exception as e:
                logging.error(f"Execution Error at [{state.current_node}]: {e}")
                state.current_node = "__END__"
        return state

# 生产演示示例
if __name__ == "__main__":
    scheduler = SafeAgentScheduler(max_steps=8, node_timeout_sec=2.0)

    def planner_agent(state: AgentState) -> AgentState:
        state.context_data["plan"] = "Generate Code"
        state.token_usage += 200
        return state

    def coder_agent(state: AgentState) -> AgentState:
        # 模拟重复生成的场景
        state.context_data["code"] = "print('hello')"
        state.token_usage += 500
        return state

    def reviewer_agent(state: AgentState) -> AgentState:
        # 故意制造拒绝，让其退回 coder_agent
        state.context_data["approved"] = False
        state.token_usage += 300
        return state

    def fallback_handler(state: AgentState) -> AgentState:
        logging.info("Fallback handler activated: Returning cached safe output.")
        state.context_data["final_output"] = "Safe Default Response"
        return state

    scheduler.register_node("planner", planner_agent)
    scheduler.register_node("coder", coder_agent)
    scheduler.register_node("reviewer", reviewer_agent)
    scheduler.register_node("fallback_node", fallback_handler)

    def router_logic(state: AgentState) -> str:
        if state.current_node == "planner":
            return "coder"
        elif state.current_node == "coder":
            return "reviewer"
        elif state.current_node == "reviewer":
            if state.context_data.get("approved"):
                return "__END__"
            return "coder"  # 循环返回
        return "__END__"

    scheduler.register_conditional_edge("planner", router_logic)
    scheduler.register_conditional_edge("coder", router_logic)
    scheduler.register_conditional_edge("reviewer", router_logic)

    init_state = AgentState(session_id="sess_001", current_node="planner")
    final_res = scheduler.run(init_state)
    print("Final State Summary:", final_res.context_data)

4. 架构选型建议与落地 Trade-offs

面对不同的业务诉求，框架选型需要权衡确定性与扩展性之间的关系。

工程落地建议如下：

1. 避免无约束对话模式：在生产场景中，尽量避免允许 Agent 自由决定调用对象的全自动对话模式。任何 Agent 协作链路都必须存在显式的 DAG 或状态转换图约束。
2. 状态快照与持久化机制：生产环境建议选择支持状态快照（State Checkpointing）的框架。当某个外部 Tool Calling 发生超时或抛出异常时，系统可以恢复至上一个正常节点重新执行，避免全链路重运行。
3. 设置硬性控制关卡：无论选用何种框架，必须在调度层最外层配置硬性限制（包括最大步骤、Token 上限、全局超时及状态哈希去重），通过确定性的工程代码保障 LLM 调度的稳定性。