2026年5大AI Agent框架实战对比：LangGraph vs CrewAI vs OpenAI Agents SDK vs AutoGen vs Google ADK

上周有人在群里问："现在搞AI Agent用哪个框架好？"我一看，好家伙，这问题底下直接吵起来了——有人说LangGraph是唯一正解，有人说CrewAI上手最快，还有人说OpenAI官方SDK才是未来。吵了半天也没个结论。

其实吧，这个问题没有标准答案。不同框架适合不同场景，关键是你得知道自己要干什么。我这半年断断续续把这几个主流框架都折腾了一遍，有的用在了真实项目里，有的就是写demo感受了一下。今天就把我的实际体验分享出来，不吹不黑，纯干货。

先列一下今天要聊的五个框架：

LangGraph — LangChain出品，图模型编排，生产环境扛把子
CrewAI — 角色扮演式多Agent，上手速度最快
OpenAI Agents SDK — OpenAI官方出品，轻量级但功能不弱
AutoGen 2.0 — 微软研究院重构版，异步架构
Google ADK — Google的Agent开发套件，Gemini生态

另外还有一个Anthropic的Claude Agent SDK，但目前还在早期阶段，功能跟OpenAI Agents SDK有不少重叠，后面单独写文章聊。今天先聚焦这五个。

为什么需要Agent框架？

在聊具体框架之前，先说一个很多人忽略的问题：你真的需要Agent框架吗？

如果你的需求就是"给LLM加个搜索工具"或者"让LLM能读写文件"，那你完全不需要任何框架。直接用OpenAI的function calling，几十行代码就搞定了：

python

import openai
 
tools = [{
    "type": "function",
    "function": {
        "name": "web_search",
        "description": "搜索互联网获取最新信息",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "搜索关键词"}
            },
            "required": ["query"]
        }
    }
}]
 
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "今天北京天气怎么样？"}],
    tools=tools
)

简单粗暴，能用就行。

但当你需要这些东西的时候，框架就有价值了：

多Agent协作：一个Agent负责搜索，一个负责分析，一个负责写报告
状态管理：Agent需要记住之前的对话和操作
人类介入：关键步骤需要人类确认才能继续
错误恢复：Agent执行到一半挂了，能从断点恢复
可观测性：想知道Agent每一步在干什么，出了问题能排查

如果你的场景涉及这些，那就值得花时间选一个框架了。

LangGraph：生产环境的扛把子

一句话总结

如果你要做正经的、上了生产要背锅的Agent系统，LangGraph目前是最靠谱的选择。

核心思路

LangGraph的核心抽象是图（Graph）。每个Agent的处理步骤是一个节点（Node），步骤之间的流转关系是边（Edge）。你可以用条件边实现分支逻辑，用循环实现反复重试，整个执行流程完全在你的控制之下。

听起来是不是很像状态机？没错，本质上就是一个带LLM能力的状态机。

python

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
 
class AgentState(TypedDict):
    query: str
    search_results: list[str]
    analysis: str
    needs_review: bool
 
def search_node(state: AgentState) -> AgentState:
    """搜索节点：调用搜索工具获取信息"""
    results = do_search(state["query"])
    return {"search_results": results}
 
def analyze_node(state: AgentState) -> AgentState:
    """分析节点：用LLM分析搜索结果"""
    analysis = llm_analyze(state["search_results"])
    needs_review = "不确定" in analysis
    return {"analysis": analysis, "needs_review": needs_review}
 
def route_after_analysis(state: AgentState) -> str:
    """条件路由：决定是否需要人工审核"""
    if state["needs_review"]:
        return "human_review"
    return "generate_output"
 
# 构建图
workflow = StateGraph(AgentState)
workflow.add_node("search", search_node)
workflow.add_node("analyze", analyze_node)
workflow.add_node("human_review", human_review_node)
workflow.add_node("generate_output", output_node)
 
# 定义流转
workflow.set_entry_point("search")
workflow.add_edge("search", "analyze")
workflow.add_conditional_edges("analyze", route_after_analysis)
workflow.add_edge("human_review", "generate_output")
workflow.add_edge("generate_output", END)
 
app = workflow.compile()

我的踩坑经历

第一次用LangGraph的时候，我被它的图模型搞懵了。之前写代码都是线性的，突然要画图、定义节点和边，脑子有点转不过来。花了大概两天时间才真正理解StateGraph的运作方式。

最大的坑是状态管理。LangGraph的状态是通过TypedDict定义的，每个节点函数接收状态、返回更新。但问题是，如果你的节点返回的状态字段名写错了，它不会报错，只是静默忽略。我有一次把search_results写成了search_result（少了个s），debug了大半天才发现。

还有一个坑是条件边的返回值必须是节点名称的字符串。我一开始以为可以返回节点对象，结果直接报错。这个文档里写了，但我没仔细看，踩坑了。

优点

完全可控：每一步执行路径都是你定义的，不存在"Agent自己决定做什么"的黑盒
Human-in-the-loop原生支持：图可以在任意节点暂停，等人类输入后继续
LangSmith可观测性：配套的LangSmith可以追踪每一次图执行的完整流程，出了问题很好排查
状态持久化：支持checkpoint，Agent执行到一半挂了可以恢复
社区生态最好：126,000+ GitHub stars，文档和教程最多

缺点

学习曲线陡：图模型的心智负担比线性代码大很多
样板代码多：一个简单的单Agent任务也要写不少胶水代码
依赖LangChain生态：虽然可以单独用LangGraph，但很多高级功能需要LangSmith（收费）

适合什么场景

需要合规审计的金融、医疗场景
复杂的多步骤工作流
需要人类在关键节点介入的流程
对可靠性要求高的生产系统

CrewAI：上手速度最快

一句话总结

如果你要快速出demo、让非技术人员也能看懂Agent定义，CrewAI是最佳选择。

核心思路

CrewAI的核心抽象是角色（Role）。你给每个Agent定义一个角色名、目标、背景故事，然后把它们组成一个"船员组（Crew）"，分配任务，Agent们就会协作完成。

这个设计思路很直觉——就像你在组建一个团队，每个人有自己的分工。

python

from crewai import Agent, Task, Crew, Process
 
# 定义Agent角色
researcher = Agent(
    role="市场调研分析师",
    goal="收集目标市场的竞品信息和用户需求",
    backstory="你是一个有10年经验的市场分析师，擅长从海量数据中提炼关键洞察",
    tools=[web_search, database_query],
    verbose=True
)
 
writer = Agent(
    role="内容策划专家",
    goal="基于调研结果撰写高质量的分析报告",
    backstory="你是一个资深的技术写手，擅长将复杂的技术概念用通俗的语言表达",
    tools=[file_writer]
)
 
# 定义任务
research_task = Task(
    description="调研2026年主流AI Agent框架的市场表现和用户评价",
    expected_output="一份包含各框架优劣势的调研报告",
    agent=researcher
)
 
writing_task = Task(
    description="基于调研结果写一篇深度对比分析文章",
    expected_output="一篇5000字以上的分析文章",
    agent=writer,
    context=[research_task]  # 依赖调研任务的输出
)
 
# 组建Crew并执行
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,  # 按顺序执行
    verbose=True
)
 
result = crew.kickoff()
print(result)

看到没？代码读起来就像在描述一个团队的工作流程。产品经理也能看懂，这是CrewAI最大的优势。

我的踩坑经历

CrewAI上手确实快，我大概花了半小时就跑通了第一个demo。但很快遇到了两个问题。

第一个问题是token消耗。CrewAI的Agent之间会"互相交流"，这种交流消耗的token比你想象的多得多。我跑一个三Agent的任务，本来以为消耗100K token就够了，结果实际消耗了接近300K。原因是Agent之间的对话会携带大量上下文，而且CrewAI默认的verbose模式会在控制台打印所有中间过程，但这些中间过程也占token。

第二个问题是调试困难。当Agent做出意料之外的行为时（比如researcher把任务转交给了writer，而writer又转回给了researcher），你很难搞清楚到底发生了什么。LangGraph的图模型虽然复杂，但至少每个节点的执行路径是确定的。CrewAI的Agent协作更像是"自由讨论"，结果有时候不可预测。

第三个坑是Flows的文档。CrewAI后来推出了Flows功能，号称是"企业级生产架构"。但我实际用下来，Flows的文档跟Crews的文档混在一起，经常搞不清楚某个功能是Flows的还是Crews的。而且Flows的一些API跟Crews不太一样，迁移成本不低。

优点

上手极快：半小时能跑通demo，一天能搭出一个像样的原型
角色定义可读性强：非技术人员也能看懂Agent在干什么
内置委派机制：Agent可以自动把子任务分配给其他Agent
支持顺序和层级两种执行模式：sequential适合流水线，hierarchical适合有"项目经理"的场景
独立于LangChain：不依赖LangChain生态，轻量

缺点

执行流程不够可控：Agent的协作行为有时候不可预测
Token消耗大：多Agent交流的开销比单Agent大很多
调试体验差：出了问题不好排查
没有大厂背书：不像LangGraph有LangChain、AutoGen有微软，CrewAI是独立团队

适合什么场景

快速原型验证
内容生成、调研分析类任务
需要让非技术人员理解Agent逻辑的场景
不太在意执行确定性的探索性项目

OpenAI Agents SDK：官方出品的轻量方案

一句话总结

如果你主要用OpenAI的模型，想要一个简洁、设计良好的Agent框架，Agents SDK值得试试。

核心思路

OpenAI Agents SDK的设计哲学是简洁。它不像LangGraph那样用图模型，也不像CrewAI那样用角色扮演，而是用一种很自然的方式定义Agent和工具。

核心概念就几个：Agent、Tool、Handoff、Guardrail。

python

from agents import Agent, Runner, function_tool
 
@function_tool
def get_weather(city: str) -> str:
    """获取指定城市的天气信息"""
    # 实际的天气API调用
    return f"{city}今天晴，气温25°C"
 
@function_tool
def search_web(query: str) -> str:
    """搜索互联网"""
    return do_web_search(query)
 
# 定义Agent
weather_agent = Agent(
    name="天气助手",
    instructions="你是一个天气查询助手，帮用户查询天气信息。如果用户问的不是天气问题，转交给通用助手。",
    tools=[get_weather]
)
 
general_agent = Agent(
    name="通用助手",
    instructions="你是一个通用AI助手，可以回答各种问题。",
    tools=[search_web]
)
 
# 定义Handoff（Agent之间的转交）
weather_agent.handoffs = [general_agent]
 
# 运行
result = Runner.run_sync(weather_agent, "北京今天天气怎么样？")
print(result.final_output)

Handoff是OpenAI Agents SDK最有意思的设计。它允许一个Agent在觉得自己处理不了的时候，把对话转交给另一个Agent。就像客服系统里的转接，但更智能。

我的体验

OpenAI Agents SDK给我的整体感觉是"恰到好处"。它没有LangGraph那么重，也没有CrewAI那么"花哨"，就是一个干干净净的Agent框架。

让我印象深刻的是它的Guardrail机制。你可以在Agent的输入和输出上加验证逻辑，不通过就拦截：

python

from agents import Agent, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel
 
class SafetyCheck(BaseModel):
    is_safe: bool
    reason: str
 
safety_guardrail = Agent(
    name="安全检查",
    instructions="检查用户输入是否包含不当内容",
    output_type=SafetyCheck
)
 
async def check_safety(ctx, agent, input):
    result = await Runner.run(safety_guardrail, input)
    return GuardrailFunctionOutput(
        output_info=result.final_output,
        tripwire_triggered=not result.final_output.is_safe
    )
 
agent = Agent(
    name="助手",
    instructions="你是一个有帮助的助手",
    input_guardrails=[InputGuardrail(guardrail_function=check_safety)]
)

这个设计在生产环境非常实用。你可以在Agent执行前就拦截掉有问题的输入，而不是等Agent回复了再去审查。

还有一个让我觉得不错的是Sandbox Agent（v0.14.0新增）。这个功能让Agent可以在一个沙箱环境里执行代码、操作文件，类似Claude Code的worktree模式。对于需要长时间运行、操作文件系统的任务非常有用。

优点

设计简洁：API干净，概念少，上手快
Handoff机制：Agent之间的转交非常自然
Guardrail原生支持：输入输出验证开箱即用
支持100+模型：虽然是OpenAI出品，但不锁死在OpenAI模型上
内置Tracing：自带追踪能力，调试方便
Sandbox Agent：支持沙箱环境执行长时间任务

缺点

相对年轻：2025年才开源，生态还在建设中
复杂场景支持有限：不像LangGraph那样支持复杂的图编排
文档示例偏简单：高级用法的文档还不够完善

适合什么场景

中等复杂度的Agent任务
需要Agent之间灵活转交的场景
对输入输出安全性有要求的应用
想要快速上手、不想学太多概念的开发者

AutoGen 2.0：微软的异步利器

一句话总结

如果你在Azure生态里，或者需要高并发的多Agent场景，AutoGen 2.0值得考虑。

核心思路

AutoGen的核心思路是对话。Agent之间通过消息交换来协作，就像一群人在微信群里讨论问题。2.0版本完全重写了架构，从同步改成了异步，性能提升了一个量级。

python

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient
 
# 创建模型客户端
model = OpenAIChatCompletionClient(model="gpt-4o")
 
# 定义Agent
coder = AssistantAgent(
    name="coder",
    model_client=model,
    system_message="你是一个Python开发者，负责写代码实现需求"
)
 
reviewer = AssistantAgent(
    name="reviewer",
    model_client=model,
    system_message="你是一个代码审查专家，负责审查代码质量并提出改进建议"
)
 
# 组建团队，轮流转发言
team = RoundRobinGroupChat(
    participants=[coder, reviewer],
    max_turns=4
)
 
# 运行
result = await team.run(task="写一个Python函数，实现快速排序并添加单元测试")

AutoGen 2.0的对话模式很灵活：两个Agent一对一聊、多个Agent群聊、甚至嵌套对话（一个Agent的回复触发另一个子对话）都可以。

我的体验

说实话，AutoGen 1.0给我的体验很差。那时候的API设计混乱，文档过时，经常遇到版本不兼容的问题。但2.0完全重写之后，体验好了很多。

最让我惊喜的是它的异步性能。我测试过同时跑200个Agent会话，AutoGen 2.0处理起来游刃有余，而同样的任务用CrewAI跑就明显感觉到卡顿。

但AutoGen 2.0也有一个让我很头疼的问题：token消耗不可控。因为Agent之间是"自由对话"的，你很难预估一次任务会消耗多少token。我有一次跑一个代码审查任务，两个Agent互相"辩论"了20多轮才结束，token消耗直接爆了。

后来我加了max_turns限制才解决这个问题。但这也说明，AutoGen的对话模式在没有限制的情况下，成本控制是一个挑战。

优点

异步架构：高并发场景性能出色
Azure深度集成：跟Azure OpenAI无缝对接
对话模式灵活：一对一、群聊、嵌套对话都支持
代码执行能力强：HumanProxyAgent模式很适合代码生成+审查场景
微软研究院背书：新功能从论文到实现的转化很快

缺点

Token消耗不可控：对话模式容易导致Agent"话太多"
从1.0到2.0的迁移成本高：API完全变了，老代码不能直接用
文档质量参差不齐：有些模块的文档写得很好，有些几乎没有
社区活跃度不如LangGraph：GitHub stars和讨论量都少一截

适合什么场景

需要高并发的多Agent系统
在Azure生态里部署的项目
代码生成和审查类任务
需要Agent之间"讨论"来达成共识的场景

Google ADK：Gemini生态的后来者

一句话总结

如果你深度使用Gemini模型和Google Cloud，ADK是最自然的选择。但它目前还在快速迭代中，API变化比较频繁。

核心思路

Google ADK（Agent Development Kit）是Google在2025年底推出的Agent开发框架，跟Gemini模型深度集成。它的设计思路是代码优先（Code-first）——所有Agent逻辑都用Python代码定义，不依赖声明式配置。

python

from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
 
# 定义Agent
root_agent = Agent(
    name="assistant",
    model="gemini-2.0-flash",
    description="一个有帮助的AI助手",
    instruction="你是一个专业的技术助手，能回答各种技术问题",
    tools=[search_tool, calculator_tool]
)
 
# 设置Runner
session_service = InMemorySessionService()
runner = Runner(
    agent=root_agent,
    app_name="my_app",
    session_service=session_service
)
 
# 运行
from google.genai import types
user_message = types.Content(
    role="user",
    parts=[types.Part(text="帮我解释一下量子计算的基本原理")]
)

ADK支持多Agent编排，你可以定义一个层级结构：主Agent负责理解用户意图，然后把子任务分配给专门的子Agent。

我的体验

ADK给我的感觉是"潜力很大，但还不够成熟"。我试用的时候遇到了几个问题：

首先，安装依赖冲突。ADK的一些依赖跟Google的其他库（比如google-cloud-aiplatform）有版本冲突，我花了差不多一个小时才把环境搞干净。

其次，文档更新跟不上代码。ADK的迭代速度很快，基本上每周都有新版本。但文档有时候跟不上，你照着文档写代码，跑起来发现API已经变了。

最后，社区资源少。跟LangGraph、CrewAI比起来，ADK的中文社区资源几乎没有。遇到问题基本只能看GitHub Issues和官方文档。

但话说回来，ADK的底层能力是真的强。特别是跟Gemini 2.0系列模型配合使用的时候，响应速度和质量都很不错。而且Google Cloud的Vertex AI平台对ADK有原生支持，部署很方便。

优点

Gemini模型深度集成：跟Google自家模型配合最好
代码优先：逻辑都在代码里，不依赖配置文件
Vertex AI部署方便：Google Cloud用户一键部署
支持MCP协议：原生支持Model Context Protocol
迭代速度快：Google在全力推进

缺点

不够成熟：API变化频繁，生产环境用要谨慎
依赖冲突多：跟Google其他库的兼容性有待改善
中文社区资源少：遇到问题不好找解决方案
模型锁定倾向：虽然理论上支持其他模型，但跟Gemini配合最好

适合什么场景

深度使用Gemini模型的团队
在Google Cloud上部署的项目
需要跟Google服务（搜索、地图、YouTube等）集成的Agent
对新技术有耐心、愿意踩坑的开发者

五个框架横向对比

聊完了每个框架的细节，来做一个横向对比。以下是我的主观评分，满分5分。

上手难度（分数越高越容易上手）：

CrewAI：⭐⭐⭐⭐⭐ — 半小时跑通demo
OpenAI Agents SDK：⭐⭐⭐⭐ — 概念少，API干净
Google ADK：⭐⭐⭐ — 安装有点折腾
AutoGen 2.0：⭐⭐⭐ — 2.0比1.0好很多
LangGraph：⭐⭐ — 图模型需要时间理解

生产就绪度：

LangGraph：⭐⭐⭐⭐⭐ — 最成熟，有LangSmith加持
OpenAI Agents SDK：⭐⭐⭐⭐ — 虽然年轻但设计扎实
AutoGen 2.0：⭐⭐⭐⭐ — 微软背书，Azure集成好
CrewAI：⭐⭐⭐ — Flows在努力但还有差距
Google ADK：⭐⭐ — 迭代太快，API不稳定

Token消耗控制：

LangGraph：⭐⭐⭐⭐⭐ — 图模型天然可控
OpenAI Agents SDK：⭐⭐⭐⭐ — Guardrail可以限制
Google ADK：⭐⭐⭐ — 还行
CrewAI：⭐⭐ — 多Agent交流消耗大
AutoGen 2.0：⭐⭐ — 对话模式容易失控

多Agent协作能力：

AutoGen 2.0：⭐⭐⭐⭐⭐ — 对话模式最灵活
CrewAI：⭐⭐⭐⭐⭐ — 角色扮演最直觉
LangGraph：⭐⭐⭐⭐ — 子图支持
OpenAI Agents SDK：⭐⭐⭐⭐ — Handoff机制
Google ADK：⭐⭐⭐ — 层级编排

社区和生态：

LangGraph：⭐⭐⭐⭐⭐ — 126K+ stars，生态最完善
CrewAI：⭐⭐⭐⭐ — 44K+ stars，社区活跃
OpenAI Agents SDK：⭐⭐⭐⭐ — OpenAI光环加持
AutoGen 2.0：⭐⭐⭐ — 微软社区
Google ADK：⭐⭐ — 还在早期

我的选择建议

说了这么多，到底该选哪个？我的建议是按场景来：

如果你要做生产级Agent系统：选LangGraph。学习曲线是陡了点，但图模型的可控性和LangSmith的可观测性在生产环境是救命的。

如果你要快速验证想法：选CrewAI。半小时出demo，一天出原型，非常适合MVP阶段。

如果你想要一个平衡的选择：选OpenAI Agents SDK。简洁、够用、不花哨，适合大多数中等复杂度的场景。

如果你在Azure生态里：选AutoGen 2.0。跟Azure OpenAI的集成是无缝的，异步性能也好。

如果你在Google Cloud生态里：选Google ADK。但要做好踩坑的准备，目前还在快速迭代中。

如果你拿不准：先从OpenAI Agents SDK开始。它的学习成本最低，概念最通用，之后迁移到其他框架也比较容易。

一个实际项目的框架选型过程

分享一个我最近做项目的选型过程，给大家参考。

需求是这样的：做一个自动化的内容分析系统，输入一个URL，系统自动抓取内容、分析关键信息、生成结构化报告。中间需要人类确认一些关键判断。

一开始我用了CrewAI，因为上手快。定义了三个Agent：爬虫Agent、分析Agent、报告Agent。跑了几天，发现两个问题：一是token消耗太高（每天跑100个URL要花$15-20），二是分析Agent有时候会把一些不确定的判断直接跳过，不等人类确认。

然后我切到了LangGraph。用图模型重新设计了流程：爬取→初步分析→判断是否需要人类确认→确认/自动处理→生成报告。Human-in-the-loop的原生支持完美解决了人类确认的问题，图模型也让token消耗变得可控（同样的100个URL，每天$8-10）。

但LangGraph的开发效率确实不如CrewAI。同样的功能，CrewAI我半天就搞定了，LangGraph花了两天。

最后的结论：如果你的项目需要上生产、要控制成本、要人类介入，LangGraph值得多花的时间。如果只是内部工具、不需要那么严格，CrewAI足够了。

2026年下半年的趋势

最后聊聊我对这个领域的一些观察：

MCP协议正在成为标配。几乎所有的Agent框架都在支持MCP（Model Context Protocol），这个协议让Agent可以标准化地调用外部工具。如果你现在开始学Agent框架，建议先了解一下MCP。

Agent-as-a-Service兴起。越来越多的平台提供托管的Agent运行环境，你不需要自己搭服务器。LangSmith Deployment、CrewAI Enterprise、Google Vertex AI Agent Builder都在做这件事。

多模态Agent是下一个战场。不只是文本，Agent需要处理图片、音频、视频。OpenAI的GPT-4o、Google的Gemini 2.0都在往这个方向走，框架也需要跟进。

成本控制越来越重要。随着Agent应用场景的扩大，token消耗的成本会成为一个核心问题。那些能在框架层面帮助控制成本的方案会更有竞争力。

好了，这篇就写到这。后面打算用每个框架分别做一个完整的小项目，到时候再写详细的实战教程。有问题评论区聊。

1	`import openai`
2
3	`tools = [{`
4	`"type": "function",`
5	`"function": {`
6	`"name": "web_search",`
7	`"description": "搜索互联网获取最新信息",`
8	`"parameters": {`
9	`"type": "object",`
10	`"properties": {`
11	`"query": {"type": "string", "description": "搜索关键词"}`
12	`},`
13	`"required": ["query"]`
14	`}`
15	`}`
16	`}]`
17
18	`response = openai.chat.completions.create(`
19	`model="gpt-4o",`
20	`messages=[{"role": "user", "content": "今天北京天气怎么样？"}],`
21	`tools=tools`
22	`)`

1	`from langgraph.graph import StateGraph, END`
2	`from typing import TypedDict, Annotated`
3
4	`class AgentState(TypedDict):`
5	`query: str`
6	`search_results: list[str]`
7	`analysis: str`
8	`needs_review: bool`
9
10	`def search_node(state: AgentState) -> AgentState:`
11	`"""搜索节点：调用搜索工具获取信息"""`
12	`results = do_search(state["query"])`
13	`return {"search_results": results}`
14
15	`def analyze_node(state: AgentState) -> AgentState:`
16	`"""分析节点：用LLM分析搜索结果"""`
17	`analysis = llm_analyze(state["search_results"])`
18	`needs_review = "不确定" in analysis`
19	`return {"analysis": analysis, "needs_review": needs_review}`
20
21	`def route_after_analysis(state: AgentState) -> str:`
22	`"""条件路由：决定是否需要人工审核"""`
23	`if state["needs_review"]:`
24	`return "human_review"`
25	`return "generate_output"`
26
27	`# 构建图`
28	`workflow = StateGraph(AgentState)`
29	`workflow.add_node("search", search_node)`
30	`workflow.add_node("analyze", analyze_node)`
31	`workflow.add_node("human_review", human_review_node)`
32	`workflow.add_node("generate_output", output_node)`
33
34	`# 定义流转`
35	`workflow.set_entry_point("search")`
36	`workflow.add_edge("search", "analyze")`
37	`workflow.add_conditional_edges("analyze", route_after_analysis)`
38	`workflow.add_edge("human_review", "generate_output")`
39	`workflow.add_edge("generate_output", END)`
40
41	`app = workflow.compile()`

1	`from crewai import Agent, Task, Crew, Process`
2
3	`# 定义Agent角色`
4	`researcher = Agent(`
5	`role="市场调研分析师",`
6	`goal="收集目标市场的竞品信息和用户需求",`
7	`backstory="你是一个有10年经验的市场分析师，擅长从海量数据中提炼关键洞察",`
8	`tools=[web_search, database_query],`
9	`verbose=True`
10	`)`
11
12	`writer = Agent(`
13	`role="内容策划专家",`
14	`goal="基于调研结果撰写高质量的分析报告",`
15	`backstory="你是一个资深的技术写手，擅长将复杂的技术概念用通俗的语言表达",`
16	`tools=[file_writer]`
17	`)`
18
19	`# 定义任务`
20	`research_task = Task(`
21	`description="调研2026年主流AI Agent框架的市场表现和用户评价",`
22	`expected_output="一份包含各框架优劣势的调研报告",`
23	`agent=researcher`
24	`)`
25
26	`writing_task = Task(`
27	`description="基于调研结果写一篇深度对比分析文章",`
28	`expected_output="一篇5000字以上的分析文章",`
29	`agent=writer,`
30	`context=[research_task] # 依赖调研任务的输出`
31	`)`
32
33	`# 组建Crew并执行`
34	`crew = Crew(`
35	`agents=[researcher, writer],`
36	`tasks=[research_task, writing_task],`
37	`process=Process.sequential, # 按顺序执行`
38	`verbose=True`
39	`)`
40
41	`result = crew.kickoff()`
42	`print(result)`

1	`from agents import Agent, Runner, function_tool`
2
3	`@function_tool`
4	`def get_weather(city: str) -> str:`
5	`"""获取指定城市的天气信息"""`
6	`# 实际的天气API调用`
7	`return f"{city}今天晴，气温25°C"`
8
9	`@function_tool`
10	`def search_web(query: str) -> str:`
11	`"""搜索互联网"""`
12	`return do_web_search(query)`
13
14	`# 定义Agent`
15	`weather_agent = Agent(`
16	`name="天气助手",`
17	`instructions="你是一个天气查询助手，帮用户查询天气信息。如果用户问的不是天气问题，转交给通用助手。",`
18	`tools=[get_weather]`
19	`)`
20
21	`general_agent = Agent(`
22	`name="通用助手",`
23	`instructions="你是一个通用AI助手，可以回答各种问题。",`
24	`tools=[search_web]`
25	`)`
26
27	`# 定义Handoff（Agent之间的转交）`
28	`weather_agent.handoffs = [general_agent]`
29
30	`# 运行`
31	`result = Runner.run_sync(weather_agent, "北京今天天气怎么样？")`
32	`print(result.final_output)`

1	`from agents import Agent, InputGuardrail, GuardrailFunctionOutput`
2	`from pydantic import BaseModel`
3
4	`class SafetyCheck(BaseModel):`
5	`is_safe: bool`
6	`reason: str`
7
8	`safety_guardrail = Agent(`
9	`name="安全检查",`
10	`instructions="检查用户输入是否包含不当内容",`
11	`output_type=SafetyCheck`
12	`)`
13
14	`async def check_safety(ctx, agent, input):`
15	`result = await Runner.run(safety_guardrail, input)`
16	`return GuardrailFunctionOutput(`
17	`output_info=result.final_output,`
18	`tripwire_triggered=not result.final_output.is_safe`
19	`)`
20
21	`agent = Agent(`
22	`name="助手",`
23	`instructions="你是一个有帮助的助手",`
24	`input_guardrails=[InputGuardrail(guardrail_function=check_safety)]`
25	`)`

1	`from autogen_agentchat.agents import AssistantAgent`
2	`from autogen_agentchat.teams import RoundRobinGroupChat`
3	`from autogen_ext.models.openai import OpenAIChatCompletionClient`
4
5	`# 创建模型客户端`
6	`model = OpenAIChatCompletionClient(model="gpt-4o")`
7
8	`# 定义Agent`
9	`coder = AssistantAgent(`
10	`name="coder",`
11	`model_client=model,`
12	`system_message="你是一个Python开发者，负责写代码实现需求"`
13	`)`
14
15	`reviewer = AssistantAgent(`
16	`name="reviewer",`
17	`model_client=model,`
18	`system_message="你是一个代码审查专家，负责审查代码质量并提出改进建议"`
19	`)`
20
21	`# 组建团队，轮流转发言`
22	`team = RoundRobinGroupChat(`
23	`participants=[coder, reviewer],`
24	`max_turns=4`
25	`)`
26
27	`# 运行`
28	`result = await team.run(task="写一个Python函数，实现快速排序并添加单元测试")`

1	`from google.adk.agents import Agent`
2	`from google.adk.runners import Runner`
3	`from google.adk.sessions import InMemorySessionService`
4
5	`# 定义Agent`
6	`root_agent = Agent(`
7	`name="assistant",`
8	`model="gemini-2.0-flash",`
9	`description="一个有帮助的AI助手",`
10	`instruction="你是一个专业的技术助手，能回答各种技术问题",`
11	`tools=[search_tool, calculator_tool]`
12	`)`
13
14	`# 设置Runner`
15	`session_service = InMemorySessionService()`
16	`runner = Runner(`
17	`agent=root_agent,`
18	`app_name="my_app",`
19	`session_service=session_service`
20	`)`
21
22	`# 运行`
23	`from google.genai import types`
24	`user_message = types.Content(`
25	`role="user",`
26	`parts=[types.Part(text="帮我解释一下量子计算的基本原理")]`
27	`)`