L9 主流 Agent 框架对比：LangGraph / AutoGen / CrewAI / smolagents / OpenAI Agents SDK

• 难度 ⭐⭐⭐（中级）
• 预计阅读 30 分钟
• 代码量 五大框架的 hello-world 对比
• 先修 L3-L7 全部（你已经会用 LangGraph 和 smolagents）

课程目标：横向对比 2025-2026 年五大主流 Agent 框架的架构理念、适用场景与代码风格，能为项目选择最合适的框架。

一、为什么需要框架对比？#

L3 你学了 smolagents，L5 你学了 LangGraph。但 2025 年的 Agent 框架远不止这两个——

• AutoGen（微软）——多 Agent 群聊的事实标准

• CrewAI ——基于"角色扮演"的团队抽象

• OpenAI Agents SDK（2025 年发布）——OpenAI 官方轻量级方案

• Semantic Kernel（微软）——企业级 .NET / Python 双栈

面试官会问："为什么选 LangGraph 而不是 AutoGen？"——没有标准答案，但你要能说出权衡。

这一课给你一张完整的"框架地图"，帮你建立选型直觉。

二、用一个比喻：五大框架 = 五种交通工具#

把"构建 Agent 系统"比作"运输货物"：

没有最好，只有最合适——你需要根据团队规模、任务复杂度、生态偏好来选。

三、五大框架深度对比#

1. LangGraph#

架构理念：状态图（StateGraph）——把 Agent 工作流建模成显式的节点和边。

from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated
from langgraph.checkpoint.memory import MemorySaver

class AgentState(TypedDict):
    messages: Annotated[list, lambda a, b: a + b]
    next_step: str

def research_node(state: AgentState):
    return {"messages": state["messages"] + ["research_result"]}

def analysis_node(state: AgentState):
    return {"next_step": "conclude"}

graph = StateGraph(AgentState)
graph.add_node("research", research_node)
graph.add_node("analysis", analysis_node)
graph.add_edge(START, "research")
graph.add_edge("research", "analysis")
graph.add_conditional_edges("analysis", lambda s: "end" if s["next_step"] == "conclude" else "research")
memory = MemorySaver()
app = graph.compile(checkpointer=memory)

优势：

• ✅ 显式控制流，调试和可视化极强

• ✅ 内置 Checkpoint、Human-in-the-Loop

• ✅ LangSmith 集成，生产级可观测性

• ✅ 处理循环、条件分支最自然

劣势：

• ❌ 学习曲线陡（要理解图的概念）

• ❌ 简单任务过度工程化

• ❌ 与 LangChain 生态强绑定

2. AutoGen（微软）#

架构理念：群聊（GroupChat）——多个 Agent 轮流发言，模拟真实会议。

import autogen

config_list = [{"model": "gpt-4o-mini", "api_key": "sk-..."}]

assistant = autogen.AssistantAgent(
    name="researcher",
    llm_config={"config_list": config_list},
    system_message="You are a researcher. Focus on gathering data."
)

analyst = autogen.AssistantAgent(
    name="analyst",
    llm_config={"config_list": config_list},
    system_message="You are an analyst. Interpret the researcher's findings."
)

user_proxy = autogen.UserProxyAgent(
    name="user",
    human_input_mode="TERMINATE",  # 用户可打断
    code_execution_config={"work_dir": "coding"}
)

# 创建群聊
groupchat = autogen.GroupChat(
    agents=[user_proxy, assistant, analyst],
    messages=[],
    max_round=10
)
manager = autogen.GroupChatManager(groupchat=groupchat)

# 发起对话
user_proxy.initiate_chat(
    manager,
    message="Research AI agent frameworks and write a comparison report"
)

优势：

• ✅ 多 Agent 协作的事实标准

• ✅ 对话驱动，自然支持协商

• ✅ 微软官方背书，企业级

• ✅ 内置代码执行、Human-in-the-Loop

劣势：

• ❌ 群聊模式调试困难（消息广播给所有人）

• ❌ Token 消耗大（每个 Agent 看到所有消息）

• ❌ 不擅长显式流程控制

3. CrewAI#

架构理念：角色扮演（Crews and Flows）——每个 Agent 有明确的 role / goal / backstory。

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role='Senior Research Analyst',
    goal='Uncover cutting-edge developments in AI',
    backstory='You are an expert at finding and synthesizing information',
    tools=[search_tool],
    verbose=True
)

writer = Agent(
    role='Tech Content Writer',
    goal='Create compelling technical content',
    backstory='You simplify complex topics for engineers',
    verbose=True
)

research_task = Task(
    description='Research the latest AI agent frameworks',
    agent=researcher,
    expected_output='A detailed research report'
)

writing_task = Task(
    description='Write a blog post based on research findings',
    agent=writer,
    expected_output='A 500-word blog post',
    context=[research_task]  # 依赖 research_task 的输出
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,  # 顺序执行
    verbose=2
)

result = crew.kickoff()
print(result)

优势：

• ✅ 直观的角色/任务抽象，业务人员也能看懂

• ✅ 快速原型（10 分钟搭一个多 Agent 系统）

• ✅ 顺序/层级/协商三种 Process

• ✅ 适合业务流程自动化

劣势：

• ❌ 生产级特性较少（observability、checkpoint）

• ❌ 灵活度不如 LangGraph（流程控制相对固化）

• ❌ 复杂逻辑需要绕弯

4. smolagents（HuggingFace）#

架构理念：极简 Code Agent——LLM 直接生成 Python 代码执行。

from smolagents import CodeAgent, HfApiModel, DuckDuckGoSearchTool

agent = CodeAgent(
    tools=[DuckDuckGoSearchTool()],
    model=HfApiModel(),
    max_steps=5
)

result = agent.run("Research current AI agent frameworks and compare them")
print(result)

优势：

• ✅ 30 行代码就能跑通

• ✅ CodeAgent 范式灵活度最高

• ✅ 与 HuggingFace Hub 深度集成

• ✅ 适合代码生成类 Agent

劣势：

• ❌ 生产级特性较少

• ❌ 代码执行需要沙箱（安全风险）

• ❌ 多 Agent 支持弱

5. OpenAI Agents SDK（2025 年发布）#

架构理念：官方标准化——OpenAI 推出的轻量级 Agent 框架，主打 handoff（任务转交）。

from agents import Agent, Runner, function_tool

@function_tool
def get_weather(city: str) -> str:
    """Get current weather for a city"""
    return f"Sunny, 25°C in {city}"

specialist_agent = Agent(
    name="Weather Specialist",
    instructions="You answer weather questions",
    tools=[get_weather]
)

triage_agent = Agent(
    name="Triage",
    instructions="Route user requests to appropriate specialist",
    handoffs=[specialist_agent]
)

result = Runner.run_sync(triage_agent, "What's the weather in Tokyo?")
print(result.final_output)

优势：

• ✅ OpenAI 官方，标准化趋势

• ✅ Handoff 模式清晰

• ✅ 与 OpenAI 生态无缝（Responses API、Guardrails）

• ✅ 轻量级，学习曲线低

劣势：

• ❌ 2025 年才发布，生态还在建设

• ❌ 主要绑定 OpenAI 模型

• ❌ 复杂流程支持不如 LangGraph

四、五大框架横向对比表#

五、选型决策树#

你的项目需要处理复杂长流程（>10 个步骤）吗？
├── 是 → 需要 Human-in-the-Loop 吗？
│        ├── 是 → LangGraph（生产级）
│        └── 否 → CrewAI（业务友好）或 LangGraph
│
└── 否 → 需要多 Agent 协商吗？
         ├── 是 → AutoGen（群聊最强）
         └── 否 → 主要任务是代码生成吗？
                  ├── 是 → smolagents（极简）
                  └── 否 → 用 OpenAI 生态吗？
                           ├── 是 → OpenAI Agents SDK
                           └── 否 → LangGraph（最灵活）或 smolagents（最简单）

决策速查表#

六、Hello World 五行代码对比#

同一个任务"查询北京天气并发送邮件"，五个框架的实现：

LangGraph（~50 行）#

# 需要 StateGraph + Node + Edge + Checkpointer（已在 L5 详解）

AutoGen（~15 行）#

import autogen
config = [{"model": "gpt-4o-mini", "api_key": "sk-..."}]
weather_agent = autogen.AssistantAgent("weather", llm_config={"config_list": config})
email_agent = autogen.AssistantAgent("email", llm_config={"config_list": config})
user = autogen.UserProxyAgent("user", human_input_mode="NEVER")
group = autogen.GroupChat([user, weather_agent, email_agent], messages=[], max_round=5)
user.initiate_chat(autogen.GroupChatManager(group), message="查北京天气并发邮件给 alice@example.com")

CrewAI（~15 行）#

from crewai import Agent, Task, Crew
weather_agent = Agent(role="Weather Expert", goal="查询天气", tools=[weather_tool])
email_agent = Agent(role="Email Sender", goal="发送邮件", tools=[email_tool])
t1 = Task(description="查北京天气", agent=weather_agent)
t2 = Task(description="发邮件给 alice", agent=email_agent, context=[t1])
crew = Crew(agents=[weather_agent, email_agent], tasks=[t1, t2])
print(crew.kickoff())

smolagents（~5 行）#

from smolagents import CodeAgent, HfApiModel
agent = CodeAgent(tools=[weather_tool, email_tool], model=HfApiModel())
print(agent.run("查北京天气并发邮件给 alice@example.com"))

OpenAI Agents SDK（~10 行）#

from agents import Agent, Runner
agent = Agent(name="Assistant", instructions="Help users", tools=[weather_tool, email_tool])
print(Runner.run_sync(agent, "查北京天气并发邮件给 alice@example.com").final_output)

观察：实现同样功能，代码量从 5 行（smolagents）到 50 行（LangGraph）不等。框架选择本质是"灵活度 vs 简洁度"的权衡。

七、生产环境的组合策略#

实战中很少用"纯框架"，更多是组合：

┌──────────────────────────────────────┐
│  LangGraph（顶层流程编排）            │
│    ├── CrewAI Crew（业务流程）        │
│    │     └── AutoGen GroupChat（协商）│
│    └── smolagents（代码生成子任务）   │
└──────────────────────────────────────┘

典型例子：Devin 的架构就是 LangGraph + AutoGen 思路的混合——用 LangGraph 管顶层流程，复杂子任务用对话式协作。

八、和 L1-L9 的连接#

九、动手时间：30 分钟选型实验#

请你完成以下三个小实验，亲身感受五个框架的差异：

实验 1：smolagents（5 行 vs 50 行）#

用 smolagents 实现一个"查询天气" Agent，然后改用 LangGraph 实现，对比代码量。

实验 2：CrewAI 角色定义#

用 CrewAI 定义三个角色（Researcher / Writer / Editor），让它们协作写一篇博客。观察 CrewAI 如何处理任务依赖（context=[task1]）。

实验 3：AutoGen 群聊#

用 AutoGen 创建两个 Agent（乐观派 / 悲观派），让它们讨论"AI Agent 会不会取代程序员"。观察 GroupChat 如何决定下一位发言者。

import autogen

config = [{"model": "gpt-4o-mini", "api_key": "sk-..."}]

optimist = autogen.AssistantAgent(
    name="Optimist",
    llm_config={"config_list": config},
    system_message="你是乐观派，强调 AI Agent 的优势和机会"
)

pessimist = autogen.AssistantAgent(
    name="Pessimist",
    llm_config={"config_list": config},
    system_message="你是悲观派，强调 AI Agent 的风险和局限"
)

moderator = autogen.AssistantAgent(
    name="Moderator",
    llm_config={"config_list": config},
    system_message="你是主持人，每次发言前先总结上一轮讨论"
)

user = autogen.UserProxyAgent(
    name="User",
    human_input_mode="NEVER",
    code_execution_config=False
)

groupchat = autogen.GroupChat(
    agents=[user, moderator, optimist, pessimist],
    messages=[],
    max_round=8,
    speaker_selection_method="auto"  # ← AutoGen 自动决定下一位发言者
)
manager = autogen.GroupChatManager(groupchat=groupchat)

user.initiate_chat(manager, message="AI Agent 会不会取代程序员？")

十、小结#

十一、Read next#

下一节 L10 Agentic RAG，我们学习传统 RAG 与 Agentic RAG 的本质差异，让 LLM 主动决定"什么时候检索、检索什么"。

主要参考：

• src-001 §02-explore-agentic-frameworks — 微软对主流框架的官方对比

• LangGraph 官方文档 — LangGraph 详细教程

• AutoGen 官方文档 — AutoGen 详细教程

十二、Sources#

• src-001 — Microsoft AI Agents for Beginners · T1 · 02-explore-agentic-frameworks

• LangGraph 官方文档 · T1 · langgraph docs

• AutoGen 官方文档 · T1 · autogen docs

• CrewAI 官方文档 · T1 · crewai docs

💬 有疑问？ 试试问我："我的项目该选哪个框架？"、"AutoGen 和 CrewAI 的本质区别是什么？"、"LangGraph 是不是要绑定 LangChain？"——我会用代码或比喻为你解答。