2026 AI Agent Framework Showdown: LangGraph vs CrewAI vs AutoGen vs OpenAI SDK
选择合适的 Agent 框架是构建 AI Agent 应用的关键决策。本文将从架构设计、代码实现、性能表现和适用场景四个维度，对 2026 年主流的四大 Agent 框架进行深度对比。
框架概览
LangGraph
架构设计
LangGraph 将 Agent 工作流建模为有向图（Directed Graph），每个节点是一个处理步骤，边定义了执行流程。
┌──────────────┐
│ START │
└──────┬───────┘
│
┌──────▼───────┐
│ Router │
└──┬───────┬───┘
│ │
┌────────▼──┐ ┌──▼────────┐
│ Search │ │ Calculator│
│ Node │ │ Node │
└────────┬──┘ └──┬────────┘
│ │
┌──▼───────▼──┐
│ Synthesizer │
└──────┬───────┘
│
┌──────▼───────┐
│ END │
└──────────────┘
核心代码示例
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from typing import TypedDict, Annotated
import operator
定义状态
class AgentState(TypedDict):
messages: Annotated[list, operator.add]
current_step: str
results: dict
定义节点函数
def router(state: AgentState) -> str:
"""根据用户意图路由到不同节点"""
last_message = state["messages"][-1]
if "计算" in last_message or "数字" in last_message:
return "calculator"
return "search"
def search_node(state: AgentState):
"""搜索信息"""
query = state["messages"][-1]
result = search_tool.invoke(query)
return {"messages": [f"搜索结果: {result}"], "results": {"search": result}}
def calculator_node(state: AgentState):
"""执行计算"""
expression = extract_math_expression(state["messages"][-1])
result = eval(expression) # 生产环境应使用安全的表达式解析器
return {"messages": [f"计算结果: {result}"], "results": {"calc": result}}
def synthesizer(state: AgentState):
"""综合所有结果生成最终回答"""
results = state["results"]
# 使用 LLM 生成最终回答
response = llm.invoke(f"基于以下信息回答用户问题: {results}")
return {"messages": [response]}
构建图
workflow = StateGraph(AgentState)
workflow.add_node("search", search_node)
workflow.add_node("calculator", calculator_node)
workflow.add_node("synthesizer", synthesizer)
添加条件边
workflow.add_conditional_edges(
"router",
router,
{"search": "search", "calculator": "calculator"}
)
添加普通边
workflow.add_edge("search", "synthesizer")
workflow.add_edge("calculator", "synthesizer")
workflow.add_edge("synthesizer", END)
设置入口点
workflow.set_entry_point("router")
编译图
checkpointer = MemorySaver()
app = workflow.compile(checkpointer=checkpointer)
执行
result = app.invoke(
{"messages": ["帮我计算 (25 * 4) + 100"]},
config={"configurable": {"thread_id": "user-123"}}
)
LangGraph 的优势
LangGraph 的局限
CrewAI
架构设计
CrewAI 基于角色扮演（Role-Playing） 模型，将 Agent 组织成一个"团队"，每个 Agent 有明确的角色、目标和背景故事。
┌─────────────────────────────────────────────────┐
│ Crew │
│ ┌─────────────────────────────────────────┐ │
│ │ Task Queue │ │
│ └────┬────────┬────────┬──────────────────┘ │
│ │ │ │ │
│ ┌────▼───┐ ┌──▼────┐ ┌─▼──────┐ │
│ │研究员 │ │分析师 │ │作家 │ │
│ │Agent │ │Agent │ │Agent │ │
│ │搜索信息 │ │分析数据│ │撰写报告│ │
│ └────────┘ └───────┘ └───────┘ │
│ │
│ Process: Sequential / Hierarchical / Consensual│
└─────────────────────────────────────────────────┘
核心代码示例
from crewai import Agent, Task, Crew, Process
from crewai.tools import SerperDevTool, FileReadTool
定义 Agent
researcher = Agent(
role="高级研究员",
goal="找到关于 {topic} 最新、最权威的研究资料",
backstory="""
你是一位资深的研究员，擅长从海量信息中筛选出高质量的资料。
你有 10 年的学术研究背景，对 AI 领域有深刻理解。
""",
tools=[SerperDevTool()],
verbose=True,
llm="claude-sonnet-4-20250514" # CrewAI 支持多种 LLM
)
analyst = Agent(
role="数据分析师",
goal="深入分析研究资料，提取关键洞察",
backstory="""
你是一位数据驱动的分析师，擅长从复杂信息中发现模式和趋势。
""",
tools=[FileReadTool()],
verbose=True
)
writer = Agent(
role="技术写作者",
goal="将分析结果撰写成清晰、引人入胜的技术报告",
backstory="""
你是一位经验丰富的技术作家，能将复杂概念转化为通俗易懂的文字。
你的文章曾被多家科技媒体转载。
""",
verbose=True
)
定义任务
research_task = Task(
description="搜索关于 {topic} 的最新研究论文、技术博客和行业报告",
expected_output="一份包含 10-15 个高质量资源的列表，每个资源附带简要摘要",
agent=researcher
)
analysis_task = Task(
description="分析研究资料，识别主要技术趋势、挑战和机会",
expected_output="一份结构化的分析报告，包含趋势图、关键发现和建议",
agent=analyst,
context=[research_task] # 依赖研究任务的输出
)
writing_task = Task(
description="基于分析结果撰写技术博客文章，2000 字左右",
expected_output="一篇完整的中文技术博客文章，包含标题、引言、主体和结论",
agent=writer,
context=[analysis_task]
)
组建 Crew
crew = Crew(
agents=[researcher, analyst, writer],
tasks=[research_task, analysis_task, writing_task],
process=Process.sequential, # 顺序执行
verbose=True,
memory=True # 启用记忆
)
执行
result = crew.kickoff(inputs={"topic": "多模态 AI Agent 的最新进展"})
print(result.raw)
CrewAI 的高级功能
#### 层级化管理
使用 Manager Agent 协调团队
manager = Agent(
role="项目经理",
goal="高效协调团队完成项目",
backstory="你有 15 年的项目管理经验...",
allow_delegation=True
)
crew = Crew(
agents=[researcher, analyst, writer],
tasks=[research_task, analysis_task, writing_task],
process=Process.hierarchical,
manager_agent=manager
)
#### 任务委托
specialist = Agent(
role="数据库专家",
goal="解决数据库性能问题",
backstory="...",
allow_delegation=True # 允许将子任务委托给其他 Agent
)
CrewAI 的优势
CrewAI 的局限
AutoGen
架构设计
AutoGen 基于对话驱动（Conversation-Driven） 模型，Agent 通过消息传递进行协作。
┌─────────────────────────────────────────────────┐
│ GroupChat Manager │
│ ┌─────────────────────────────────────────┐ │
│ │ Speaker Selection Logic │ │
│ └─────────────────────────────────────────┘ │
│ │
│ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐│
│ │User │ │Coder │ │Reviewer│ │Executor││
│ │Proxy │ │Agent │ │Agent │ │Agent ││
│ │ │ │ │ │ │ │ ││
│ └───┬────┘ └───┬────┘ └───┬────┘ └───┬────┘│
│ │ │ │ │ │
│ └───────────┴───────────┴───────────┘ │
│ Message Bus │
└──────────────────────────────────────────────────┘
核心代码示例
from autogen import ConversableAgent, GroupChat, GroupChatExecutor
from autogen.coding import LocalCommandLineCodeExecutor
配置 LLM
llm_config = {
"model": "gpt-4o",
"api_key": "your-api-key",
"temperature": 0
}
创建 Agent
user_proxy = ConversableAgent(
name="User",
human_input_mode="TERMINATE",
max_consecutive_auto_reply=10,
code_execution_config=False
)
coder = ConversableAgent(
name="Coder",
system_message="""
你是一位资深 Python 开发者。你的职责是：
1. 根据需求编写高质量的代码
2. 编写清晰的文档字符串
3. 处理代码审查中的反馈
只编写代码，不要执行代码。
""",
llm_config=llm_config
)
reviewer = ConversableAgent(
name="Reviewer",
system_message="""
你是一位代码审查专家。审查代码时关注：
1. 代码正确性
2. 性能问题
3. 安全漏洞
4. 代码风格
提供具体的改进建议。
""",
llm_config=llm_config
)
executor = ConversableAgent(
name="Executor",
human_input_mode="NEVER",
code_execution_config={
"executor": LocalCommandLineCodeExecutor(timeout=30)
}
)
创建 GroupChat
groupchat = GroupChat(
agents=[user_proxy, coder, reviewer, executor],
messages=[],
max_round=20,
speaker_selection_method="round_robin" # 或 "auto"
)
创建 GroupChat Manager
manager = GroupChatExecutor(
groupchat=groupchat,
llm_config=llm_config
)
启动对话
user_proxy.initiate_chat(
manager,
message="编写一个 Python 函数，计算斐波那契数列的第 n 项，要求支持缓存"
)
AutoGen 的高级功能
#### 异步和分布式 Agent
from autogen import agent_utils
在不同进程中运行 Agent
@agent_utils.register
class RemoteAgent(ConversableAgent):
def __init__(self, name, **kwargs):
super().__init__(name=name, **kwargs)
#### 嵌套对话
定义子任务对话
def sub_task_conversation(task_description):
sub_agents = [Agent(...) for _ in range(3)]
sub_chat = GroupChat(agents=sub_agents, messages=[])
# 在子对话中完成任务
return result
AutoGen 的优势
AutoGen 的局限
OpenAI Agents SDK
架构设计
OpenAI Agents SDK 采用工具调用优先（Tool-Calling First） 的设计理念，将 Agent 定义为具有特定工具和指令的实体。
┌─────────────────────────────────────────────────┐
│ Runner │
│ ┌─────────────────────────────────────────┐ │
│ │ Agent Loop │ │
│ │ ┌─────┐ ┌──────┐ ┌───────┐ ┌────────┐ │ │
│ │ │LLM │→│Tool │→│Result │→│Next │ │ │
│ │ │Call │ │Select│ │Process│ │Action │ │ │
│ │ └─────┘ └──────┘ └───────┘ └────────┘ │ │
│ └─────────────────────────────────────────┘ │
│ │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │Agent A │ │Agent B │ │Agent C │ │
│ │+ Tools │ │+ Tools │ │+ Tools │ │
│ └────────┘ └────────┘ └────────┘ │
└──────────────────────────────────────────────────┘
核心代码示例
from agents import Agent, Runner, function_tool, handoff
from pydantic import BaseModel
定义工具
@function_tool
def search_web(query: str) -> str:
"""搜索互联网获取信息"""
# 实现搜索逻辑
return f"关于 '{query}' 的搜索结果..."
@function_tool
def calculate(expression: str) -> float:
"""执行数学计算"""
return eval(expression)
@function_tool
def get_weather(city: str) -> dict:
"""获取城市天气信息"""
return {"city": city, "temp": 22, "condition": "晴"}
定义输出格式
class AnalysisResult(BaseModel):
summary: str
key_points: list[str]
confidence: float
定义 Agent
weather_agent = Agent(
name="WeatherExpert",
instructions="你是一个天气专家，提供准确的天气信息和出行建议。",
tools=[get_weather],
model="gpt-4o"
)
research_agent = Agent(
name="Researcher",
instructions="你是一个研究员，深入分析问题并提供结构化答案。",
tools=[search_web, calculate],
output_type=AnalysisResult,
model="gpt-4o"
)
定义 triage Agent（路由 Agent）
triage_agent = Agent(
name="Triage",
instructions="""
根据用户问题的类型，路由到合适的专家：
- 天气相关 → 转交给 WeatherExpert
- 研究/分析 → 转交给 Researcher
- 其他问题 → 直接回答
""",
handoffs=[weather_agent, research_agent],
model="gpt-4o"
)
运行
async def main():
result = await Runner.run(triage_agent, "北京明天的天气怎么样？适合户外运动吗？")
print(result.final_output)
result = await Runner.run(triage_agent, "分析一下 RAG 和 Fine-tuning 的优缺点")
print(result.final_output)
OpenAI Agents SDK 的高级功能
#### Guardrails（护栏）
from agents import input_guardrail, output_guardrail, GuardrailFunctionOutput
@input_guardrail
async def content_safety_check(ctx, agent, message):
"""输入安全检查"""
is_safe = await check_content_safety(message)
return GuardrailFunctionOutput(
output_info={"safety_score": is_safe},
tripwire_triggered=not is_safe
)
safe_agent = Agent(
name="SafeAgent",
instructions="...",
input_guardrails=[content_safety_check]
)
#### Handoff 配置
from agents import handoff
带有上下文传递的 Handoff
billing_handoff = handoff(
agent=billing_agent,
tool_description="处理账单和支付问题",
on_handoff=lambda ctx: print(f"正在转交至账单专家..."),
input_type=BillingContext # 可以传递结构化上下文
)
OpenAI Agents SDK 的优势
OpenAI Agents SDK 的局限
性能基准对比
我们基于标准 Agent 基准测试对四个框架进行了对比：
执行效率（任务完成时间，秒）
成本效率（平均 Token 消耗）
选择指南
什么时候选择 LangGraph
什么时候选择 CrewAI
什么时候选择 AutoGen
什么时候选择 OpenAI Agents SDK
混合架构实践
在实际项目中，我们经常需要结合多个框架的优势：
使用 LangGraph 作为编排层
from langgraph.graph import StateGraph
from agents import Agent, Runner # OpenAI Agents SDK
LangGraph 节点调用 OpenAI Agent
async def openai_agent_node(state):
agent = Agent(name="specialist", tools=[...])
result = await Runner.run(agent, state["input"])
return {"output": result.final_output}
LangGraph 节点调用 CrewAI Crew
def crewai_node(state):
from crewai import Crew, Agent, Task
crew = Crew(agents=[...], tasks=[...])
return {"output": crew.kickoff()}
构建混合图
graph = StateGraph(AgentState)
graph.add_node("openai_step", openai_agent_node)
graph.add_node("crewai_step", crewai_node)
graph.add_edge("openai_step", "crewai_step")
总结
没有"最好"的框架，只有最适合你需求的框架。建议从核心需求出发，选择最匹配的框架，并在必要时采用混合架构。