01 · 框架分层与评测坐标系

前置：会调大模型 API。不需要用过任何框架。

你在群里问「LangChain 和 LangGraph 该用哪个」，有人说用 LangGraph，有人说 LangChain 就够了，还有人说都别用。

三个人都没说错 —— 因为 LangChain 本来就跑在 LangGraph 上面。这就像问「该用 Django 还是 WSGI」。

这类争论几乎全部来自同一件事：拿不在同一层的东西在比。 所以在拆具体框架之前，得先有一把尺子，量清楚每个框架站在哪一层、又该拿哪些问题去问它。这一篇就是那把尺子。

一、先把「Agent」这个词拆开

工程上，一个 Agent 只有两部分：

• Model：会思考、会决定调什么工具的那个大脑。你换不换框架，它都在那儿。
• Harness：模型周围的一切 —— 提示词、工具、循环、上下文裁剪、状态存储、失败重试、人工审批。

换句话说：框架卖的从来不是模型能力，卖的是 Harness。 所以「LangChain 和 GPT-5.5 哪个强」是个不成立的问题 ——「LangChain 那套 Harness，比我自己手写的 while 循环强在哪」才是要问的。

Harness 通常包含这些能力，你可以拿它当 checklist 去对每个框架：

图片来源：LangChain Docs

二、Agent Loop：所有框架的最小公约数

去掉包装，几乎所有框架的核心都是同一个循环：调模型 → 模型选工具 → 执行工具 → 把结果塞回上下文 → 再调模型 → 模型不再调工具就结束。

图片来源：LangChain Docs — Middleware

手写出来大概二十行：

def agent_loop(model, tools, messages, max_turns=20):
    for _ in range(max_turns):                       # max_turns 是保险丝，防止无限循环烧钱
        # ① 把「完整对话历史 + 可用工具清单」交给模型，让它决定下一步
        response = model.invoke(messages, tools=tools)
        messages.append(response)                    # 模型这次的输出也要记进历史

        # ② 模型这次没要求调工具 → 说明它认为任务完成了，返回最终答案
        if not response.tool_calls:
            return response

        # ③ 模型要求调工具 → 逐个执行，把结果塞回历史，下一轮它就能看到
        for call in response.tool_calls:
            result = tools[call.name](**call.args)   # 真正执行的是你的代码，不是模型
            messages.append(tool_message(result, call.id))
            # call.id 很关键：模型靠它把「结果」和「是哪次调用」对上号

    raise RuntimeError("超出最大轮数")

这二十行任何人一小时能写完 —— 所以框架的价值全在这二十行之外。

写完这二十行，你会觉得自己已经做出 Agent 了。接下来几周会依次发生下面这些事，每一件都不在这二十行里：

你会撞上的问题	手写方案的代价
messages 撑爆上下文窗口	得自己实现摘要 / 裁剪 / 卸载到磁盘
第 14 轮进程挂了	从头再跑一遍，钱和时间都白花
某个工具调用要人工确认	得把整个循环拆成可暂停的状态机
想看模型每一步在想什么	得自己埋点、自己做 trace UI
要换个模型供应商	工具 schema、消息格式、流式协议全得重写
一个 Agent 忙不过来，要拆多个	得自己设计通信、路由、上下文隔离

这六行就是框架真正在卖的东西 —— 它们各自给出了一套现成答案。谁的答案更合你的场景，谁就是你该选的那个。

三、三层结构：Runtime / Framework / Harness

「Agent 框架」这个词现在同时指三种东西，混着比必然比不出结论。

四层各自解决一个正交的问题：Harness 管「开箱即用」、Framework 管「写」、Runtime 管「跑」、Model 是不变量。右侧那条竖线是关键——DeepAgents 跑在 create_agent 上、create_agent 又跑在 LangGraph 上，三者同时出现在一个技术栈里并不矛盾。比较两个框架之前，先确认它们在同一层。

3.1 Runtime（运行时）：解决「跑」

这一层和 LLM 关系不大，和分布式系统关系很大 —— 它管的是任务怎么活着跑完：

• Durable execution 持久执行：进程崩了从上次检查点继续，而不是从头
• Streaming 流式：token 级、步骤级、状态级三种粒度
• Human-in-the-loop：在任意节点中断，等人改完状态再继续
• Persistence 持久化：线程内（一次会话）和跨线程（长期记忆）

代表：LangGraph。注意 Temporal、Inngest 这类通用持久执行引擎也在这一层 —— 它们不懂 LLM，但持久执行做得比谁都好，很多团队用 Temporal + 裸 SDK 而不用 LangGraph。

3.2 Framework（框架）：解决「写」

这一层给你模型、工具、循环的统一抽象，让你不用重复造轮子，也让团队里五个人写出来的 Agent 长得像同一个东西。

代表：LangChain、OpenAI Agents SDK、Google ADK、CrewAI、Vercel AI SDK、LlamaIndex。

3.3 Harness（脚手架）：解决「开箱即用」

这一层不只给你抽象，直接给你一套已经调好的 Agent：待办清单、文件系统、子智能体、上下文压缩、以及一份反复打磨过的系统提示词，装上就能干活。

代表：DeepAgents、Claude Agent SDK、Manus。这一层是 2025 年下半年才成形的，直接受 Claude Code 启发。

层与层是可以叠的，不是互斥的

LangChain 的 create_agent 跑在 LangGraph 上；DeepAgents 又跑在 create_agent 上。所以「LangChain vs LangGraph」这个问题本身不成立 —— 正确问题是「我要在哪一层写代码」。

四、九个评测维度

有了分层，还需要一组固定的问题 —— 否则每篇文章挑各自框架的长处讲，读完还是比不出来。

下面九个维度就是这组固定问题。它们不是按「框架的功能清单」排的，而是按你从写下第一行代码到把它送上线，会依次撞上的顺序排的：先是代码长什么样（D1、D2），然后是状态和多 Agent（D3、D4），接着是工具与人工介入（D5、D6），最后是上线要面对的事（D7、D8、D9）。后面每一篇都按这九个问题回答一遍，最后在 13 横向对比 汇总成一张表。

D1 · 抽象层级：你写的是什么

风格	你写的东西	代表
声明式 Agent	一个 Agent(model, tools, instructions)	OpenAI Agents SDK、Pydantic AI、Agno、Strands
图 / 状态机	节点、边、状态 schema	LangGraph、ADK 2.0 Workflow
角色 + 任务	Role、Goal、Backstory、Task	CrewAI、MetaGPT
会话 / 群聊	一组 Agent 轮流发言	AutoGen、Microsoft Agent Framework
编译式	Signature + Optimizer，提示词是编译产物	DSPy
可视化 DAG	拖拽出来的节点图	Dify、Langflow、n8n

这是你打开框架文档第一眼就会感觉到的差异 —— 同一个「查资料然后写摘要」的需求，在 OpenAI Agents SDK 里是一个 Agent(...) 构造函数，在 LangGraph 里是三个节点两条边，在 Dify 里是拖出来的一张图。它直接决定了半年后接手的人能不能看懂你写的东西。

D2 · 控制权在谁手里

「下一步做什么」是模型说了算，还是你的代码说了算？

这个问题在 demo 阶段不重要 —— 反正你在旁边看着。上线之后它变成头号问题：模型全权决定的时候，你没法预测它会不会突然连调二十次工具；代码全权决定的时候，遇到你没想到的情况它就卡死。

一条光谱，两端各有代价：

生产系统里绝大多数最终落在中间：外层是确定性流程，内层某几步交给 Agent 自主发挥。 一个框架能不能优雅表达「混合」，是它能不能上生产的关键。

D3 · 状态与记忆

你的 Agent 查了一份 8 万字的报告。这份报告要不要留在对话历史里？留着，下一轮就爆窗口；不留，它待会儿要引用的时候就找不着了。

处理这件事的东西经常被统称为「记忆」，其实是三样不同的东西，混着叫会选错组件：

图片来源：LangChain Docs — Memory

类型	生命周期	典型实现
对话状态	一次会话内	消息列表 + checkpointer
长期记忆	跨会话	向量库 / KV store / 结构化 memory block
工作区	一次任务内，但不进上下文	虚拟文件系统、artifact store

第三种是 2025 年之后才被重视的：把大的工具结果写到「磁盘」上，只让上下文里留一个文件名。 这是 DeepAgents 和 Claude Agent SDK 能跑长任务的核心，见 04。

D4 · 多智能体拓扑

一个 Agent 装不下的时候，你会拆成几个。拆完立刻要回答：谁来指挥？它们之间传的是完整对话还是一句结论？其中一个跑歪了谁负责发现？

不同框架对这三个问题的默认答案差别很大，而且通常改不动 —— 它是框架最深的那层假设。

图片来源：LangGraph Docs — Multi-agent architectures

拓扑	谁在调度	代表框架
Supervisor 主管制	一个中心 Agent 分派	LangGraph、ADK、Agent Framework
Handoff 交接制	Agent 之间直接转交控制权	OpenAI Agents SDK
Subagent 子智能体	父 Agent 把子 Agent 当工具调，上下文隔离	DeepAgents、Claude Agent SDK
Group Chat 群聊	按规则轮流发言	AutoGen、CAMEL
Pipeline 流水线	顺序 / 并行写死	CrewAI、MetaGPT、ADK Sequential

Handoff 和 Subagent 的区别常被问到：Handoff 是「我不干了，你接手，用户接下来跟你说话」；Subagent 是「你帮我查一下，把结论给我，我继续」。前者转移控制权，后者是带隔离上下文的函数调用。

D5 · 工具生态与 MCP

图片来源：LangChain Docs — MCP

到 2026 年，MCP 支持已经是及格线而不是加分项 —— 本专题里所有活跃框架都支持。真正的差异在：

• 有没有托管工具（模型厂商侧执行的搜索 / 代码解释器 / 计算机操作）
• 工具审批粒度：能不能针对单个工具设置「执行前必须人工确认」
• 工具错误处理：报错是抛异常还是塞回给模型自己重试

D6 · 人工介入（HITL）

有些动作模型不能自己拍板 —— 发邮件给客户、删生产数据、付一笔钱。你得让它停下来等人点确认。

麻烦在于「等人」可能要等三天。这三天里你的进程还得活着吗？三种实现强度，差别就在这里：

1. 回调式：给你一个 hook，暂停等待要自己实现（大多数轻量框架）
2. 中断式：框架内建 interrupt，状态落盘，进程可以直接退出，几小时后再恢复（LangGraph、DeepAgents、ADK）
3. 审批协议：工具级别声明 interrupt_on，前端拿到结构化的审批请求（DeepAgents、LangChain 的 HumanInTheLoopMiddleware）

图片来源：Deep Agents Docs — Human-in-the-loop

只有第 2 种能撑住「等审批等三天」的业务流程，第 1 种要求进程一直活着。

D7 · 可观测性

线上答错了一次，你想知道它当时调了哪些工具、模型原话是什么。这时候才发现什么都没记下来。三个要问的问题：

• 有没有自带 tracing（OpenAI Agents SDK、Agno、ADK 有；LangChain 走 LangSmith）
• 是否输出 OpenTelemetry（决定能不能进你现有的 Grafana / Datadog）
• 有没有本地调试 UI（LangGraph Studio、ADK Web、Mastra Studio、AutoGen Studio）

D8 · 上生产的形态

pip install 完能跑，不等于能上线。谁来接 HTTP 请求、状态存哪、怎么扩容 —— 有的框架把这些都给你了，有的一件都不管：

形态	含义
纯库	pip install 后自己套 FastAPI，自己管状态
库 + 官方服务端	框架给你一个能直接跑的 API server
库 + 托管平台	有官方云，一条命令部署（通常收费）
平台优先	本来就是个要部署的系统

D9 · 供应商中立性

这是最容易被忽略、最容易在半年后咬你一口的维度。

• OpenAI Agents SDK 支持 100+ 模型，但 tracing、Realtime、Sandbox 深度绑 OpenAI
• Google ADK 号称 model-agnostic，但 Agent Engine 部署、内置 Google Search 工具只在 GCP 上香
• Microsoft Agent Framework 的快速上手路径默认 Azure Foundry
• LangChain / LangGraph / Pydantic AI / Agno 是少数几个「哪家模型都一样是二等公民 / 一等公民」的

问自己一句：如果明年要把主力模型从 A 换到 B，我要改多少行代码？

五、这些框架是怎么一步步变成今天这样的

这条时间线解释了很多现象：

• 为什么 LangChain 早期抽象那么重、现在又变轻了 —— 那时模型不会稳定调工具，框架得替它兜底；现在模型自己能规划，框架就该退回去。LangChain 1.x 把重心从 Chain 换成了 create_agent + Middleware，见 02。
• 为什么 AutoGPT 星最多却没人拿它做生产 —— 它证明了「让模型无限自主循环」不可行，这个教训催生了 LangGraph 那一代。
• 为什么 2025 年之后 Harness 派又火了 —— Claude Code 证明了「模型全权 + 好工具 + 上下文管理」是能跑长任务的，前提是模型足够强 + 工具设计足够好。这和 Anthropic 那篇长期运行代理工具设计 是同一件事的两面。

六、下一步

坐标系建好了，接下来一篇一篇拆。建议从生态最大的 02 LangChain 开始，它同时是「框架层」的样板和「和 LangGraph / DeepAgents 怎么分工」的最佳案例。

如果只想要结论，直接跳到 13 横向对比与选型决策。