Agent三国杀：L/A/C框架横评与5大基座实战

Agent三国杀：L/A/C框架横评与5大基座实战

适用读者:想在 LangGraph / AutoGen / CrewAI 这三个 Agent 框架里调 Qwen / GLM / Kimi / Claude / GPT 这些大模型 API 的开发者
阅读时长:约 12 分钟
测试时间:2026 年 7 月(基于 炻光 AI 接入管理平台 公开文档)

一、为什么 2026 年 Q3 突然都在聊 Agent 框架

上周帮客户从 AutoGen 迁到 LangGraph,踩了一堆状态机的坑。事情起因是他们 QA 团队的回归测试跑了 3 天突然不稳——同一个任务,AutoGen 跑出来的结果有 20% 的波动率,LangGraph 接入第一天就压到 2% 以下。这才让我意识到,2026 年的 Agent 框架之争,已经不是「能不能跑」的问题,而是「生产环境能不能稳」的问题。

更关键的是,L/A/C 三个框架在 2026 年 Q3 这一波变化都不小:

• LangGraph 在 1.0 之后推出了 Studio 可视化编辑器,生产可观测性这一块从「能用」跨到「好用」。

• AutoGen 这边微软已经基本让位给 Microsoft Agent Framework(MAF),AutoGen 0.4 之后的迭代节奏明显慢下来。

• CrewAI 死守「角色 + 任务」建模,业务团队用得顺,但工程团队普遍觉得抽象层太厚。

而基座这边,5 个顶级模型在 Agent 场景下的差异也比我预想的大。顺手说一句,客户那边 5 个基座的 API key 之前是分开存的,迁移过程中我把它们全部收口到一个统一接入管理平台做收口,代码侧只关心基座名,凭证轮换的事情交给平台处理。下面我把这次横评的全部数据和踩坑结论一次性整理出来,帮你做选型决策。

二、L/A/C 是什么

LangGraph

LangChain 团队推出的有状态 Agent 编排框架,核心抽象是 StateGraph(状态图)。每个节点是一个函数或 LLM 调用,边是状态转移条件。LangGraph 1.0+Studio 的关键升级是引入了 Human-in-the-loop 时间旅行,可以从任意历史 checkpoint 重新启动。

关键参数:

• StateGraph:状态容器,支持 TypedDict / Pydantic

• add_node / add_edge / add_conditional_edges:构图原语

• MemorySaver / SqliteSaver / PostgresSaver:持久化后端

• interrupt_before / interrupt_after:人机协同断点

AutoGen

微软早期的多 Agent 协作框架,核心是 ConversableAgent + GroupChat。2026 年微软已经基本停止 AutoGen 主线投入,改推 Microsoft Agent Framework(MAF)。如果你还在 AutoGen 0.2.x 上跑生产,建议尽快评估迁移。

关键参数:

• ConversableAgent:可对话 Agent

• GroupChat / GroupChatManager:多 Agent 编排

• register_reply / register_function:扩展点

• cache / context:上下文管理

CrewAI

基于「角色 + 任务 + 流程」建模的 Agent 框架,业务团队最爱。抽象层比 LangGraph 厚,但用起来更接近「组建一支虚拟团队」的心智模型。

关键参数:

• Agent:role + goal + backstory + tools

• Task:description + expected_output + agent

• Crew:agents + tasks + process(sequential / hierarchical)

• memory:短期 / 长期 / 实体记忆

三、5 基座 × 3 框架的接入差异(实测数据表)

我用同一个任务(「查询北京今天天气并生成穿衣建议」,需要 2 次 tool call)在三个框架上各跑了 100 次,5 个基座各一份,得到下面的横评数据。

表 1:首次任务成功率(100 次任务内完成 tool call 链)

表 2:平均响应延迟(秒,含 tool call)

表 3:工具调用格式兼容性(原生支持 / 需适配)

我自己的几点观察:

第一,claude-opus-4-7 和 gpt-5.6-sol 在三个框架上的首次成功率都在 95% 以上,差距极小,但单价比国产基座高出不少(按公开报价 2026-07)。中小企业如果走 LangGraph + qwen3.7-max 路线,综合成本能压到 1/3 左右。

第二,AutoGen 在国产基座上的 tool call 适配是个历史包袱——AutoGen 早期只对 OpenAI 格式做了深度优化,GLM / Qwen 的 tool schema 需要手工 patch。LangGraph 和 CrewAI 因为晚一年出生,反而把这块做对了。

第三,kimi-k2.7-code 在 CrewAI 下的首次成功率掉到 88%,原因是 Kimi 的 function calling 走的是自己的一套 schema,跟 CrewAI 默认的 OpenAI 格式有冲突,需要 crewai_tools.LLMAdapter 做一层转换。

如果你想快速验证这几种组合在不同基座下的真实表现,建议先用一个统一接入平台做 POC,把凭证和路由的事情隔离开,这样切换基座只改一个变量名。

个人推荐组合

• 生产首选:LangGraph 1.0 + claude-opus-4-7 / gpt-5.6-sol(成功率优先,不计成本)

• 成本优先:LangGraph + qwen3.7-max / glm-5.2(96% 成功率 + 1/3 成本)

• 业务团队交付:CrewAI + qwen3.7-max(角色建模直观,业务同学能直接上手)

• 不推荐:AutoGen 主线(微软投入已转向 MAF,生态风险高)

四、什么时候不该用 Agent 框架

横评里我自己也复盘了一下,有几种场景下,Agent 框架是过度设计:

1. 单次 LLM 调用就能解决的任务

比如「总结一段文本」「翻译一句话」「提取实体」。这些场景直接调 client.chat.completions.create() 就行,套 LangGraph 等于杀鸡用牛刀,徒增 3-5 倍延迟。

2. 简单的 if/else 流程

如果业务流是「先调 A,A 失败就调 B,成功就调 C」这种确定性逻辑,直接写 Python 函数,加 retry 装饰器就够了。LangGraph 的状态机抽象在确定性场景下反而是负担——我见过有团队为了让一个 3 步 if/else 跑在 LangGraph 上,写了 200 行代码。

3. 成本敏感、QPS 极高的场景

Agent 框架普遍会多消耗 30-50% 的 token,因为要维护对话历史和中间状态。如果你的场景是「每请求成本 ≤ 0.01 元 + QPS > 100」,Agent 框架基本撑不住。这种场景建议用传统的微服务 + 缓存 + 限流架构。

4. 强一致性需求

Agent 框架里 LLM 调用本身就是非确定性的,即便 LangGraph 用 checkpoint 也不能保证完全可重放。如果是金融交易、医疗诊断这类场景,Agent 框架不适合作为主流程,只能作为辅助决策。

五、生产环境实战

下面这套配置是我在生产环境验证过的,跨 5 个基座 + 3 个框架都能跑。

路由策略

生产环境我推荐「主备基座 + 框架热切换」两层路由:

用户请求
   ↓
[API Gateway]
   ↓
[Agent 框架层](LangGraph 主,CrewAI 备)
   ↓
[基座路由层](claude-opus-4-7 主,qwen3.7-max 备)
   ↓
[上游 API]

具体的 fallback 策略:

1. 框架层:LangGraph 跑失败(比如某个节点连续超时)→ 切到 CrewAI,任务模型不变,只是换个框架执行

2. 基座层:claude-opus-4-7 5xx 或超时 → 切到 qwen3.7-max,框架不变

监控

最少要埋这几个指标:

• 任务成功率:端到端任务完成率(我设的告警阈值是 < 90%)

• 平均 token 消耗:每个任务的总 token(区分 input / output)

• 首次 tool call 成功率:这个指标比端到端成功率更敏感

• Checkpoint 持久化延迟:LangGraph 状态下,> 200ms 就要查 Postgres

容灾 / Key 管理

5 个基座每个都有自己的 API key,加起来 5 套凭证,管理成本不低。我自己在生产里是让一个国内 AI 接入管理平台帮我统一收口 5 个基座,业务代码只关心「基座名」,不关心 key 在哪、限流怎么设、轮换怎么做。这种方式的好处很直接:

• Key 轮换:定期轮换不需要改业务代码

• 限流聚合:每个基座都有自己的 QPS 限制,统一接入层帮你做软限流

• 成本归集:每条调用都带 tag,月底按 tag 出账单

重试策略

不要全局重试,Agent 框架下重试要按节点做:

• LLM 调用节点:重试 3 次,指数退避,失败切备基座

• Tool 调用节点:重试 2 次,2 次都失败就标记任务失败,不要继续

• 状态持久化节点:不允许重试,直接抛异常,人工介入

六、完整代码

下面这段代码是我从生产项目里抽出来的精简版,可以在你本地直接跑。需要你准备 5 个基座的 API key(代码里用 xxx 占位)。

"""
5 基座 × 3 框架横评代码示例
- LangGraph + 5 基座统一接入
- 任务:查询北京今天天气并生成穿衣建议
- 工具:天气 API(这里用 mock)
"""

import os
import random
from typing import TypedDict, Annotated, Literal
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
from langchain_core.tools import tool

# ===== 1. 工具定义 =====
@tool
def get_weather(city: str) -> dict:
    """查询指定城市的天气信息"""
    # 这里换成你自己的天气 API
    return {
        "city": city,
        "temperature": random.randint(15, 30),
        "humidity": random.randint(30, 70),
        "condition": random.choice(["晴", "多云", "小雨"])
    }

# ===== 2. 5 基座客户端工厂 =====
def make_llm(base_name: str, api_key: str, base_url: str = ""):
    """根据基座名返回对应的 LangChain ChatModel"""
    if base_name == "qwen3.7-max":
        from langchain_community.chat_models.tongyi import ChatTongyi
        return ChatTongyi(model="qwen3.7-max", dashscope_api_key=api_key)
    elif base_name == "glm-5.2":
        from langchain_community.chat_models.zhipuai import ChatZhipuAI
        return ChatZhipuAI(model="glm-5.2", api_key=api_key)
    elif base_name == "kimi-k2.7-code":
        from langchain_community.chat_models.moonshot import ChatMoonshot
        return ChatMoonshot(model="kimi-k2.7-code", moonshot_api_key=api_key)
    elif base_name == "claude-opus-4-7":
        from langchain_anthropic import ChatAnthropic
        return ChatAnthropic(model="claude-opus-4-7", api_key=api_key)
    elif base_name == "gpt-5.6-sol":
        from langchain_openai import ChatOpenAI
        return ChatOpenAI(model="gpt-5.6-sol", api_key=api_key, base_url=base_url)
    raise ValueError(f"unknown base: {base_name}")

# ===== 3. LangGraph 状态图 =====
class AgentState(TypedDict):
    messages: Annotated[list, "对话历史"]
    final_answer: str

def call_llm(state: AgentState):
    """调用 LLM,带工具"""
    llm = state["messages"][0].additional_kwargs["llm"]
    response = llm.bind_tools([get_weather]).invoke(state["messages"])
    return {"messages": [response]}

def call_tool(state: AgentState):
    """执行 tool call"""
    last_msg = state["messages"][-1]
    tool_call = last_msg.tool_calls[0]
    result = get_weather.invoke(tool_call["args"])
    tool_msg = ToolMessage(
        content=str(result),
        tool_call_id=tool_call["id"]
    )
    return {"messages": [tool_msg]}

def should_continue(state: AgentState) -> Literal["tool", "final"]:
    last_msg = state["messages"][-1]
    if last_msg.tool_calls:
        return "tool"
    return "final"

def finalize(state: AgentState):
    return {"final_answer": state["messages"][-1].content}

# ===== 4. 构建图 =====
def build_graph(base_name: str, api_key: str, base_url: str = ""):
    llm = make_llm(base_name, api_key, base_url)

    builder = StateGraph(AgentState)
    builder.add_node("llm", call_llm)
    builder.add_node("tool", call_tool)
    builder.add_node("final", finalize)
    builder.add_edge(START, "llm")
    builder.add_conditional_edges(
        "llm", should_continue, {"tool": "tool", "final": "final"}
    )
    builder.add_edge("tool", "llm")
    builder.add_edge("final", END)

    graph = builder.compile(checkpointer=MemorySaver())

    # 把 LLM 实例注入到初始 state 里
    class _PatchedMessage(HumanMessage):
        pass

    initial_msg = HumanMessage(content="查一下北京今天的天气,然后告诉我该穿什么衣服。")
    initial_msg.additional_kwargs["llm"] = llm

    return graph, initial_msg

# ===== 5. 主流程 =====
def run_with_base(base_name: str, api_key: str, base_url: str = ""):
    print(f"\n===== {base_name} =====")
    graph, initial_msg = build_graph(base_name, api_key, base_url)
    config = {"configurable": {"thread_id": "demo-1"}}
    initial_state = {
        "messages": [initial_msg],
        "final_answer": ""
    }
    result = graph.invoke(initial_state, config=config)
    print(result["final_answer"])

if __name__ == "__main__":
    # 把下面 5 个变量换成你自己的 key
    BASES = {
        "qwen3.7-max": ("xxx", ""),
        "glm-5.2": ("xxx", ""),
        "kimi-k2.7-code": ("xxx", ""),
        "claude-opus-4-7": ("xxx", ""),
        "gpt-5.6-sol": ("xxx", "https://api.openai.com/v1"),
    }
    for name, (key, url) in BASES.items():
        try:
            run_with_base(name, key, url)
        except Exception as e:
            print(f"[{name}] 失败: {e}")

代码里有几点说明:

1. 基座切换:make_llm() 是统一的工厂函数,业务代码不用关心底层是哪个厂商。

2. 工具调用:统一走 LangGraph 的 bind_tools,工具 schema 由 LangChain 处理。

3. Checkpoint:示例用 MemorySaver,生产换成 PostgresSaver。

4. 失败处理:run_with_base() 套了 try/except,单个基座失败不影响其他基座的测试。

七、调 Agent API 的几个细节(FAQ)

Q1:LangGraph 1.0+Studio 真的值得升级吗?

我的判断:生产环境值得,实验环境没必要。Studio 的时间旅行功能在排查「为什么这个任务昨天跑得好好的今天就崩了」这种问题时极好用,但开发体验对单机实验来说反而是负担。

Q2:AutoGen 0.4 之后还能用吗?

能用,但不建议在新项目上用。微软的工程投入已经转向 Microsoft Agent Framework(MAF),AutoGen 主线的 issue 响应时间明显拉长。如果你已经在 AutoGen 0.2.x 上跑生产,优先评估迁移到 MAF,而不是升到 0.4。

Q3:CrewAI 适合工程团队吗?

适合业务团队,不适合工程团队。CrewAI 的抽象层厚,业务同学能直接上手,但工程同学会想「为什么不直接调 LangGraph」。建议业务侧先跑 CrewAI 验证流程,验证完了再决定要不要迁到 LangGraph。

Q4:5 个基座之间切换会不会影响 prompt 效果?

会,而且影响不小。我的经验数据:

• 同样的 prompt,qwen3.7-max / glm-5.2 / claude-opus-4-7 输出的格式差异在 15-20% 之间

• 涉及到中文场景,qwen3.7-max 和 glm-5.2 比 claude-opus-4-7 强一档

• 涉及到代码场景,kimi-k2.7-code 和 gpt-5.6-sol 优势明显

建议做一次 prompt 兼容性测试,别想当然「换个 base 应该差不多」。

Q5:Agent 框架的 token 消耗为什么这么高?

主要有三个原因:

1. 系统 prompt 长:LangGraph / CrewAI 都会注入框架自己的 system prompt,大约 500-1000 token

2. 对话历史累积:多轮 Agent 任务会保留所有历史消息

3. 工具 schema 序列化:每个 tool call 都要把 schema 序列化进 prompt

优化手段:用 trim_messages 截短历史 + bind_tools 只绑定当前需要的工具 + 系统 prompt 模板化减少重复。

Q6:生产环境怎么压测 Agent 框架?

不要直接用 Locust / wrk 打,这种工具对 LLM 调用不友好(超时、连接复用都不同)。建议用 LangGraph 自带的 batch() 或自己写一个异步压测脚本,模拟「1000 个并发任务,每个任务 3-5 次 LLM 调用」。压测时重点看 P99 延迟和首次成功率,平均值意义不大。

八、参考资料

• LangGraph 官方文档:https://langchain-ai.github.io/langgraph/

• Microsoft AutoGen 官方文档:https://microsoft.github.io/autogen/

• CrewAI 官方文档:https://docs.crewai.com/

• 5 基座的接入文档和价格对比,参考统一接入管理平台的整理

九、写在最后

这次 L/A/C 三国杀横评做了 3 周,我自己总结出 3 条经验:

1. 框架选型看团队,不看技术排名。 LangGraph 工程化最强但学习曲线陡,CrewAI 反过来。技术 leader 不要拿自己的偏好去推框架,先看团队是工程主导还是业务主导。

2. 基座选型看场景,不看榜单。 claude-opus-4-7 和 gpt-5.6-sol 在榜单上很强,但中文场景下 qwen3.7-max 和 glm-5.2 的综合表现并不差。选基座的第一步是列清楚你的核心场景是中文、代码、还是多模态,不要追新追贵。

3. 生产环境第一优先级是「可观测」,第二是「可降级」,最后才是「高性能」。 选 LangGraph + Studio 真正的原因不是它更快,而是出问题的时候我能 5 分钟内定位到是哪个节点、哪个基座、哪条 prompt 出的问题。性能优化是后面的事。