Agent 编排引擎：LangGraph vs CrewAI vs AutoGen

原创灵阙教研团队

S 精选进阶对比评测 | 约 11 分钟阅读更新于 2026-02-28

AI 导读

Agent 编排引擎：LangGraph vs CrewAI vs AutoGen 三大主流 Agent 编排框架的架构对比与选型指南编排引擎解决什么问题 Agent 编排引擎负责管理 Agent 的生命周期、工作流控制、状态管理和工具调度。核心要回答的问题：流程控制：Agent 的执行路径如何定义？是固定的还是动态的？状态管理：多步骤执行中的中间状态如何持久化和传递？多 Agent...

Agent 编排引擎：LangGraph vs CrewAI vs AutoGen

三大主流 Agent 编排框架的架构对比与选型指南

编排引擎解决什么问题

Agent 编排引擎负责管理 Agent 的生命周期、工作流控制、状态管理和工具调度。核心要回答的问题：

流程控制：Agent 的执行路径如何定义？是固定的还是动态的？
状态管理：多步骤执行中的中间状态如何持久化和传递？
多 Agent 协调：多个 Agent 之间如何通信和协作？
容错恢复：步骤失败时如何重试、回退或降级？

编排引擎的核心职责：

  任务输入 ──→ [编排引擎] ──→ 最终输出
                  │
          ┌───────┼───────┐
          v       v       v
        流程    状态    Agent
        控制    管理    生命周期
        │       │       │
        v       v       v
      分支     持久化   创建/销毁
      循环     快照     工具注入
      并行     恢复     上下文管理

三大框架总览

维度	LangGraph	CrewAI	AutoGen
开发者	LangChain	CrewAI Inc.	Microsoft
核心抽象	图（Graph）	角色（Role/Crew）	对话（Conversation）
状态管理	显式状态图	隐式（任务上下文）	消息历史
流程控制	节点+边（条件路由）	顺序/层级	对话驱动
学习曲线	中-高	低	中
灵活性	极高	中	高
生产就绪度	高	中	中
适用场景	复杂工作流	角色协作任务	多 Agent 对话

一、LangGraph

核心概念

LangGraph 的核心抽象是有向图：节点（Node）代表计算步骤，边（Edge）代表执行路径，状态（State）在图中流转。

LangGraph 的思维模型：

  状态 ──→ 节点A ──→ 条件边 ──→ 节点B ──→ 节点C ──→ 输出
                        │
                        └──→ 节点D ──→ 节点C ──→ 输出

架构设计

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from operator import add

# 1. 定义状态 Schema
class AgentState(TypedDict):
    task: str
    plan: list[str]
    current_step: int
    results: Annotated[list[str], add]  # 使用 reducer 合并结果
    final_answer: str
    errors: list[str]

# 2. 定义节点（每个节点是一个函数）
def planner(state: AgentState) -> dict:
    """规划节点：将任务分解为步骤"""
    plan = llm.generate(
        f"将以下任务分解为执行步骤：{state['task']}"
    )
    return {"plan": plan.steps, "current_step": 0}

def executor(state: AgentState) -> dict:
    """执行节点：执行当前步骤"""
    step = state["plan"][state["current_step"]]
    result = llm_with_tools.run(step)
    return {
        "results": [result],
        "current_step": state["current_step"] + 1
    }

def reviewer(state: AgentState) -> dict:
    """审查节点：检查执行结果"""
    review = llm.generate(
        f"审查以下执行结果是否满足要求：\n"
        f"任务：{state['task']}\n"
        f"结果：{state['results']}"
    )
    return {"final_answer": review}

# 3. 定义条件路由
def should_continue(state: AgentState) -> str:
    """条件边：判断是否需要继续执行"""
    if state["current_step"] < len(state["plan"]):
        return "executor"    # 继续执行下一步
    else:
        return "reviewer"    # 所有步骤完成，进入审查

# 4. 构建图
graph = StateGraph(AgentState)

# 添加节点
graph.add_node("planner", planner)
graph.add_node("executor", executor)
graph.add_node("reviewer", reviewer)

# 添加边
graph.set_entry_point("planner")
graph.add_conditional_edges(
    "planner",
    lambda s: "executor" if s["plan"] else END
)
graph.add_conditional_edges("executor", should_continue)
graph.add_edge("reviewer", END)

# 编译
app = graph.compile()

# 5. 执行
result = app.invoke({"task": "分析项目代码质量"})

LangGraph 的核心优势

1. 持久化与检查点

from langgraph.checkpoint.sqlite import SqliteSaver

# 启用检查点持久化
checkpointer = SqliteSaver.from_conn_string("./checkpoints.db")
app = graph.compile(checkpointer=checkpointer)

# 执行时指定 thread_id，支持中断和恢复
config = {"configurable": {"thread_id": "task-001"}}
result = app.invoke(initial_state, config=config)

# 中断后恢复
result = app.invoke(None, config=config)  # 从检查点恢复

2. Human-in-the-Loop

from langgraph.prebuilt import ToolNode

# 在特定节点设置中断点
app = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=["executor"],  # 在执行前暂停等待人工审批
)

# 执行到中断点
result = app.invoke(state, config)
# result.status == "interrupted"

# 人工审批后继续
app.invoke(
    {"approved": True},  # 人工输入
    config
)

3. 子图复用

# 定义可复用的子图
research_subgraph = StateGraph(ResearchState)
research_subgraph.add_node("search", web_search)
research_subgraph.add_node("analyze", analyze_results)
# ...
research_compiled = research_subgraph.compile()

# 在主图中嵌入子图
main_graph = StateGraph(MainState)
main_graph.add_node("research", research_compiled)
main_graph.add_node("implement", implement_node)
main_graph.add_edge("research", "implement")

二、CrewAI

核心概念

CrewAI 的核心抽象是角色（Agent）和团队（Crew）：每个 Agent 有明确的角色、目标和工具，Crew 定义 Agent 之间的协作方式。

CrewAI 的思维模型：

  Crew（团队）
    │
    ├── Agent: 研究员（Role + Goal + Backstory + Tools）
    ├── Agent: 分析师（Role + Goal + Backstory + Tools）
    └── Agent: 撰稿人（Role + Goal + Backstory + Tools）
         │
         └── Tasks: 按顺序/并行分配给 Agent

基础使用

from crewai import Agent, Task, Crew, Process

# 1. 定义 Agent（角色）
researcher = Agent(
    role="高级研究员",
    goal="搜集和分析关于 {topic} 的最新信息",
    backstory=(
        "你是一位经验丰富的技术研究员，"
        "擅长从大量信息中提取关键洞察。"
    ),
    tools=[web_search_tool, document_reader_tool],
    llm="claude-opus-4-6",
    verbose=True,
    memory=True,          # 启用记忆
    max_iter=5,           # 最大迭代次数
    allow_delegation=True # 允许委派任务给其他 Agent
)

analyst = Agent(
    role="数据分析师",
    goal="对研究数据进行深入分析，提取可操作的洞察",
    backstory="你是一位数据科学专家，擅长统计分析和趋势预测。",
    tools=[python_tool, chart_tool],
    llm="claude-opus-4-6",
)

writer = Agent(
    role="技术撰稿人",
    goal="将分析结果撰写成清晰、有说服力的报告",
    backstory="你是一位技术写作专家，能将复杂概念表达得简洁易懂。",
    tools=[file_write_tool],
    llm="claude-opus-4-6",
)

# 2. 定义任务
research_task = Task(
    description="搜集关于 {topic} 的最新技术进展和市场动态",
    expected_output="结构化的研究报告，包含 5-10 个关键发现",
    agent=researcher,
)

analysis_task = Task(
    description="分析研究数据，识别趋势和机会",
    expected_output="数据分析报告，包含图表和关键指标",
    agent=analyst,
    context=[research_task],  # 依赖 research_task 的输出
)

report_task = Task(
    description="撰写最终的综合分析报告",
    expected_output="2000 字的专业分析报告",
    agent=writer,
    context=[research_task, analysis_task],
    output_file="report.md",
)

# 3. 组建 Crew
crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[research_task, analysis_task, report_task],
    process=Process.sequential,  # 顺序执行
    verbose=True,
    memory=True,
)

# 4. 执行
result = crew.kickoff(inputs={"topic": "AI Agent 编排引擎"})

CrewAI 的核心特性

1. 流程模式

# 顺序执行：Task 按定义顺序执行
crew = Crew(process=Process.sequential, ...)

# 层级执行：Manager Agent 自动协调
crew = Crew(
    process=Process.hierarchical,
    manager_llm="claude-opus-4-6",
    ...
)
# Manager 会自动决定哪个 Agent 执行哪个任务

2. 委派与协作

# Agent 可以将任务委派给其他 Agent
researcher = Agent(
    role="高级研究员",
    allow_delegation=True,  # 允许委派
    # 当研究员遇到需要数据分析的部分，会自动委派给分析师
)

3. 记忆系统

crew = Crew(
    memory=True,
    # CrewAI 内置三种记忆：
    # - Short-term: 当前任务的对话历史
    # - Long-term: 跨任务的经验积累
    # - Entity: 实体知识（人物、组织、概念）
)

三、AutoGen

核心概念

AutoGen 的核心抽象是对话（Conversation）：Agent 之间通过消息传递进行协作，对话模式定义了谁可以和谁说话。

AutoGen 的思维模型：

  GroupChat（群聊）
    │
    ├── AssistantAgent（AI 助手）
    ├── UserProxyAgent（用户代理）
    └── CustomAgent（自定义 Agent）
         │
         └── 通过消息传递协作，Speaker Selection 决定谁发言

基础使用（AutoGen 0.4+）

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient

# 1. 定义模型客户端
model_client = OpenAIChatCompletionClient(
    model="claude-opus-4-6",
    api_key="...",
)

# 2. 定义 Agent
planner = AssistantAgent(
    name="planner",
    model_client=model_client,
    system_message=(
        "你是一个项目规划专家。"
        "将任务分解为具体可执行的步骤。"
    ),
)

coder = AssistantAgent(
    name="coder",
    model_client=model_client,
    system_message=(
        "你是一个编程专家。"
        "根据规划编写高质量的代码。"
    ),
    tools=[code_execution_tool],
)

reviewer = AssistantAgent(
    name="reviewer",
    model_client=model_client,
    system_message=(
        "你是一个代码审查专家。"
        "审查代码质量并提出改进建议。"
        "如果代码质量满足要求，回复 APPROVE。"
    ),
)

# 3. 组建群聊
team = RoundRobinGroupChat(
    participants=[planner, coder, reviewer],
    max_turns=10,
)

# 4. 执行
from autogen_agentchat.conditions import TextMentionTermination
termination = TextMentionTermination("APPROVE")

result = await team.run(
    task="编写一个 Python 脚本，分析 CSV 文件中的销售数据",
    termination_condition=termination,
)

AutoGen 的核心特性

1. 灵活的对话模式

# 轮询模式：Agent 轮流发言
team = RoundRobinGroupChat(participants=[a, b, c])

# 选择器模式：LLM 决定谁发言
from autogen_agentchat.teams import SelectorGroupChat
team = SelectorGroupChat(
    participants=[planner, coder, reviewer],
    model_client=model_client,
    # LLM 根据对话上下文选择下一个发言者
)

# Swarm 模式：Agent 自主切换
from autogen_agentchat.teams import Swarm
team = Swarm(
    participants=[agent_a, agent_b, agent_c],
    # Agent 通过 HandoffMessage 自主切换控制权
)

2. 代码执行

from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor

code_executor = DockerCommandLineCodeExecutor(
    image="python:3.12-slim",
    timeout=60,
    work_dir="./workspace",
)

coder = AssistantAgent(
    name="coder",
    code_executor=code_executor,  # 生成的代码在 Docker 中执行
)

3. 嵌套对话

# 外层团队可以包含内层团队
inner_team = RoundRobinGroupChat(
    participants=[coder, reviewer]
)

outer_team = RoundRobinGroupChat(
    participants=[planner, inner_team, deployer]
)
# planner 规划 -> inner_team 编码+审查 -> deployer 部署

深度对比

状态管理

LangGraph：
  - 显式状态 Schema（TypedDict）
  - 状态在图的边上传递
  - 内置持久化（SQLite/PostgreSQL）
  - 支持检查点和恢复
  - 最精确的状态控制

CrewAI：
  - 隐式状态（任务上下文自动传递）
  - context 参数声明任务依赖
  - 内置记忆系统（短期/长期/实体）
  - 状态管理对用户透明
  - 简单但灵活性有限

AutoGen：
  - 消息历史即状态
  - 每个 Agent 维护自己的消息列表
  - 群聊消息对所有参与者可见
  - 可通过自定义 Agent 实现复杂状态
  - 灵活但需要手动管理

流程控制

LangGraph：
  ┌─────────┐     ┌─────────┐     ┌─────────┐
  │ Node A  │──→──│ Node B  │──→──│ Node C  │
  └─────────┘  │  └─────────┘     └─────────┘
               │
               └──→──┌─────────┐
                     │ Node D  │
                     └─────────┘

  特点：完全自定义的 DAG，条件分支，循环，子图
  适合：复杂的、需要精确控制的工作流

CrewAI：
  Task1 ──→ Task2 ──→ Task3 ──→ Task4
  （顺序）    或     Manager 动态分配（层级）

  特点：简单直观，角色驱动
  适合：以角色分工为核心的任务

AutoGen：
  Agent A ←──对话──→ Agent B
       ↑                ↓
       └──── Agent C ───┘

  特点：对话驱动，灵活的发言选择
  适合：需要多轮讨论和迭代的场景

扩展性

维度	LangGraph	CrewAI	AutoGen
自定义节点	任意 Python 函数	Agent + Task	继承 Agent 类
工具集成	LangChain Tools + 自定义	CrewAI Tools + LangChain	Function Calling + 自定义
模型支持	任意 LLM	OpenAI/Anthropic/本地	OpenAI/Anthropic/本地
子图/嵌套	原生支持	不支持	嵌套群聊
流式输出	原生支持	有限	原生支持
持久化	SQLite/PostgreSQL	内置记忆	需自定义

选型决策矩阵

你的场景是什么？
     │
     ├── 复杂工作流（条件分支、循环、子图）
     │    └── LangGraph
     │
     ├── 角色协作（研究员+分析师+撰稿人）
     │    └── CrewAI
     │
     ├── 多轮对话式协作（讨论+迭代）
     │    └── AutoGen
     │
     ├── 需要精确状态控制和持久化
     │    └── LangGraph
     │
     ├── 快速原型验证
     │    └── CrewAI（最快上手）
     │
     ├── 代码生成+执行场景
     │    └── AutoGen（内置代码执行器）
     │
     └── 生产级部署
          └── LangGraph（LangGraph Platform）
               或根据团队技术栈选择

不同场景的推荐选择

场景	首选	理由
客服路由系统	LangGraph	需要精确的状态机和条件路由
内容创作团队	CrewAI	角色协作模式天然适配
代码审查系统	AutoGen	多轮对话讨论代码质量
数据处理流水线	LangGraph	DAG 模式 + 持久化 + 恢复
研究助手	CrewAI	多角色分工，简单直接
RAG 增强系统	LangGraph	需要复杂的检索-推理-验证循环
教学模拟	AutoGen	多角色对话模拟

混合使用策略

实际项目中，三个框架可以互补使用：

外层编排（LangGraph）：负责整体工作流控制
  │
  ├── 研究阶段 ──→ CrewAI Crew（研究员+分析师）
  │
  ├── 讨论阶段 ──→ AutoGen GroupChat（多角色辩论）
  │
  └── 实现阶段 ──→ LangGraph 子图（代码生成+测试+部署）

# 在 LangGraph 节点中调用 CrewAI Crew
def research_node(state):
    crew = Crew(agents=[researcher, analyst], ...)
    result = crew.kickoff(inputs={"topic": state["topic"]})
    return {"research_results": result}

# 在 LangGraph 节点中调用 AutoGen GroupChat
async def discussion_node(state):
    team = SelectorGroupChat(participants=[...])
    result = await team.run(task=state["discussion_topic"])
    return {"discussion_outcome": result}

# LangGraph 主图
graph = StateGraph(State)
graph.add_node("research", research_node)
graph.add_node("discuss", discussion_node)
graph.add_node("implement", implement_node)

工程实践建议

从场景出发选框架：不要因为某个框架"热门"就选它，匹配场景最重要
先单 Agent 后多 Agent：很多任务单 Agent + 好的 Prompt 就够了
LangGraph 学习曲线投资：如果项目需要生产级部署，LangGraph 的学习投资值得
CrewAI 适合快速验证：团队不熟悉 Agent 编排时，用 CrewAI 最快出效果
AutoGen 适合研究场景：需要灵活的多 Agent 对话实验时，AutoGen 最自由
关注版本迭代：三个框架都在快速迭代（尤其是 AutoGen 0.4 重写），注意跟进最新版本

参考资料

LangGraph 官方文档：langchain-ai.github.io/langgraph/
CrewAI 官方文档：docs.crewai.com
AutoGen 官方文档：microsoft.github.io/autogen/
LangChain 博客：多框架对比分析
Andrew Ng 的 AI Agent 设计模式课程

Maurice | [email protected]

深度加工（NotebookLM 生成）

基于本文内容生成的 PPT 大纲、博客摘要、短视频脚本与 Deep Dive 播客，用于多场景复用

PPT 大纲（5-8 张幻灯片）点击展开

Agent 编排引擎：LangGraph vs CrewAI vs AutoGen — ppt

幻灯片 1：Agent 编排引擎概述

核心定义：Agent 编排引擎主要负责管理 Agent 的生命周期、工作流控制、状态管理和工具调度 [1]。
解决的关键问题：涵盖了流程路径定义（动态或固定）、中间状态的持久化传递、多 Agent 的通信协作，以及任务失败时的重试与降级机制 [1]。
主流框架三剑客：目前市面上三大主流 Agent 编排框架分别是 LangChain 推出的 LangGraph、CrewAI Inc. 推出的 CrewAI，以及 Microsoft 研发的 AutoGen [1]。

幻灯片 2：三大框架核心架构全方位对比

核心抽象对比：LangGraph 基于“有向图”，CrewAI 基于“角色与团队”，而 AutoGen 基于“对话”驱动 [1]。
状态管理差异：LangGraph 采用显式的状态图，CrewAI 采用隐式的任务上下文传递，AutoGen 则依靠各自维护的消息历史记录状态 [1, 2]。
适用场景与上手难度：CrewAI 学习曲线最低，适合角色协作；AutoGen 难度中等，适合多Agent对话；LangGraph 难度中高但灵活性极高，是复杂工作流及生产部署的首选 [1, 3]。

幻灯片 3：LangGraph - 复杂工作流的构建者

图与节点架构：核心思想是将任务抽象为有向图，节点代表具体的计算步骤，边代表执行的条件与路径，状态在图中动态流转 [1]。
持久化与状态恢复：内置检查点（Checkpoint）持久化功能，不仅支持状态快照，还支持中断执行和随时恢复 [1, 4]。
人机协同（Human-in-the-Loop）：支持在特定节点设置中断点，可以在任务执行中途暂停，等待人工审批或输入后再继续 [4]。
高复用性：原生支持子图嵌套，允许定义独立的可复用子图并将其直接嵌入到主流程图中 [4, 5]。

幻灯片 4：CrewAI - 角色驱动的协作团队

角色与职责设计：以角色为核心，每个 Agent 均被赋予了特定的角色名称、目标任务、背景设定以及对应的工具集 [5]。
丰富的流程模式：支持任务列表的顺序执行（Sequential），也支持通过 Manager Agent 自动协调规划的层级执行模式（Hierarchical） [6, 7]。
任务委派与协作：具备灵活的委派机制，允许 Agent 在遇到自身无法解决的问题时将部分任务委派给其他更专业的 Agent [5, 7]。
内置记忆系统：原生内置了包含短期对话历史、跨任务长期经验以及实体知识的三重记忆系统 [7]。

幻灯片 5：AutoGen - 灵活多变的对话群聊

多轮对话驱动：跳出传统的流程图或角色分配限制，Agent 之间的协作完全依靠消息传递与对话（Conversation）来完成 [7]。
多元化的发言模式：支持顺序轮流发言的轮询模式、由大模型根据上下文决定发言者的选择器模式，以及 Agent 自主切换控制权的 Swarm 模式 [2, 8]。
强大的代码执行能力：内置安全的 Docker 命令行代码执行器，特别适合代码生成、执行分析以及后续的代码审查任务 [2, 8]。
复杂的嵌套结构：支持群聊（GroupChat）的层级嵌套，可以实现外部团队分发任务给内部讨论团队的复杂架构 [2]。

幻灯片 6：如何为你的项目选择合适的框架？

LangGraph 适用场景：对于需要精确状态控制、包含条件分支循环的数据处理流水线或复杂的 RAG 增强系统，优先选择 LangGraph [3, 9]。
CrewAI 适用场景：如果是内容创作、研究助手等明确需要多角色分工协作的场景，且追求快速验证原型，CrewAI 是最快见效的选择 [3, 9, 10]。
AutoGen 适用场景：在需要多轮探讨辩论的代码审查系统、教学模拟或实验性质较强的多Agent对话研究中，AutoGen 的自由度最具优势 [3, 9, 10]。

幻灯片 7：进阶：混合编排策略与工程实践

互补的混合编排：在大型项目中可以结合使用，例如外层使用 LangGraph 控制整体工作流，内部研究阶段调用 CrewAI，讨论阶段嵌入 AutoGen 群聊 [9]。
化繁为简：工程中应切记不要盲目使用多 Agent 框架，很多任务只需单 Agent 搭配优秀的 Prompt 即可解决 [9, 10]。
评估团队投入：若是面向企业级生产部署，值得投入时间跨越 LangGraph 的学习曲线；如果团队缺乏 Agent 编排经验，可以从 CrewAI 起步 [10]。

博客摘要 + 核心看点点击展开

Agent 编排引擎：LangGraph vs CrewAI vs AutoGen — summary

这是一份为您定制的 SEO 友好博客摘要及核心看点：

SEO 友好博客摘要

寻找最适合您的 Agent 编排引擎？本文深度剖析 LangGraph、CrewAI 与 AutoGen 三大主流框架，为您提供全面的架构对比与选型指南 [1]！LangGraph 凭借有向图提供极高灵活性，专精复杂工作流与精细的显式状态管理 [1, 2]；CrewAI 采用直观的角色与团队设计，学习门槛低，最适合快速验证与内容创作场景 [1, 3]；AutoGen 则以多轮对话驱动见长，内置代码执行器，是编程与讨论任务的首选 [2, 3]。阅读本指南，助您精准匹配业务场景，甚至掌握多框架混合使用的最佳实践，轻松驾驭多 Agent 协同工作 [4]！

3 条核心看点