主题
第 1 章 什么是 Agent
如果要选出一个最能代表当前 AI 发展阶段的词,答案不是大语言模型(Large Language Model,LLM)本身,而是它之上的智能体(Agent)。
在最初的生态划分里,Agent 只是 LLM 衍生出来的一种应用形态。但是在当下,这个状态已经发生了更本性的逆转。Agent 已经成为公众与技术界谈论 AI 时的代名词。
今天人们讨论 AI 如何落地、如何改变行业,本质上讨论的都是 Agent 如何使用的问题。Agent 早已走出实验室论文的纸面推演,在算力突破,开源生态在成熟,行业应用在铺开这三股力量的推动下,一路狂奔着往前走。
如今,从代码重构到业务流接管,Agent 正在以超高的效率重塑生产力格局。但繁荣之下,概念的混淆也随之而来。
究竟什么是真正的 Agent?它与普通的自动化脚本、聊天机器人有何本质区别?它是如何一路演进至今的?它又将给个人能力与组织形态带来怎样的剧烈冲击?
在开启后续架构与工程实战的讨论之前,我们必须先进行认知对齐,同时也是最基础也最核心的问题:到底什么是 Agent?
1.1 Agent 概念简介
其实如果能够回答前面提出的四个问题:Agent 是什么,它与普通的自动化脚本、聊天机器人有何本质区别,它如何一路演进至今,它将给个人能力与组织形态带来怎样的冲击。那么Agent也不那么神秘。我们先从第一个问题开始,顺带划清它与聊天机器人、工作流(Workflow)的边界,也就是第二问的前半。第三、第四个问题留给后面几节。
本节分五步。1.1.1 给一个可检验的工程定义,1.1.2 区分三个容易混淆的对象,1.1.3 用一段最小代码把定义跑起来,1.1.4 说明它和 LLM 的分工与成本,1.1.5 划出定义的适用边界。
1.1.1 一个可检验的工程定义
先给定义,再逐条拆。Agent 是以 LLM 为推理核心,能在循环中持续调用工具、能够读取结果且能记忆,并循环推进目标的应用程序。
这句话里有四个必要条件,少一个都不成立。
- 推理核心:由 LLM 判断下一步做什么。
- 上下文(Context):保存任务、历史动作与工具返回的结果。
- 工具:把外部系统包装成可调用的函数或服务。
- 执行循环(Loop):决定何时继续、何时停止、出错时怎么退出。
至于长期记忆(向量数据库等)归入上下文的外延,本书不单列为第五个条件。
换个角度看,缺一件就会退回上一代形态。没有推理核心,它是工作流;没有跨步保存的状态,它是一次性问答;没有工具,它只能给建议;没有循环,它只有一次机会。
提示词(Prompt)也不是 Agent。它能规定角色和输出格式,却不能自己调用工具,也拿不到实时返回。一段再长的 Prompt,跑完一次就结束,第二次从零开始。它解决的是单次生成,不解决多步推进。
框架同样不等于 Agent。LangGraph、AutoGen 这类项目提供的只是脚手架,主要解决状态流转、消息路由和并发。脚手架本身不产生判断,真正做判断的仍是模型。把框架图当成 Agent,就像把集成开发环境(IDE)当成程序员。
四个条件里最容易缺的是最后一个。多数演示版本能调用工具,却没有退出条件,任务一旦卡住,它就会一直调下去,直到配额烧完或者进程被杀。这种程序看起来能干活,实际不能交付。
更短的判据是:看谁决定下一步。固定脚本由代码决定,Agent 由模型决定。这条判据比“有没有用 LLM”可靠,因为脚本也能调用 LLM。在项目评审里遇到项目是否具备Agent属性的争议的时候,用这个判据,争论通常会很快收敛。
1.1.2 三个容易混淆的对象
日常讨论里,聊天机器人、工作流和 Agent 经常被混为一谈。用 1.1.1 末尾那条判据看,三者的差别不在界面,也不在是否联网。我们通过下面的表格来对比三者之间的差异:
| 对象 | 控制权 | 状态存放 | 典型交付 |
|---|---|---|---|
| 聊天机器人 | 人 | 单轮对话,少量上下文 | 一段文字 |
| 工作流 | 代码 | 流程变量与数据库 | 固定格式的结果 |
| Agent | 模型,代码划边界 | 完整执行轨迹 | 经过校验的任务结果 |
客服问答机器人属于第一类。你问他一个问题,他给你一个答案,会话结束就清空,就算背后接了检索和知识库,路径仍然是固定的。用户问什么,它就查什么,不会自己换一种查法。
报销审批属于第二类。先提交,再审核,最后打款,每一步都由代码写死。流程跑一万次,走法还是那条走法。这类系统的优势是稳定,代价是遇到例外只能挂起等人工。
修一个线上缺陷更接近第三类。先看日志,再定位文件,改完跑测试,失败就回去再改,下一步取决于上一步看到了什么,没人能提前把步骤写完。也正因为路径不固定,它才需要模型来判断。
还有两类系统常被误认。这两类系统是:流程自动化操作界面很灵活,但分支是设计时写死的,属于工作流。代码补全工具会生成整段代码,可采不采纳由人决定,控制权还在人手里,属于单轮生成工具这一类,聊天机器人也在其中。
“会调用工具”不是分界线。持续集成流水线也会调用十几个工具,我们不会因此叫它 Agent。真正的区别是路径有没有被预先写死。
1.1.3 一个最小可运行的循环
前面我们花费了大量的介绍了相关的概念,但是概念说到这里还是抽象的,下面这段代码把四个条件(下称四件套)凑齐,只用标准库,复制到一个空目录就能跑。
环境要求:Python 3.10 及以上,不需要安装第三方包。你把它保存为
mini_agent.py,执行python3 mini_agent.py。
python
import tempfile
from pathlib import Path
WORKDIR = Path(tempfile.mkdtemp(prefix="mini_agent_"))
(WORKDIR / "a.txt").write_text("3\n5\n", encoding="utf-8")
(WORKDIR / "b.txt").write_text("7\n", encoding="utf-8")
TOOLS = {
"list_files": lambda: sorted(p.name for p in WORKDIR.glob("*.txt")),
"read_file": lambda name: (WORKDIR / name).read_text(encoding="utf-8"),
}
def decide(task, step, history):
"""占位策略:真实项目里,这里换成一次 LLM 调用。"""
if step == 0:
if "数字" not in task:
return {"final": "任务不在支持范围内"}
return {"tool": "list_files", "args": {}}
files = history[0]["observation"]
done = [h["args"].get("name") for h in history if h["tool"] == "read_file"]
for name in files:
if name not in done:
return {"tool": "read_file", "args": {"name": name}}
total = sum(
int(x)
for h in history
if h["tool"] == "read_file"
for x in h["observation"].split()
)
return {"final": f"共 {len(files)} 个文件,数字总和为 {total}"}
def run(task, max_steps=8):
history = []
for step in range(max_steps):
action = decide(task, step, history)
if "final" in action:
return action["final"], history
name = action["tool"]
if name not in TOOLS:
raise ValueError(f"未授权的工具:{name}")
observation = TOOLS[name](**action["args"])
history.append({"tool": name, "args": action["args"], "observation": observation})
raise RuntimeError(f"超过 {max_steps} 步仍未完成,终止")
if __name__ == "__main__":
answer, trace = run("统计目录里所有 txt 的数字总和")
print(answer)
for i, item in enumerate(trace, 1):
print(i, item["tool"], item["args"])输出如下。
text
共 2 个文件,数字总和为 15
1 list_files {}
2 read_file {'name': 'a.txt'}
3 read_file {'name': 'b.txt'}这段代码有五十多行,但集齐了 Agent 所必需的四个条件。TOOLS 是工具,history 是上下文,run 里的 for 是循环。decide 是推理核心的替身。
这段代码执行的是一条轨迹:列目录,读第一个文件,读第二个文件,最后汇总,三次工具调用都由同一段循环驱动。每一步的输入都包含前面所有动作和结果,这就是上下文在起作用。没有 history,第三步不可能知道已经读过哪些文件。
这里用脚本代替模型,是为了让例子离线可跑。这个例子用来演示一个基本的流程,但是并不能证明模型的推理,模型推理能力接入,在本书第二章有介绍。但是,如果你想亲手在这里验证,可以把代码里 write_text 写入的数字改掉再跑一次。输出会跟着变。这种“策略与执行分离”的结构,也是 Agent 能换模型、换工具而不重写流程的原因。
真实项目里,把 decide 换成一次 LLM 调用,循环骨架不用动,但要补三件事:
- 1.结构化输出校验、
- 2.工具调用的参数校验、
- 3.
history裁剪与去重。输入仍是任务和history,输出是结构化的动作。
注意:把
max_steps设得过大,或写成while True且没有退出条件,循环不会及时退出,进程会持续消耗模型调用配额。
工具白名单同样不能省,代码里用 TOOLS 字典做了限制,模型只能调用已注册的函数。其余几条工程约束怎么分工,1.1.5 会一次说清。
四件套到这里已经齐了:推理核心、上下文、工具、循环。接下来该看它们各自在系统里的位置,以及维持这套位置关系要付出的代价。
1.1.4 依赖与分工
Agent 和 LLM 是什么关系?一句话,单向依赖加分工。LLM 提供单步判断,Agent 提供多步组织。
没有 LLM,Agent 会退回规则系统,能做的事和传统工作流差不多;没有 Agent 这层外壳,LLM 无法自主多步推进,也无法持续接触外部系统。
举个具体的例子。让模型一次写出某个模块的改造方案,它只能凭上下文猜现状。换成 Agent,它可以先读代码、再跑测试、失败后重试,交付物因此更接近可合并的补丁(这是经验判断,不是基准结论)。二者的差别不在能力,而在有没有拿到现场信息。
一次问答只调用一次模型。一个十步循环至少调用十次。成本随步数增长,时延也随步数增长。这笔成本账必须在设计阶段就算清楚。这是 Agent 与聊天机器人最现实的一条差别。
算一笔粗账。假设每一步都把 8000 个 Token 的上下文窗口送进模型,走十步至少是 80000 输入 Token。同一件事如果一次问答能解决,成本只有 8000 输入 Token(未计输出 Token 与重复的系统提示);但一次问答也拿不到同样的现场信息,这个对比只说明量级。多出来的部分,买的是试错和校验。通过上面的统计数,从某种意义上可以认为,Agent 是用时间和空间的双重交换来获取更加智能的过程和正确的执行结果。这个归根结底算是成本问题,后续章节会有仔细的讨论。
所以“高效”不能理解成“模型更聪明”。它更像一道组织题:用更少的步数拿到更高的成功率,同时把 Token 成本压住。
我们在项目里看三个数:任务成功率、单任务 Token 消耗、端到端时延。三个数一起看,才知道一个 Agent 是真能干,还是只是话多。
三个数先看哪个,取决于当前瓶颈在哪。模型决定单步的上限,工程决定能不能稳定接近这个上限,两者缺一不可。方向不难判断:工具描述越清楚,成功率越高;上下文窗口越长,成本越高;链路越长,时延越高。
1.1.5 定义的适用边界
最后要说清 Agent 不是什么。它不是能替人背责的全自动员工。
目标由人给,验收标准也由人定。Agent 能做的是把中间那段重复劳动接过去,并且把过程留下来,供人检查。读者在评估一个 Agent 产品时,也可以先问两个问题:目标是谁定的,失败时谁负责。
还有一个常被忽略的成本:验收。一次问答的结果,读者读一遍就能判断。Agent 交来的是十步轨迹,人要核对每一步的输入输出,按我们的经验,验收时间可能比执行时间还长。所以流程设计里要留出检查点,不能等最后一步才看。
边界不止在验收,还有工程边界。1.1.3 的演示只保证最小循环能转,真实系统还要管住上下文、工具和写操作。
上下文窗口会不断变长。十步之后,history 里堆着工具返回的原文,很容易撑爆上下文窗口。所以生产级 Agent 都要做裁剪,比如只保留最近几步,或者把旧结果压成摘要。这一步做不好,后面每一步都在为无关信息付费。裁剪策略要提前定。
工具描述也会影响结果。名字含糊、参数缺失的函数,模型很容易传错值。把用途、参数类型和失败返回写清楚,通常比反复改 Prompt 更省事。
白名单不能只写在文档里。少了代码里那层限制,模型可以要求执行任意命令,在裸机上等于交出主机控制权;有沙箱或容器时风险降一档,但白名单仍然不能省。
写操作还要单独处理。读文件失败可以重试,发消息、转账这类动作重试会重复执行。常见做法是给每次调用带一个幂等键,让服务端识别重复请求。这个细节在演示里基本看不见,上线后却容易出事。
常见的失败有三类,各对应一项约束设计。
模型调用不存在的工具,多半是接口描述不清,对应工具白名单,代码里已经实现。
模型反复执行同一个动作,属于状态没有推进,对应循环检测,这一步还需要自己补上;max_steps 只能兜住步数上限,不能识别重复动作。
模型提前宣布完成,属于缺少结果校验,对应退出条件,final 之前的检查同样待补。
三类问题都不靠换一个更强的模型解决,靠的是外层的约束设计。
这也是本书后面反复要用的视角:先看边界,再看能力。边界不清的系统,能力越强,出错时的代价通常越高。
Agent 的四件套不是一天长齐的,是逐层长出来的。下一节把这些层按时间排一遍。
1.2 Agent 编年史
上一节我们拆过 Agent 的四个部件:推理核心、上下文(Context)、工具、循环(Loop),这四者构成了后续所有架构的基础。清单很清楚,装回去却千差万别。
同一套部件,2023 年装出来是玩具,2026 年装出来能交付工程。差别不在模型参数,而在控制权(谁决定下一步、谁判定完成)放在谁手里,以及这份控制权什么时候被收回。
Agent 的演进因此可以看成一条收敛曲线。一端是非确定性的模型推理,另一端是可验收的工程交付,中间隔着一整套工程约束。
每次跃迁都在回答同一个问题。哪些事交给模型,哪些事必须写死,答案决定了架构形态,也决定了失败时能不能定位。
本节先纵向排时间,看五个阶段怎么接力;再横向比控制权,看四种架构怎么分摊失败代价。
1.2.1 Agent 演进的五个阶段
把 2023 年以来的公开项目按控制方式排一遍,可以得到五个阶段。这是本书的归纳,不是穷举统计。划分依据不是模型版本,而是谁来决定下一步。
1.2.1.1 赛博玩具阶段(2023 年)
2023 年春,AutoGPT 与 BabyAGI 在 GitHub 开源。它们把 ReAct 模式包成一个循环:模型想一步,调一个工具,看一次结果,然后进入下一轮。
ReAct 的思路来自 Yao 等人 2022 年的论文。核心是把推理轨迹与动作交替写进上下文,让模型边想边做,不必一次给出完整计划。
这套循环能跑通演示,却跑不完任务。原因很具体:没有持久状态,没有步骤预算,没有失败判定,更没有退出条件。
模型一旦重复同一个动作,循环就会一直转,直到耗尽 Token 或被人手动停掉。
任务一长,错误累积,上下文膨胀,模型开始忘记最初目标。玩具阶段的遗产不是产品,而是那个被验证过的最小循环。
它证明了一件事:模型可以自己决定下一步。这份控制权后来被一层层收回,收回的过程就是后面四个阶段。
1.2.1.2 图态控制流阶段(2023 年末至 2024 年中)
2023 年秋,微软开源 AutoGen,用代码编排多 Agent 对话;固定工作流模式下控制流落在代码里,GroupChat 模式则允许模型选下一个发言者。这类把执行路径写成图、并把控制流显式写进代码的做法,本书统称图态控制流。
2024 年 1 月,LangGraph 发布。它把执行路径画成一张图,节点是步骤,边是条件跳转,状态存在图外,图本身还能纳入版本管理。
两条路径做法不同,方向一致,都是把不确定性挤到节点内部:控制流从 Prompt 里搬进代码。
分支、并行、重试、人工审批,都变成图上的边。模型只负责节点内部的生成,不再决定下一步去哪。
LangGraph 的检查点让长任务可以暂停再恢复。状态落在外部存储里,进程重启也不会丢,这一步对生产环境很关键。
代价是灵活性。路径写死之后,遇到图外的情况就卡住,改一次流程就要改一次图。收益是可控性,每一步都能被记录、中断、重放。
这一阶段解决的是逻辑断层。模型仍然会犯错,但只要状态写入受控、每个节点有独立校验,错误就只停在单个节点内,不会扩散成整条链路的失控,排障时能直接定位到节点。
1.2.1.3 协议与感知标准化阶段(2024 年下半年至 2025 年上半年)
2024 年 10 月,Anthropic 开放 Computer Use 测试。一个月后,它发布模型上下文协议 MCP(Model Context Protocol),一个跨框架的工具接口标准。
两件事指向同一个方向。让 Agent 接触外部世界的方式标准化,从工具调用一直到屏幕操作。
在此之前,每个框架都有自己的工具描述格式。换一个框架,工具要重写一遍,权限也要重配一遍,接入成本随框架数量线性增长。
MCP 把工具、资源与提示模板抽象成统一接口。服务端实现一次,多个客户端复用,传输层可以走标准输入,也可以走 HTTP,MCP Server 与 MCP Client 的职责就此分开。
Computer Use 把感知推到屏幕层。Agent 不只会调 API,还能看截图、点按钮、敲键盘,操作系统的界面成了新的工具面。
接口标准化降低接入成本,感知下探扩大可操作范围。两条主线合起来,Agent 的能力边界向外扩了一圈,攻击面也随之扩大。
注意:MCP 服务端的工具描述会直接进入模型上下文,第三方服务写得含糊,会导致模型选错工具并传错参数。
在这期间,其他巨头也没有闲着,继续通过协议层进行补位。2025 年 4 月,Google 发布 A2A(Agent2Agent)协议,处理跨厂商 Agent 之间的任务交接。
由此形成了MCP 管工具,A2A 管协作,分工逐渐清晰的初始架构。但是,协议只定义怎么说话,不保证对方听得懂,这仍是当前的短板,互操作测试的成本很高。
1.2.1.4 循环工程阶段(2025 年中至 2026 年初)
2025 年,Claude Code 从预览走向正式发布。以 Claude Code 为代表的编码 Agent 把校验循环做进产品,循环工程(Loop Engineering,本书用语)由此成形,交付方式随之改变,校验器成了产品的一部分。
核心变化只有一句话。完成由检查说了算,不由模型自己说了算。
典型循环是四步:执行、校验、捕获错误、带着错误重来。校验器可以是单元测试、类型检查、Schema 校验,也可以是一个退出码,只要它能给出通过或不通过。
模型在循环里只做局部修补。它拿到的是错误信息,不是整份需求,上下文因此收窄,修复也更准。
这一步把不确定性关进了笼子。交付判据由校验器给出,不再靠模型的自我评价;但校验通过率不等于任务成功率。
指标要先看分母:任务成功率的分母是全部任务,校验通过率的分母是能写成校验的那部分任务,两者的含义完全不同。
长任务还带来一个新问题:副作用。改错文件、发错消息、扣错款,都不能靠重试解决,重试只会把错误放大。
Saga 事务的思路被引进来。每个动作配一个补偿动作,失败时按逆序回滚,这一层在 2025 年之后开始出现在部分长任务系统中。
注意:校验器本身有假阳性时,循环会在错误的方向上反复修补,任务耗时可能翻倍,最终无法交付。
这套结构也有边界。闭环指有校验反馈,开环指没有校验反馈;目标写不成校验时,自动闭环失效,退回人工验收。
写作、设计、战略判断都属于这一类。它们的完成标准藏在人的判断里,短期看不到可执行的校验器,只能做过程约束。
1.2.1.5 多 Agent 编排阶段(2026 年至今)
从公开讨论看,2026 年起讨论重心从单个 Agent 转到多 Agent 系统(Agent 团队)。任务常被拆成有向无环图(DAG)或其他依赖图,不同角色的 Agent 并行执行。
这类编排里的异构,指不同模型、不同框架、不同职责的 Agent 混编在同一条任务链上。
编排层(负责调度)负责顺序、预算与上下文隔离。关键不在 Agent 数量,而在边界是否清楚。
每个 Agent 拿到的上下文要收窄,产出要可验收,失败要能定位到具体节点。否则多一个 Agent,只多一份噪音。这个阶段还没有定型,下面的描述是归纳,不是定论。
五个阶段排完,把控制权的分布并排放在一起,就是下一节的四种架构。
1.2.2 控制权的迁移路径
为了控制Agent的执行过程,目前业界发明了四种控制流程:
- 传统工作流
- 开环 Agent
- 循环工程 Agent
- 多 Agent 编排
这是四种控制流程各不相同,把同一个任务放进四种架构,控制权的分布完全不同。这不是能力之争,而是失败代价的分摊方式不同。Agent的发展过程同时也是任务对结果控制权变更的过程。
1.2.2.1 四种架构的控制权分布
先看分类轴:1.2.1 按时间切分五个阶段,这一节按控制权切分四种架构。五阶段里的图态控制流,放到控制权轴上就是传统工作流。
| 架构 | 谁决定下一步 | 适应性 | 确定性 | 适用任务 |
|---|---|---|---|---|
| 传统工作流 | 代码 | 低 | 高 | 规则稳定的业务 |
| 开环 Agent | 模型 | 高 | 低 | 探索与演示 |
| 循环工程 Agent | 人定边界,模型局部决策 | 中高 | 中高 | 可验收的工程任务 |
| 多 Agent 编排 | 编排层定边界 | 高 | 中高 | 长链路多角色任务 |
传统工作流的确定性来自枚举。在枚举到的分支内,覆盖率就是确定性,规则覆盖不到的地方就是盲区,盲区只能靠人工兜底。
弱点同样直接。没写到的分支一律不处理,业务一变就要改代码,响应速度跟不上。
开环 Agent 反过来。它把控制权全交给模型,在规则未定的场景里适应性最强,代价是无法保证结果,也说不清结果为什么对。
它的问题不是一定失败,而是失败了自己不知道,还会把错误结果当成完成交付出去。
循环工程做的是分层。人定有限状态机(FSM)、验收标准与预算,模型负责节点内的生成与修补。
控制权没有回到人手里。它被拆成两层,一层管边界,一层管内容,责任因此可分。
1.2.2.2 闭环判断的可复现实验
1.2.1.4 的判断是:完成由检查说了算。下面的代码把这个判断做成可复现实验,把两种循环放在一起跑。环境是 Python 3.10 以上,只用标准库,不需要 API Key。
模型用随机函数模拟,便于复现,读者可以自己跑一遍。真实系统里换成模型调用,外层结构不变。
python
# loop_demo.py
# 运行环境:Python 3.10+,无第三方依赖
# 运行方式:python3 loop_demo.py
import random
GOAL = 42
BUDGET = 8
SEED = 5
def model(total: int, rng: random.Random) -> int:
"""模拟模型:一半概率给出精确修正量,一半给出随机小步。"""
if rng.random() < 0.5:
return GOAL - total
return rng.choice([-3, -1, 1, 3])
def open_loop() -> int:
rng = random.Random(SEED)
total = 0
for _ in range(BUDGET):
total += model(total, rng)
return total # 没有检查,直接当成结果
def closed_loop() -> tuple[int, int]:
rng = random.Random(SEED)
total = 0
for used in range(1, BUDGET + 1):
total += model(total, rng)
if total == GOAL: # 校验器:目标本身可判定
return total, used
raise RuntimeError(f"预算用尽,最后一次结果 {total}")
if __name__ == "__main__":
print("open :", open_loop())
print("closed:", closed_loop())我们跑了一次,开环停在 41,闭环在第五步命中 42,这是同一随机序列下的结果。开环会把 41 当成答案交出去,闭环会告诉你它用了五步。
差别不在运气,而在有没有校验。把 total == GOAL 换成单元测试、类型检查或 Schema 校验,结构完全一样。
1.2.2.3 选型与代价
闭环的适用边界已在 1.2.1.4 说明:目标写不成校验,自动闭环失效,退回人工验收。
多 Agent 编排把这条线再往上推一层。
单个 Agent 内部仍然是循环工程。控制权被拆成三层:编排、状态机、模型。
层级越多,定位越难。一条链路跑失败,要先判断是任务拆错了、上下文给少了,还是某个节点的校验没写。
这也是多 Agent 系统当前的主要成本。能力上限提高了,排障成本同样提高了。
读者在选型时,要同时算这两笔账。只看能力不看排障,上线之后会付出更高的代价。
我们在工程任务里默认选闭环,在探索任务里保留开环。理由不是闭环更先进,而是前者的失败可以定位,后者的失败只能靠运气复现。
编年史到这里可以收束。Agent 的历史,不只是模型越来越强的历史,而是控制权不断重新分配的历史。
每一次分配,都换来更高的确定性,也付出更多的工程成本。下一个阶段到来时,这条规律大概率还会成立,只是控制权的分配比例会变。
1.3 Agent 的应用现状
上一节我们把 Agent 的演进拆成了五个阶段,那是一条时间线,不是一张现状图。这一节换一个角度,看这些能力在真实产业里落地到了哪一步。
如果我们只看新闻,容易走到两个极端。一边说 Agent 要接管一切,一边说全是 Demo,两种说法都能找到例子,问题出在观察尺度,而不是证据数量。
其实我们问自己三个问题来回答Agent应用的现状。这个三个问题是:历史走到了哪一步,产业交付到了哪一步,技术上还差什么。
但是如果我们用单一视角来回答这三个问题,那么对Agent现状的理解难免有些偏颇,所以这里我们采用不用的视角回答这三个问题。这三个视角的我们用了一个形象的比喻:望远镜,放大镜,显微镜。
1.3.1 望远镜视角的 Agent
望远镜只看两个事实:生产主体有没有变,变化铺开了没有。
先说第一个。
工业革命的标志是用机器制造机器,这一次的标志是用程序创造程序。这两句话结构相同,指向的生产方式不同。这句话听起来像口号,但它描述的是一件很具体的事。在 Agent 之前,代码由人一行行写出来,模型只负责补全下一行。Agent 把写、跑、看结果、再改连成一个循环,循环里的每一步都可以由模型发起。这个循环一旦稳定,代码的生产者就不再只有人。
这个变化有多大,看两个数字。
- 微软在 2024 年 4 月的 FY24 Q3 财报电话会上披露,GitHub Copilot 的付费订阅超过 180 万,覆盖 7.7 万个组织,渗透发生在日常工位。
- Stack Overflow 2024 年的开发者调查里,76% 的受访者已经使用或计划使用 AI 编程工具。
数字说明工具进了工位,不说明交付变好了。使用率和交付率是两回事。
判断交付有没有变好,看的是评审负担、返工率和维护成本,不是采用率。补全出来的代码能跑,但没人说得清为什么这样写。一两个季度后原作者离职,这段代码就成了黑盒。这类代码随后就会成为维护成本(经验判断,不是统计)。
所以望远镜看到的第一个事实,是生产主体变了:过去是人写比特,现在是人定目标、模型写比特、循环做校验。
第二个事实,是变化还停在局部。
制造业的机器制造机器用了一百多年才铺开,程序创造程序也不会例外。目前稳定成立的环节并不多。代码补全、单测生成、重构、脚本编写、日志排查,这些环节的反馈快,错了能立刻发现。我们更看重反馈周期:周期越短,Agent 越可靠。
这也是 Agent 在软件行业最先站住脚的原因。跨十几个微服务、牵扯历史数据和审批流程的任务,仍然要人盯着。
判断边界比判断趋势更重要。这也是我们看现状时最在意的一条。
但是望远镜里面我们也看到一个事实,Agent的迭代速度空前的迅速。因为机器制造机器,操作机器的还是人,人就特定的生物钟周期,比如要吃饭,要睡觉,有情绪。但是Agent没有这些,所以速度可能会超乎想象的快。
1.3.2 放大镜视角的 Agent
把镜头拉到产业一线,Agent 的交付形态已经变了。它不再只是一个聊天框,开始出现在 IDE、终端、工单系统和运维平台里。
下面按代码、客服、运维的顺序看三个落点。每个落点看同一组问题:交付物是什么,怎么计价,责任边界在哪。这三个落点不是行业全集,只取代码、客服、运维三类代表场景。
第一个落点是代码。
Claude Code 在终端里读写仓库,Cursor 把编辑器和模型绑在一起,GitHub Copilot 把补全扩到 PR 评审,三家都在抢同一个入口。
这些产品的共同点不是会聊天,是能改文件、能跑命令、能看测试结果。工具能力比对话能力更重要,这一点决定了它们能不能进生产。交付物是可直接合入的代码,计价分三种:GitHub Copilot 按席位、Cursor 按订阅、Claude Code 按用量;卡点在责任边界:代码进了主干,出了问题要有人签字、有人回滚。
第二个落点是客服与销售。 Salesforce 在 2024 年推出 Agentforce,把 Agent 放进 CRM 的工单流,直接接在客户数据上,回答能引用订单和账单。
Intercom 的 Fin 接在在线客服入口,先答,答不了再转人工。它们卖的不是模型,是一个工位的工作量。
单价可以直接对比。Agentforce 按对话计费,每次 2 美元起,卖的是结果,不是 Token;此处只列 Agent 侧单价,便于读者自行对照。交付物是一次可结单的答复,计价按对话;卡点在数据:答案要引用订单和账单,企业知识散在多个系统里,检索质量决定上限。
第三个落点是运维和数据管道。
告警进来,Agent 先查日志、比对最近变更、给出处置建议,再决定要不要升级给人。这条链路的价值不在全自动,在于把平均响应时间压下来。交付物是一份处置建议,计价按平台和工单量;卡点在流程:自动化的边界往往就是责任边界,审批和升级越靠近生产系统越难绕开。
这些落点背后,是 1.2 已述的工具协议与编排能力,本节不重复。
能力曲线也确实在涨:2024 年 10 月到 2025 年 5 月,Claude 3.5 Sonnet 到 Opus 4 在 SWE-bench Verified 上从 49.0% 升到 72.5%。
这是跨模型档位对比,含规格提升,分数为厂商自报。
产业侧是另一类证据:看懂能力曲线只需要看榜单,看懂产业落地要进企业。
注意:把基准分数直接当成生产能力,会导致项目排期和验收标准同时失真。
Gartner 在 2025 年 6 月 25 日的新闻稿中预测:到 2027 年底,超过 40% 的智能体式 AI(Agentic AI)项目会被取消。 这不是唱衰,是提醒。它给的理由是成本失控、价值说不清、风险控制不到位。同年 7 月,METR 做了一次随机对照试验,测的是真实开发效率。
16 名资深开源开发者在自己熟悉的仓库里完成真实 issue,用 AI 工具的一组反而慢了 19%。他们自己以为快了 20%。样本只有 16 人,任务也集中在代码修复,但方向值得重视。效率工具的收益,未必等于任务吞吐的收益。
把能力曲线和产业侧的证据放在一起,结论很清楚:单点交付已经成立,规模化落地卡在流程、数据和责任边界上。但单点交付不等于可托付。 窄任务能交付,端到端任务还差得远。2024 年 3 月,Devin 发布时,在 SWE-bench 原始测试集的随机 25% 子集上给出 13.86% 的无辅助解决率(与 SWE-bench Verified 榜分数不可直接比较)。这个差距要靠工程补。
演示视频和实际能力之间的差距,成了那一年的公共话题。这不是个例,是行业常态。
规模化的阻力可以拆成三件事,和三个落点对上。
- 代码落点撞上的是责任问题:模型改错了生产库,损失算谁的。
- 客服落点撞上的是数据问题:企业知识散在多个系统里,检索质量决定上限。
- 运维落点撞上的是流程问题:Agent 干完的活谁来签字。
这三个问题不解决,采购预算就会停在试点。
注意:在没有回滚方案和审计日志的系统里直接放开写权限,会导致故障无法定位、数据无法恢复。
1.3.3 显微镜视角的 Agent
再把镜头推到技术层,Agent 的部件这两年基本配齐了。模型的 Tool Calling 成了标配,结构化输出有了约束,接口层开始收敛。
主流厂商开始支持 MCP,工具接入方式在收敛,上下文可以压缩、检索、落盘。 但是配齐不等于可靠。
下面只看三件事:可靠性、成本、上下文。
可靠性
演示看的是单次成功,生产看的是重复成功:这两个指标的差距可以用 pass^k 量出来。pass^k 的定义是:同一个任务独立跑 k 次,k 次全部成功的概率。k 等于 1 时它就是普通成功率。它和 pass@k 不同:pass@k 看 k 次里至少成功一次,pass^k 要求 k 次全部成功。k 变大时,它对不稳定特别敏感,这一点常被演示掩盖。读者如果只记一个指标,就记 pass^k。
下面这段代码只用标准库,可以直接运行。
环境只需要 Python 3.10 以上。 代码用的是无放回抽样下的无偏估计;k=1 时退化为 c/n。
python
# pass_k.py — 计算 pass^k。Python 3.10+,无第三方依赖
from math import comb
# 示例数据:3 个任务,每个跑 10 次,1 表示成功
TRIALS = [
[1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
]
def pass_hat_k(trials: list[list[int]], k: int) -> float:
if k <= 0:
raise ValueError("k must be positive")
scores = []
for runs in trials:
n = len(runs)
if n < k:
raise ValueError("runs shorter than k")
c = sum(runs)
scores.append(comb(c, k) / comb(n, k) if c >= k else 0.0)
return sum(scores) / len(scores)
if __name__ == "__main__":
for k in (1, 3, 5, 10):
print(f"pass^{k} = {pass_hat_k(TRIALS, k):.3f}")运行结果是四行数字。 pass^1 是 0.700,pass^3 是 0.308,pass^5 是 0.110,pass^10 是 0.000。 差距一目了然。
单次成功七成,连续 5 次全对只剩一成,这就是演示和生产的差距。可靠性不是小数点后的修饰,它决定任务能不能交付。
τ-bench 在 2024 年给出的结论方向一致。 当时最好的模型 GPT-4o 在两个领域的平均任务成功率不足 50%(零售 61.2%、航空 35.2%),而零售场景连续 8 次全对的 pass^8 掉到 25% 以下。
可靠性还要看得见,也就是可观测性(Observability)。执行轨迹(Trace)能记录每一步的输入输出,出了问题能回放。OpenTelemetry 在 2025 年推进 GenAI 语义约定(目前仍是实验性),执行轨迹开始有一套可对齐的字段。没有这些,pass^k 掉下来时只能猜原因。
可靠性还有一个风险源:Agent 开始参与造 Agent。 GitHub Copilot 写单测,Claude Code 改脚手架,代码审查也交给模型先过一遍,人的角色退到验收。
这些事是真的,但它们是人在监督下的自我修改,不是自主进化。 把监督拿掉,出错概率会明显上升,这一点在长任务里尤其明显,pass^k 会掉得更快。
注意:把自动生成的代码直接合入主干而不经过测试和评审,会导致缺陷在后续迭代里成倍放大。
可靠性之外,还有成本。
成本 2023 年 GPT-4 每百万 Token 输入 30 美元、输出 60 美元,长任务光输入就烧得心疼。
三年过去,价格没有一路向下,而是分成了层。 2024 年 7 月,GPT-4o mini 把输入价压到 0.15 美元,比 GPT-4 低两个数量级。 2026 年 3 月,GPT-5.4 一代就摆出三档:输入 2.5、0.75、0.2 美元。
同一代里,最贵和最便宜的档位差十几倍。 更值得注意的是另一头,前沿档位在往回涨。 2026 年 4 月 GPT-5.5 输入 5 美元,9 月 GPT-6 Astra 是 10 美元,是 2024 年 GPT-4o 的四倍。
便宜的一端还在往下走。 2026 年 9 月 GPT-6 Luna 的输入价落在 0.1 美元上下,相对 GPT-4 差了两个数量级以上。 还有一个方向别忘了:输出比输入贵四到六倍,而 Agent 的输出从来不省钱。
算一笔账。 一个任务跑 20 轮,每轮带 2 万 Token 上下文,单任务就是 40 万 Token 输入。 按 GPT-4 的价格,光输入 12 美元;按 GPT-4o mini 是 0.06 美元;按 GPT-6 Luna 是 0.02 到 0.04 美元。 同样这 40 万 Token,换 2026 年的前沿档位:GPT-5.5 是 2 美元,GPT-6 Astra 是 4 美元。
同一件事,账从 4 美元跨到 0.04 美元,差了一百倍。 差的是档位,不是任务难度。 2023 年的问题是“用不起”,2026 年的问题是“用错档”。
一个跑通了却全程挂在前沿档上的 Agent,账单可能比它替人省下的工时还贵。 也正因为便宜档把长循环托住了,成本才从拦路虎变成一道选择题。
成本降下来,新的问题浮上来。 上下文压缩做得不好,前面读过的文件后面就忘了,轮次越多越明显,最后只能靠外部记忆兜底。
这也是上下文工程(Context Engineering)要处理的问题。 瓶颈从模型转到上下文。
把显微镜下的三件事放在一起,结论不乐观也不悲观。 部件齐了,可靠性(含可观测性)、成本、上下文仍是决定生死的三件事。
谁把这三件事做扎实,谁的 Agent 才能从 Demo 走到生产。
回到开头的三个问题。
望远镜看到的是:生产主体变了,但变化还停在局部。 放大镜看到的是:单点交付已经成立,规模化卡在流程、数据和责任边界上。 显微镜看到的是:部件配齐了,可靠性、成本、上下文还差火候。
所以两个极端都不对:既不是接管一切,也不是全是 Demo;单点已成立,规模化未成立。
看清现状之后,下一个问题更值得追问。 Agent 到底把什么改变了,又把谁推到了台前。
1.4 Agent 带来的变化与冲击
1.3 节我们看了 Agent 已经落到哪些场景。接下来要回答一个更贴身的问题:这些落地到底改变了什么,又把谁推到了台前。答案不在新闻标题里,而在两处:一是每天的工作流程,二是每个人的考核表。本节分别展开:工作流程对应任务怎么被拆开、岗位怎么被重组;考核表对应什么能力还值钱、人的心理怎么被搅动。
答案分两层。一层是生存层,也就是工作内容、岗位数量和分工方式;另一层是能力层,也就是经验的价格,以及由此产生的心理落差。冲击真实存在,但分布并不均匀。两层算完还要合起来看一次:合起来的结果是分工重排,体现在组织流程和个人动作上,这就是 1.4.3 要做的事。
1.4.1 Agent 带来的生存冲击
先给结论:冲击落在任务层,不落在整岗。要看清这一点,先看工作是怎么被拆开的。多数工程任务,都可以拆成五步:定义目标、准备上下文、生成方案、验证结果、集成上线。
Agent 主要压缩第二步和第三步。第一步、第四步和第五步没有被压缩或替代,其中第四步的评审按不变保守计。举个量级估算的假设案例:一个 12000 行的 Java 服务,有 40 个外部调用点要补重试与超时。
按传统做法,2 名工程师改 3 天。合计 6 人天。其中大半时间花在找调用点、抄模板、改参数上。
把这些交给 Agent 之后,生成 40 个补丁大约要 40 分钟。剩下的时间用于评审、补测试、处理边界,约 1.5 人天(按评审时间不变保守计)。总成本降到 1.6 人天左右,约四分之一(26%)。
五步里真正被压缩的是第二步和第三步:找调用点属于准备上下文,抄模板、改参数属于生成方案,现在由 Agent 一并完成。第一步(定义目标)和第五步(集成上线)都没有被压缩:前者要判断做不做、做到什么程度,后者要处理真实环境的兼容与回滚,两者都卡在人的判断和系统边界上;第四步的评审与测试则原样留在那 1.5 人天里。
这个结果说明两件事:
- 第一,按这个推演,提效可能是四分之一量级,不是几小时。
- 第二,省下来的是机械时间,不是判断时间。评审不能省。测试不能省。回滚方案也不能省。
注意:如果只提升生成速度,不提升评审与回滚能力,缺陷会从生成阶段写错,变成修改阶段改出新错,最终导致线上故障率上升。
生成阶段的成本取决于模型能力与上下文质量,评审阶段的成本取决于系统复杂度与责任边界。以我们接触的团队为例,前者下降得很快,后者变化不大。以上是有限观察,不是统计结论。所以越是核心系统,Agent 带来的总工期缩短越有限。
哪些任务最先被接走?判断标准先看两条:输入输出是否容易写清楚;验证成本是否低于生成成本。
- 输入输出固定、验收标准明确的任务,最先被接走,例如基础的增删改查(CRUD)、字段映射、格式转换、常规数据标注。
- 需要大量隐性上下文的任务,接走得慢,例如故障根因定位、跨团队接口谈判、合规边界判断。
- 验证成本高于生成成本的任务,即使能生成也未必划算,例如涉及资金与权限的核心链路。
任务边界清楚、测试覆盖充分的团队,可以把生成直接接进流水线,而任务边界模糊、测试靠人工点击的团队,生成得越快返工越多。
这也解释了为什么同一款工具,在不同团队里的效果差异很大。
任务层先看到这里,下面回到岗位层。
岗位不是一整块。它是一组任务的集合。Agent 吃掉其中标准化的部分,剩下的部分要么变少,要么变重:变少指的是编制收缩,变重指的是判断要求提高。
就我们在项目中观察到的情况而言,岗位数量上的表现通常不是集中裁员,而是不补缺:走一个少一个,新增名额转向评审、平台与治理。要核对这一点,看团队近两年的编制和招聘要求(JD),比看新闻标题可靠。
具体到岗位,变化通常不是整岗消失,而是职责拆分。一个前端工程师,页面搭建的比例下降。组件规范、状态管理、验收测试的比例上升。
一个运维工程师,手工操作的比例下降。故障预案、权限治理、成本分析的比例上升。
这套拆分逻辑不只适用于研发。客服、法务、财务共享中心里的岗位,只要任务能被写成清晰的输入输出,就会经历同样的重组。区别只在速度。
对读者来说,更值得关注的是任务结构,而不是岗位名称。同样叫后端工程师,有人每天写 CRUD,有人每天定位线上故障。前者被替换的速度,会明显快于后者。
所以“Agent 消灭了多少岗位”这个问题本身就问得不准,更准确的问法是:一个岗位里,有多少比例的任务可以被写进标准作业程序(Standard Operating Procedure,SOP)?这个比例越高,岗位被重组的压力越大。
1.4.2 Agent 带来的能力与心理冲击
生存冲击改变的是岗位。能力冲击改变的是经验的价格。过去,一个工程师的价值很大一部分来自记得住。
记得住 API 签名,记得住框架的默认行为,记得住某个报错对应哪一行配置。Agent 把这部分价值压得很低。查一次和生成一次的成本已经低到可以随手查、随手生成,记住本身不再构成壁垒。
但“经验归零”只说对了一半:被清零的是陈述性知识,也就是知道是什么。没有被清零的是程序性知识,也就是知道怎么判断、怎么验证、怎么取舍。
以 Spring 的 @Transactional 注解为例。知道在默认代理模式下,自调用会让事务注解失效,这是陈述性知识,Agent 一秒就能答出来。
真正的经验是另一回事。看到一段自调用代码,能判断这次调用是否经过代理对象(而不是 this 自调用)、是否会因此绕过事务、失败后数据会停在什么状态。后者需要读代码、跑用例、看日志。
这类知识为什么没有被清零?因为它的瓶颈不是记忆,而是验证。验证需要环境,需要数据,需要对失败的预判。Agent 可以给出十个假设,也能跑测试、读日志来验证执行;但确认哪一个成立、由谁担责,仍然要人来做。
再看一个更贴近日常的场景。代码评审时,Agent 可以在几分钟内指出空指针、并发竞争、边界条件。
这些意见有价值,但它们是概率性的。Agent 加速的是发现问题;哪些必须改,哪些可以放过,由谁担责,仍然取决于评审者对业务与风险的判断。
能力边界确实在扩张,但扩张有前提。
- 横向跨界(跨专业,走广度)的前提是你能写清验收标准,写不出验收标准,跨过去也只是多了一堆看不懂的代码。
- 纵向穿透(端到端,走深度)的前提是你能管住上下文。给少了 Agent 靠猜,给多了它抓不住重点。
- 这两个方向本质上都是工程能力,不是背几句 Prompt 模板就能获得的。
所以学习重点要换。背 API 的收益越来越低。把时间花在三件事上,回报更高:读懂现有系统、写清验收标准、设计可回滚的方案。
学习路径也要跟着换:先读一个真实项目的代码,再试着让 Agent 改一个小功能,最后自己写验收用例。三步走完,比看十篇教程更有用。
能力上的账算到这里。还有一笔账不在能力上,在心理上。
心理冲击来自比较。你花了十年记住的 API、写熟的模板代码,别人用 Agent 三天就绕过去了。这种失落是真实的,不需要被安慰。
但另一面也要看清。被绕过去的只是记住 API、写模板代码这类积累;判断力、担责和领域上下文并没有被绕过。Agent 降低的是入场成本,不是胜出成本。会用的人变多了,但能把事情做完、做对、做成可维护系统的人依然少。
所以希望不在于“一个人干完一个团队的活”:很多人会这样理解 Agent,但那是不准确的承诺。
希望在于另一件事:过去需要团队才能覆盖的环节,现在一个人可以串起来。串起来之后能走多远,取决于判断力,不取决于工具数量。
1.4.3 冲击之后的分工重排
先说回开头那个判断:冲击分布不均匀。任务层被压缩得最狠,岗位层被重组,能力层则是重新定价:陈述性知识贬值,程序性知识(判断与验证)升值。三块力度不同(把生存层拆成任务层与岗位层,再加能力层),方向却一致。
顺着这个方向看,真正变稀缺的东西换了位置:稀缺性从生成转移到定义与验证。生成变便宜了,定义问题和验证结果反而变贵了。
组织(含团队)层面的难点也随之明确:不是买工具,而是改流程。如果需求仍然靠口头传递,验收仍然靠人工点击,Agent 只能加快中间一段;前后两端不变,整体吞吐量提升有限。改流程通常要动三处:需求入口结构化、验收自动化、回滚预置。缺一个,增益就会被下游吃掉。下面三条是它在编制、招聘与个人工作台上的表现。
如果你所在的团队已经开始用 Agent 写代码,下面三条应该都不陌生。
编制在缩,评审环节在加人加规则。前面说的岗位重组,落到组织上就是这件事:小团队加一套自动化检查,可以覆盖过去更大的编制,但前提是检查真的能跑,而且能拦住问题。
招聘标准在移动:从会某个框架,转向能拆问题、能验收。面试里让候选人评审一段 Agent 生成的代码,比让他手写排序更有信息量。
个人工作台在成形:任务模板、上下文模板(Context Template)、验收清单、回滚方案,这四样东西决定你能否稳定复用 Agent。
团队层面,一个可操作的指标是:从提交到合并的时间,以及回滚率。
只看生成速度会高估收益。两个指标一起看,才能判断 Agent 是真的提效,还是把问题推到了下游。读者可以拿自己团队近三个月的数据算一遍。
个人层面,一个简单的自测方法是把自己一周的工作按小时记下来,标出哪些时间在生成,哪些时间在判断。生成占比越高,越需要尽快调整。
组织之外的个人层面,最实际的动作不是学更多工具,而是把任务重新分类。
- 哪些任务可以完整交给 Agent,自己只看结果?(可委派)
- 哪些任务必须自己拆解,只把执行交出去?(半委派)
- 哪些任务不能交,因为验证成本太高,或者责任无法转移?(不可委派)
分完这三类,你就知道自己该把时间花在哪里。判断力强的人会把时间集中在第二类和第三类上。判断力弱的人容易把时间花在挑工具上。
本节留下的不是一份工具清单,而是一张按可委派性(验证成本 + 责任可转移性)划分的任务清单:哪些任务交给 Agent,哪些任务自己拆,哪些任务不能交。
第 1 章到这里结束。我们讨论了 Agent 是什么、怎么来的、用在哪里、带来了什么冲击。
下一章换一种方式:不再讲趋势,直接装环境、跑第一个 Agent。只有亲手跑一遍,前面这些判断才会变成你自己的。