Skip to content

第10章 Agent的未来 ​

面对 Agent 的到来,我们已经无法回避,唯一的选择是主动接纳。

前面几章,我们聊了技术、聊了架构、聊了实战案例,也讨论了个人如何打破瓶颈。但如果把视角拉长,Agent 带来的绝不仅是一个好用的工具,而是一场对个人与社会的深层重构。

过去 20 年,我们习惯了用“堆时间、积经验、练手艺”的方式建立个人护城河;但今天,Agent 正在以极低成本平现这些传统优势。如果你的工作介质是比特,你的经验可能在一夜之间被算法抹平。

面对这种巨变,真正有效的应对不是恐慌,而是重构:重构你的知识体系,重构你的思维模型,重整你的工作方法论。

10.1 对个人的改变:知识的重构与能力重组 ​

先把结论放在前面:Agent 来了,躲不开,只能主动接纳。但接纳不是装几个新工具,而是把自己重新组织一遍,让知识、能力和工作方式都跟着换一套结构。

同样一套模型,有人用它把一周的活压到半天,有人只拿到一篇漂亮的废话。差别不只在提示词(Prompt),更在手里的两件事:知识能不能被调用,能力有没有站到正确的位置。本节就讲这两件事:知识重构,把知识变成 Agent 执行得了的资产;能力重组,把精力从执行移到定义、裁决和编排。

10.1.1 知识重构 ​

我们每天都会往文档里丢东西,会议纪要、旧方案、聊天记录、临时笔记,几年下来能攒出几百个文件。这些东西对人没有太大伤害,因为人读的时候会跳过废话,看到矛盾也会自己判断哪条更可信。

模型不会这样过滤,它倾向于把上下文里的陈述当成可用前提。上下文里如果有两条互相打架的规则,它会按概率挑一条,这次挑 A,下次挑 B。

同一个问题,两次答案不一样,你还很难查出原因。排查半天,最后发现是知识库里躺着一条三年前的旧流程。这也是幻觉(Hallucination)最常见的来源之一,模型没有编造,它只是把互相矛盾的输入各信了一半。

除了不稳定,污染还有成本。一条模糊规则会占掉几十个 Token,一百条就是几千个。一份 30 页的会议纪要约 1.5 万汉字(每页按 500 字估)。1 个汉字约合 1–1.5 个 Token(视分词器),直接塞进上下文就是 1.5 万到 2 万多个 Token。

上下文被噪音填满,真正关键的信息反而被挤到角落。模型注意力是有限资源,你给它什么,它就优先看什么。

所以顺序不能反。先整理知识,再谈工具。知识不整理,Agent 只是把混乱放大,而且放大得很快。

本小节分两块。存量清洗:去噪、结构化、标准化、分层,把已经躺在文档里的东西洗成可执行的规则;增量萃取:双向提纯与经验萃取,把人和模型的新判断持续写回资产。维护跟着规则卡一起讲,见结构化那节末尾。

存量清洗(四步)

去噪:删掉不能执行的句子 ​

去噪只管删,不改写;改写归结构化。删的标准不是长短,而是这句话能不能回答:在什么条件下做什么。

比如“大家要注意发布的稳定性”,它没有条件,没有动作,也没有验收标准。删掉,换成“发布前必须跑完回归用例,失败则回滚”。

前者只能被点头,后者能被执行,而知识库需要的是后者。一句话能不能变成动作,是判断噪音最省事的尺子。

常见的噪音有三类:过期信息,三年前的流程还挂在首页;重复信息,同一个规则在五个文件里各写一遍;没有边界的口号,听起来正确,落地时却无法判断。去噪不要追求一次到位,建议分三轮:第一轮删过期信息,第二轮处理重复信息和口号,第三轮收尾。剩下需要改写的表述交给结构化。规模小可以两轮,规模大可以加轮次。每轮只做一件事,判断成本最低。

去噪可以先做一轮机器扫描,把明显的模糊表述和旧年份标出来,范围是 knowledge/ 目录及其子目录下的 Markdown 文件。机器只做粗筛,不替代判据。

结构化:把散文改成可判定的分支 ​

去噪之后,剩下的内容还是散文,而散文适合人读,不适合模型执行。人能从上下文里补齐缺失的主语和条件,模型也会补,但它补出来的东西不一定是你想要的。

结构化的目标,是把一段描述变成可判定的分支。条件、动作、理由(because)三样写清楚,模型就不需要猜。

拿发布回滚举例。散文版是“发布后如果错误率明显上升,要及时回滚,避免影响扩大”。这句话里,“明显上升”和“及时”都没有数值,不同的人会理解成不同的阈值。

改成规则卡,歧义就消失了:

json
{
  "id": "release.rollback",
  "when": "发布后 10 分钟内错误率超过 1%",
  "then": "回滚到上一个稳定版本",
  "because": "错误率继续上升会扩大影响面",
  "owner": "值班工程师",
  "updated_at": "2026-10-30"
}

这张卡可以直接拼进 System Prompt,也可以作为知识库的一条记录。模板字段固定,另可按维护规则扩展,模型读到的边界更清楚、歧义更小。

规则卡不需要复杂,一张卡只回答一件事,条件里带数值,动作里带对象。写不出来,通常说明这件事还没想清楚,先别急着交给 Agent。

规则卡还有一个好处:可测试。每条规则都能对应一个测试用例,条件满足时动作是否触发,跑一遍就知道。散文做不到这一点,只能靠人反复读。

规则卡写完不是结束,它和代码一样会过期。没有维护机制,半年后知识库又会回到一团乱麻。

规则卡的模板字段是 id、when、then、because、owner、updated_at,已经覆盖了负责人和更新日期。维护时在模板六字段之外,另加两个扩展字段:适用版本,用来避免新系统沿用旧约束;失败案例,用来记录这条规则踩过的坑,让规则卡从一句结论变成一份可追溯的证据。每次 Agent 因为这条规则出错,就把案例追加进去。

维护频率不用太高,每月一次就够。重点不是写得多漂亮,而是让知识库里的每一条都能被信任。

标准化:统一术语和单位 ​

结构化管的是形状,条件、动作、理由;标准化管的是命名与量纲,两者不重叠。同一个概念,团队里往往有好几种叫法,有人说 Agent,有人说智能体,有人说机器人。人听得懂,模型也能猜,但猜就有偏差,偏差会在长链路里累积。

标准化的做法不复杂。维护一份术语表,规定每个词的标准写法,第一次出现时给中英对照。

比如本书统一写 Agent,首次出现给“智能体(Agent)”。统一写 Token,鉴权语境才写“令牌”。统一写 Prompt,首次出现给“提示词(Prompt)”。

单位也要统一。延迟统一写 P95 毫秒,不写“很快”。数据量统一写条数或 GB,不写“很大”。阈值统一写百分比或绝对值,不写“明显上升”。

术语混乱的代价不在沟通,而在执行。你和 Agent 说“让大语言模型(LLM)调用工具”,它可能理解成模型自己发请求;你改成“让 Agent 通过 MCP Server(模型上下文协议的服务端)调用工具”,动作边界就清楚了。

术语表和规则卡一样,是给模型看的约束,不是给人看的文档。写的时候要假设读者没有上下文,这样人和模型都不会误读。

分层:事实、规则、判断各归各的位置 ​

整理知识时,还有一个常被忽略的动作:分层。不是所有知识都该塞进同一个地方。

事实层放可查证的信息,比如接口文档、字段含义、历史故障记录。这类内容适合放进检索库,需要时再取,不必常驻上下文。知识库是上位概念:规则层进 System Prompt,事实层进检索库,判断层留给人。

规则层放必须遵守的约束,比如发布前跑哪些用例、回滚阈值是多少、哪些操作需要审批。这类内容适合写成规则卡,直接放进 System Prompt。

判断层放需要人拍板的部分,比如这个需求值不值得做、这次故障要不要对外披露。这类内容不要写成自动执行规则,留给人。

分层的价值在于控制上下文。事实层按需检索,规则层常驻,判断层留白,三层混在一起,模型就会把判断当规则执行。判断层具体怎么练,见 10.1.2。

分层还有一个落地办法:给每份知识标一个使用场景。写“发布”时用、写“故障处理”时用、只在审计时用,场景标清楚,塞错位置的概率会低很多。

增量萃取(两步)

双向提纯:人提纯给模型,模型提纯给人 ​

这一部分是 10.1.1 的总装。前面四步(去噪、结构化、标准化、分层)主要发生在人审段,解决的是单份材料怎么变干净、变可判定。它把“机器粗筛 → 人判断 → 机器固化”串成一条完整链路,讲人机怎么分工完成一轮提纯。所以它不是与前面四步并列的第五种操作,而是把它们组装成可循环的流程。

提纯不是单向的,人和模型各做一段,效率最高。

第一段由模型做。把几十页会议记录丢进去,让它抽出决策、负责人和截止时间,人只做审核,不做搬运。

第二段由人做。模型抽出来的东西往往太全,需要人删掉不重要的部分,补上模型不知道的背景。

第三段再交给模型。把审核后的规则卡放进 System Prompt 或知识库,让它在执行时调用。

拿同一份会议纪要试一次。经验上,第一轮能抽出几十条候选规则;人审核后通常只剩十条左右,真正会被 Agent 反复调用的可能只有三条。这个收缩过程本身就是提纯。

这条链路可以循环。Agent 执行失败,把失败案例写回规则卡,下一轮就少犯一次。提纯的产出不是一篇更短的文档,而是一组可调用的资产。

规则卡、检查清单、术语表、Skill 文件,都算资产。判断标准很简单:下一个人拿到它,能不能直接执行。

提纯后要做一次验收,问三个问题。新来的人能不能照着执行,模型能不能只靠这份材料完成任务,出错时能不能定位到具体哪一条。三个都答是,才算提纯完成。

经验萃取:把一万小时变成可调用的资产 ​

前面讲存量文档,这一部分讲还没写下来的隐性经验。过去靠常说的“一万小时定律”堆出来的手艺,Agent 把这段路压短了。

但经验没有归零,只是换了一种存在方式。它不再值钱在“你会做”,而值钱在“你能把它写出来”。

写经验有一个四段式:触发条件、判断依据、动作、反例。四段写全,别人才敢用,Agent 才敢执行。

拿接口超时排查举例。触发条件是 P95 超过 800 毫秒且错误率超过 1%。判断依据是先看下游依赖的耗时,再看连接池是否打满。动作看下游状态:已过载就先限流,未过载就先扩容。反例是直接重启服务,会丢掉现场。

这四段写成规则卡,就能被 Agent 调用。写不出来,经验就只留在你手上,带宽还是一个人。

萃取还有顺序。先做高频场景,再做高价值场景,最后做低频但高风险的场景。高频场景复用次数多,写卡成本回收最快。知识库也不需要大而全,先给高频规则定一个上限,比如两百条;把这两百条写清楚,比堆两千条半成品有用。

这里有一个边界。依赖体感和现场的经验,萃取成本很高,老工匠的手感、老旧系统的玄学排错,写不成规则;硬写只会得到一堆废话。

第 9 章讲过这个限制。可行的做法是先萃取高频、可复述、有明确判据的部分,剩下的留给人类专家,不要硬做端到端。

判断一条经验值不值得萃取,先算复用次数和写卡成本。一年只用一次的经验,写卡的成本收不回来。

10.1.2 能力重组 ​

知识整理完,只解决了“喂什么”。接下来要解决“人做什么”,因为 Agent 把执行变便宜之后,人的价值不会消失,但会换位置。

位置大致有三个:定义问题、裁决结果、编排系统。三个位置对应三种能力,也对应三种新的工作方式。

它们的共同点是:都需要人给出判断,而不是给出劳动。判断的质量,决定 Agent 产出的上限。

提问大于回答:从找答案到定义问题 ​

过去的瓶颈在获取。想弄明白一件事,要查资料、翻书、问人,几天才能拼出一个答案。

现在瓶颈在定义。答案几秒钟就能拿到,但问题问错了,拿到的答案再漂亮也没用,返工时间可能比原来更长。

坏问题长这样:“帮我优化这段代码。”好问题长这样:“这段代码在 10 万条数据下 P95 是 800 毫秒,慢查询日志显示瓶颈在 N+1 查询,请给三个改法,并说明每个改法的索引代价。”

后一个问题里有目标、有现状、有证据、有验收方向。模型不需要猜,输出就能直接比较,人也容易判断哪个方案更合适。

可以把提问拆成四个要素:目标是什么,约束是什么,现状证据是什么,怎样算完成。四个要素缺一个,模型就多一次猜测,你就多一轮返工。

提问也分层。事实型问题问“是什么”,诊断型问题问“为什么”,方案型问题问“怎么做”,验证型问题问“怎么证明”。多数人卡在方案型,其实前面的诊断没做够。

text
目标:把订单列表接口的 P95 从 800 毫秒降到不超过 200 毫秒
约束:不能改表结构;本周内上线;只允许加索引和改查询
现状:10 万条数据下慢查询日志显示 N+1;索引命中率 12%
验收:压测 10 万条数据,P95 不超过 200 毫秒,错误率为 0
请给出三个方案,并说明每个方案的索引代价与回滚方式

这个例子是方案型问题:目标、约束、现状证据齐了,才轮到问“怎么做”。前四行(目标、约束、现状、验收)不是模板表演,而是把隐性判断显性化。你写得越具体,Agent 的输出越接近可交付,而不是可讨论。

注意:提问时没写验收标准,Agent 交出的结果就无法验收。

判断与验证大于演绎:从陪同演绎到结果裁决 ​

Agent 把演绎(推演)变便宜了,写代码、拆逻辑、列方案,它几秒钟能给你一版。但演绎便宜,不等于结果可信,中间任何一步出错,后面的演绎都会沿着错误往前走。

所以人的重心要从“陪着演绎”移到“判得准”。判断和验证,是新的核心工作。

验证分两层,动作层决定怎么查,判据层决定查什么:

层三项说明
动作层断言 / 对照 / 回归断言把验收标准写成可执行的检查;对照拿已知正确的样本比一遍;回归确认改动没有破坏原有行为
判据层阈值 / 黄金样本 / 反例阈值如 P95 不超过 200 毫秒;黄金样本如输出必须与基准一致;反例如空串、缺数量、非数字、负数、零这五类输入必须报错

两层混用,比只写一句“结果正确”可靠得多。

拿一个订单解析函数举例。Agent 写完,先别急着接进主流程,给它补一组测试。

python
# Python 3.10+,运行:pip install pytest && pytest test_parse_order.py
import pytest

def parse_order(raw: str) -> dict:
    sku, sep, qty = raw.partition(":")
    if not sep or not qty.isdigit() or int(qty) <= 0:
        raise ValueError(f"bad order: {raw!r}")
    return {"sku": sku, "qty": int(qty)}

def test_normal_order():
    assert parse_order("A-1001:2") == {"sku": "A-1001", "qty": 2}

@pytest.mark.parametrize("raw", ["", "A-1001", "A-1001:x", "A-1001:-2", "A-1001:0"])
def test_bad_input(raw):
    with pytest.raises(ValueError):
        parse_order(raw)

测试跑过,只说明这几条边界成立,它不能证明函数对所有输入都正确。这已经够了,验证的目标不是证明绝对正确,而是把错误控制在可发现的范围里。

判断力很难速成,但可以积累。每次验收记录一条判据,半年后就是一套自己的检查清单。

注意:把未经测试的生成代码直接接进主流程,会导致错误在上下游静默扩散,定位成本远高于提前写测试。

宏观规划与编排大于微观实施:从单点工匠到系统调度官 ​

过去的技能墙很硬。做后端的人,前端样式往往搞不定;想做全栈,得先补几个月的短板。

Agent 把墙拆成了门。前端、后端、数据处理、样式调优,每个微观环节都有能落地的 Agent,人的精力就可以往上抽。

从“自己写”,变成“拆任务、定接口、验结果”。编排要做的也是三件事:拆解、接口、验收。

先说拆解。子任务要小到一次能验收,又要大到不需要反复拼接。拆得太细,接口成本会超过执行成本。一个可操作的检查是:如果你说不清每个子任务的输入和输出,说明还没到可以交给 Agent 的程度。

再说接口。字段名、类型、错误码、超时时间,都要在开工前定死。前后端一个写 user_id,一个写 userId,联调时就得返工。

最后是验收,判据见上一节。每个子任务都要有可执行的检查,不能只看“看起来对了”。验收标准最好在开工前写,而不是等结果出来再补。

人工检查点要设在不可逆的动作之前。发布、删数据、对外发送消息,这三类动作一旦执行就很难回退,必须让人看一眼再放行。

编排不需要复杂工具。一个任务的依赖关系写清楚,就够起步:

text
api     -> (无依赖)
ui      -> (无依赖)
client  -> api
e2e     -> ui, client

依赖调度的完整示例见第 6 章。

除了上面的人工检查点,把任务换成 Agent 调用时还要补失败重试。Agent 失败不会自己停下来,没人监控,就会反复重试,直到撞上最大重试次数。重试次数和费用,都要盯。

编排能力不是工具能力,是架构能力。拆得清、接口定得住、验收写得出来,Agent 越多越省事。

反过来,拆得粗、接口含糊、验收缺失,Agent 越多,返工越多。工具会放大执行力,也会放大设计缺陷。

重组的顺序 ​

三个能力不用同时练,建议按下面的顺序来。先练提问,因为提问决定输入质量,输入不对,后面全是返工。

再练验证,因为验证决定结果能不能用。最后练编排,因为编排是把前两个能力复制到多个 Agent 上。

这是建议顺序,不是唯一路径。先被验证逼着学提问的人,同样成立。这个顺序有一个现实原因:提问和验证在单个任务里就能练,编排要等你有多个任务并行时才有意义。

练提问可以从改写旧指令开始。把过去交给同事的一句话任务,补上目标、约束、现状和验收,再交给 Agent,观察输出差多少。

在Agent时代,个人的改变可以落到两个动作:把知识提纯成可调用的资产,把能力重新进行定义和编排。

这两个动作都不轻松,但都能逐步做。今天先整理十张规则卡,明天写一条验收标准,都算开始。

衡量的方式也很直接。一个月后看两件事:知识库里有多少条可执行规则,你的时间有多少花在定义和验收上。

个人之后是一群人。当每个人都完成这次重组,组织的流程和规则也会跟着重排。10.2 讨论这件事。

10.2 一群人的改变:流程重建与规则重排 ​

10.1 讨论的是个人。一个人把知识提纯,把能力重组,效率可以提升几倍。

但个人效率不等于组织效率,一个人再快,卡在审批、对齐、返工上,产出还是上不去。

从改造的先后看,组织的最小单位不是人,是流程和规则。流程决定信息怎么走,规则决定人怎么协作、收益怎么分。

Agent 进入组织后,最先被改造的不是岗位名称,而是这两样东西。流程从“人传人”变成“按接口对接”,规则从“防人”变成“调度”。

本节分两层看这件事,先看流程重建,再看规则重排。讨论的范围限定在以数字交付物为主的团队,比如软件、内容、设计、数据分析。涉及物理世界和强监管的流程,改造速度会慢很多。

10.2.1 流程重建 ​

流程由两段构成:一段把“要做什么”对齐成一致的理解,一段让信息在角色之间流动、并在节点上做判断。前一段是意图对齐,后一段是信息流转。

传统流程大多为“人可能出错”而设计。所以要有对齐会、转述、复核、签字。这些环节不是浪费,它们是在给人性的不确定性买保险。

Agent 不会消除这两段,它改的是每一段的实现方式:意图对齐从“说服”变成“定义”,信息流转从“转述”变成“直达”。下面分别看。

意图对齐:从说服到定义 ​

过去组织花大量时间开会、一对一沟通、做团建。很大一部分目的,是把大家的脑子揉到一块儿。

这件事之所以难,是因为人有私心、有认知偏差、执行会走样。在我们接触的知识型团队里,统一思想是传统组织成本最高的部分。

Agent 没有情绪,没有办公室政治,也不会阳奉阴违。但这不等于它天然对齐。它只对齐你写下来的东西,你没写清楚,它就会自信地做错。

所以,思想工作变成了规格工作,管理者要交付的不是会议纪要,而是一份可执行的定义。

一份合格的任务定义(任务卡),至少包含六项:目标、输入、输出、约束、验收标准、失败处理。少一项,执行方就要猜一次。

举个内容团队的例子(示意),过去定一个选题,开 40 分钟会,三个人记了三份笔记。写出来的东西方向不一致,再开一次会返工。

现在换成一张任务卡,十来行字,六项逐条落地:目标写成目标读者和核心判断;输入写成必须回答的问题和素材范围;输出写成交付形态;约束写成禁用词和字数区间;验收标准写成验收清单;失败处理写成退回条件。人和 Agent 读同一份卡,分歧在开工前就暴露。

读者可以把这张卡理解为一份可执行的合同。它的价值不在“规范”,在“可检查”。写不清楚的地方,验收时一定会变成争议。

状态机(Finite State Machine,FSM)就是一张“当前状态 × 动作 → 下一状态”的表,用来判断哪些转移合法。下面用一个最小状态机,把这种“可检查”落到代码里。它只验证流程状态,不验证任务卡内容;卡的内容靠验收清单。环境是 Python 3.10 以上,只用标准库。

python
# fsm_task.py — Python 3.10+,仅标准库
from enum import Enum

class State(Enum):
    DRAFT, READY, RUNNING, REVIEW, DONE, FAILED = "draft", "ready", "running", "review", "done", "failed"

ALLOWED = {
    State.DRAFT: {State.READY}, State.READY: {State.RUNNING},
    State.RUNNING: {State.REVIEW, State.FAILED},
    State.REVIEW: {State.DONE, State.RUNNING},
    State.FAILED: {State.DRAFT}, State.DONE: set(),
}

def move(cur: State, target: State) -> State:
    if target not in ALLOWED[cur]:
        raise ValueError(f"不允许从 {cur.value} 直接到 {target.value}")
    return target

if __name__ == "__main__":
    path = [State.DRAFT]
    for t in (State.READY, State.RUNNING, State.REVIEW, State.DONE):
        path.append(move(path[-1], t))
    print(" -> ".join(x.value for x in path))
    try:
        move(State.DONE, State.RUNNING)
    except ValueError as e:
        print(f"拦截:{e}")

运行结果如下,状态转移和拦截信息都能对上。

bash
python3 fsm_task.py
# draft -> ready -> running -> review -> done
# 拦截:不允许从 done 直接到 running

二十多行代码,固化的是流程层的状态与合法转移:哪些状态合法、哪些转移非法、非法动作有什么后果;内容约束、验收标准仍在任务卡上。

团队开会时争的是“我觉得可以发”,状态机回答的是“流程没走到审校,不能进 done”。前者靠嗓门,后者靠规则。

注意:状态机定义过细,会导致新任务无法进入流程,团队最后绕过系统手工改状态。只把必须一致的动作写进状态机,创作判断留给审校。

这里要说清楚边界。状态机管的是交付流程,不管创意好坏,它能让流程不跳步,不能让内容变好。对齐的目标也不是让所有人想法一样,而是让验收标准一样:想法可以不同,交付物必须过同一道门。这道门的标准要写在任务卡里,不能只留在管理者脑子里,否则换一个人执行就会走样。

信息流转:从转述到直达 ​

信息流转是流程的血管,传统流程里,信息每经过一个人,就损失一次精度。

假设一个场景。测试写一段自然语言 Bug 报告,开发看完说描述不清。双方开会、复现、争执,半天过去了。

问题不在谁不负责,而在信息格式。一份能直接开工的报告,字段要齐。环境、版本、复现步骤、期望结果、实际结果、日志。

少一个字段,接收方就得多问一轮。六个字段全缺时,按每缺一项追问一次算,最坏情况是六次往返。这不是沟通技巧问题,是结构问题。

Agent 时代的做法很直接。测试 Agent 输出结构化报告,通过模型上下文协议(Model Context Protocol,MCP)或 HTTP 接口交给开发 Agent。开发 Agent 在隔离环境复现,跑测试,把结果写回同一条记录。

这里的关键不是“自动修复”,而是“每一步都可验证”。发现、判定、修复、验证,四个动作都有输入和输出。

下面是一个最小闭环。它不依赖任何第三方库,用临时目录模拟隔离环境,用 unittest 做验收。

python
# bug_handoff.py — Python 3.10+,仅标准库
import json, subprocess, sys, tempfile
from pathlib import Path

REQUIRED = ("env", "version", "steps", "expected", "actual", "log")
def validate(report: dict) -> list[str]:
    return [k for k in REQUIRED if not report.get(k)]

def run_case(workdir: Path) -> subprocess.CompletedProcess:
    # -B 关闭字节码缓存,避免同秒同大小的改写被旧 pyc 覆盖
    return subprocess.run([sys.executable, "-B", "-m", "unittest", "-q", "test_calc"],
                          cwd=workdir, capture_output=True, text=True)

if __name__ == "__main__":
    report = {"env": "Python 3.11 / Linux x86_64", "version": "calc 0.1.0",
              "steps": "调用 add(2, 3)", "expected": "5", "actual": "-1",
              "log": "AssertionError: -1 != 5"}
    print("缺失字段:", validate(report) or "无")
    with tempfile.TemporaryDirectory() as tmp:  # 临时目录模拟隔离环境
        wd = Path(tmp)
        (wd / "calc.py").write_text("def add(a, b):\n    return a - b\n", encoding="utf-8")
        (wd / "test_calc.py").write_text("import unittest\nfrom calc import add\nclass T(unittest.TestCase):\n    def test_add(self):\n        self.assertEqual(add(2, 3), 5)\n", encoding="utf-8")
        first = run_case(wd)
        (wd / "calc.py").write_text("def add(a, b):\n    return a + b\n", encoding="utf-8")
        second = run_case(wd)
        print(f"修复前: {'PASS' if first.returncode == 0 else 'FAIL'}  修复后: {'PASS' if second.returncode == 0 else 'FAIL'}")
        report["result"] = "fixed" if second.returncode == 0 else "open"
        print(json.dumps(report, ensure_ascii=False, indent=2))

执行输出:字段校验、修复前失败和修复后通过都能对上。

bash
python3 bug_handoff.py
# 缺失字段: 无
# 修复前: FAIL  修复后: PASS
# {... "result": "fixed" ...}

示例里的修复动作是写死的,真实系统里,这一步由开发 Agent 根据报告定位并提交补丁。报告结构和验证顺序不变。

这段代码说明了一件事:结构化不是为了好看,是为了让下一个环节可以自动判断。字段少而准,比字段多而空有用。

MCP 在这里的角色,不是魔法。MCP 是开放标准,数据层走 JSON-RPC;它让 Agent 能发现工具、调用工具、拿回结果。没有 MCP,用 HTTP + JSON-RPC(参数用 JSON Schema 描述)也能做,关键是双方对同一份 Schema 负责。

还有一个边界:结构化只解决格式,解决不了跨组织的责任和权限,合同、审批、合规仍然要人来做。

流程重建讲到这里,可以收一句,意图对齐从“说服”变成“定义”,信息流转从“转述”变成“直达”。这两件事做完,组织的协作成本会下降,幅度取决于流程里原本有多少转述环节。

但流程变了,规则不改,新流程会被旧规则拉回去。这就是下一层要讨论的规则重排。规则重排又分协作与分配两层,先看协作。

10.2.2 规则重排 ​

规则分两类。一类管“怎么一起干”,叫协作规则。一类管“干完怎么分”,叫分配规则。

传统规则大多为“防人”而设计,Agent 进来后,防的对象从人挪到任务边界。两类规则各自换锚点:协作规则从防弊到调度,分配规则从工时到判断力。

协作规则:从防弊到调度 ​

先看传统协作规则。考勤、打卡、审批、周报、层层汇报、签字。它们的共同点,是把“不信任”变成可执行的流程。

这些规则在纯人团队里是合理的,人会影响状态,会疲劳,会情绪化。组织用规则换确定性。

但 Agent 参与后,会出现两个错位。

第一个是对象错位,Agent 不打卡,也不写周报。你用管人的规则管它,只能得到形式主义的数据。

第二个是成本错位,审批链越长,Agent 的并行优势越被抵消。一个 5 分钟的审批,会把 24 小时运行的流水线切成碎片。

新的协作规则,核心是五条。

  • 接口契约:输入输出 Schema、错误码、超时时间。

    注意:把内部实现细节直接暴露给下游,会导致接口一改就全线报错。报告 Schema 要版本化,字段只增不删,废弃字段先标记再下线。Schema 的版本号要写进每一次调用,不能靠双方记忆,调用方拿到不认识的版本应该拒绝执行。拒绝执行会暴露一次集成问题,猜字段含义则会把问题藏到生产环境里,后者的修复成本高得多。

  • 权限边界:能读什么、能写什么、能调用哪些工具。

  • 预算阈值:Token、金额、调用次数、并发数。

  • 自愈与升级:重试几次、什么条件下停止、什么条件下叫人。

  • 可解释:为什么停、为什么拒绝、依据是什么,都要写得出来。

规则的数量不一定减少。变的是位置:从“事前盯人”移到“事中约束”和“事后审计”。

策略执行器如下,同样只依赖标准库。

python
# policy_guard.py — Python 3.10+,仅标准库
import json

POLICY = {"max_attempts": 3, "max_tokens": 1200}

def run(task, policy=POLICY):
    used = 0
    for attempts in range(1, policy["max_attempts"] + 1):
        r = task(attempts)
        used += r.get("tokens", 0)
        if r["status"] == "ok":
            return {"status": "done", "attempts": attempts, "tokens": used}
        if r["status"] == "permission_denied":
            return {"status": "escalate", "reason": "permission_denied", "attempts": attempts, "tokens": used}
        if used >= policy["max_tokens"]:
            return {"status": "escalate", "reason": "budget_exceeded", "attempts": attempts, "tokens": used}
    return {"status": "failed", "reason": "max_attempts", "attempts": policy["max_attempts"], "tokens": used}

if __name__ == "__main__":
    cases = {"flaky": lambda a: {"status": "error", "tokens": 400} if a < 2 else {"status": "ok", "tokens": 300},
             "denied": lambda a: {"status": "permission_denied", "tokens": 50},
             "expensive": lambda a: {"status": "error", "tokens": 700}}
    for name, fn in cases.items():
        print(name, json.dumps(run(fn), ensure_ascii=False))

三个用例的输出:完成、权限升级和预算升级。

bash
python3 policy_guard.py
# flaky {"status": "done", "attempts": 2, "tokens": 700}
# denied {"status": "escalate", "reason": "permission_denied", "attempts": 1, "tokens": 50}
# expensive {"status": "escalate", "reason": "budget_exceeded", "attempts": 2, "tokens": 1400}

这段代码里,没有一条规则是“你几点上班”。它管的是三件事:能做几次、能花多少、什么情况下必须停下来找人。

这就是从人肉管理到资源调度的具体样子。规则不再盯着人,而是盯着任务的边界。

注意:预算和权限写得太宽,会导致 Agent 在失败时反复重试,把一次小错误放大成账单;写得太窄,会导致正常任务频繁中断。阈值要按任务分级,不要一刀切。另外,示例里的 Token 检查发生在调用之后,是软阈值:max_tokens: 1200 仍可能被一次 700 Token 的失败调用顶到 1400,要硬拦就得在调用前先查剩余额度。

最后一条“可解释”不是附赠的文档工作,它决定“自愈与升级”能不能成立。只写阈值不写原因,执行方遇到边界情况就只能停机等指令。调度优势会被重新吃掉。解释写清楚了,它才知道该重试、该降级,还是该叫人。

审计也要跟着变。Agent 的每一步都可以留下 Trace,这比人工汇报可靠。但前提是日志要记输入,不能只记结果;只记结果的日志,出事时无法复盘。涉及资金、生产环境、用户数据的操作,仍然必须保留人工审批:Agent 能提高审批的信息质量,不能取消责任主体。

分配规则:从工时到判断力 ​

传统分配有一个两难,听话的人态度好,但能力可能一般。能干活的人脾气大,但不好管。大量的奖惩规则,都在平衡“听话”和“干活”。

Agent 把这件事的底座换了,服从和基础执行,变成了廉价资源。Agent 不需要休假,没有情绪,可以复制,可以 7×24 小时运行。

当“听话”不再稀缺,分配的重心就会转移。转向问题定义、判断、审美、架构、验收。这些是 Agent 暂时做不好、也最难标准化的部分。

但这里有一个误区要拆掉:不是“刺头”值钱,是“正确判断”值钱。脾气不是能力。把“难管”当成“有本事”的证明,是另一种形式主义。

怎么给判断力定价?有三个方向可以试。

  • 决策留痕:重要判断写下假设、依据、可证伪的条件。
  • 结果复盘:看这个判断在不同项目里的复现率,区分运气和能力。
  • 影响半径:一个判断影响一个人、一个团队,还是一条产品线。

这三个方向都不完美,但比工时更接近价值,工时衡量投入,判断衡量杠杆。

判断力也需要校准,一个人连续三次判断正确,第四次仍然要写清假设,否则组织会把运气当成能力。校准的周期不能太长,我们的做法是一个季度一次,间隔太久,记忆会把因果关系抹平。

我们来看一个简化的假设例子。工程师 A 每天写 300 行代码,15 天交付一个模块。工程师 B 花 2 天定义接口,让 5 个 Agent 并行实现,3 天完成,总周期 5 天。

月底按个人手写代码量算,A 赢;按交付周期算,B 赢。再看返工(按轮计):B 的接口改了 1 次,A 的模块集成时改了 4 次。

如果分配规则只看代码量,B 会被淘汰,组织会留下 A。这就是规则在替旧流程投票。

注意:这里的口径是“个人手写代码量”。如果统计的是团队总代码量,B 指挥 5 个 Agent 的产出也要计入,A 就不一定赢;换一个口径,结论就会反转,所以分配规则第一步是把口径写清楚。

注意:只看结果不看过程,会导致大家抢容易出结果的短任务,把长周期的基础工作丢给别人。结果指标要配过程审计,否则分配会再次失真。

那分配规则该怎么接住判断力?有三个口子不必等薪酬体系重写就能先做:项目权,谁定义问题、谁定验收口径;资源配额,一个人能调用多少 Agent、多少预算、多少并行任务,这就是他的编制;复盘权重,看谁的解释被采纳、谁的假设被证伪,作为下一轮分配的依据。奖金系数要单独说:它把判断质量作为系数而不是把工时作为基数;但它绕不开薪酬体系,得和体系一起改,不能先做。

这几项里,项目权和资源配额最容易被忽略。它们不体现在工资条上。但恰恰是这两项决定了一个人能不能把判断力用出来:只给钱不给定义权,等于让他继续在别人画好的框里执行。

这也是“干完怎么分”的完整回答:分的不只是钱,还有定义权、调度半径和话语权。反过来,如果分配只动奖金、不动这三样,我们倾向于认为,判断力强的人会先走,留下的还是最会执行旧流程的人。

那是不是人就不重要了?答案恰恰相反。Agent 越多,定义问题和验收结果的人越关键。

一个错误的判断,配上强大的执行力,只会更快地产生错误结果。判断力不是 Agent 时代的配角,它是新的瓶颈。

改造的难点 ​

这两件事不会同时发生。通常是流程先变,规则滞后。于是出现一批“用新工具跑旧流程”的团队,工具很新,产出没变。

我们判断一个组织是否真的完成了改造,不看它买了多少 Agent。看它的审批链、考核表、事故复盘记录有没有变。

在我们看来,改造的难点不在技术,在利益。流程调整会动到岗位,规则调整会动到收入,这两件事都不会自动发生。所以真正的改造往往从一次具体的流程试点开始,先用结果说服人,再动规则,顺序反了会遭到反弹。

本节讲了两件事:流程换了接口,规则换了锚点。

下一节把视角再放大,当一群人的流程和规则都变了,生产力会怎么跃迁,人与机器的边界会落在哪里。

10.3 所有人的改变:生产力跃迁与人机共同体 ​

10.2 讨论的是一群人内部的流程与规则,范围仍在一个组织之内。把镜头再拉远一层,Agent 改变的是整个社会的知识供给方式与分工方式。

个人能力重组、组织流程重排,最终会汇成两件事:生产力跃迁,以及人与 Agent 之间稳定的协作关系。这一节沿着这条线往下走。

所谓生产力跃迁,不是工具变快,而是同样的人能在同样时间处理更多问题。

它有三个来源:知识调用成本下降,人不必把整条学习链路走完;分工重排,岗位从“会不会”转向“能不能定义问题”;验收接口标准化,交付质量能被机器判定,协作不再依赖熟人信任。三个来源分别对应 10.3.1、10.3.2、10.3.3,最后单设 10.3.4 讲度量、追溯与责任。

要强调的是,我们说的跃迁,衡量的是单位人力的产出,不是单次任务的速度。一项任务速度提升,返工却翻倍,产出并没有跃迁。本节只给机制与方向,不给统一倍数;具体倍数取决于任务类型与基线,任何单一数字都不可外推。

10.3.1 知识传递路径扁平化 ​

传统时代的超长知识链路,可以拆成六段:专家写书、教师讲课、读者阅读、做笔记、查文档、实践试错。

每一段都有损耗。

  • 写书:一两年,读者却有限。
  • 讲课:受课时与场地约束,只到几十人。
  • 阅读:15 万字,按 500 字/分读一遍要 5 小时。读懂、验证,还要 20–40 小时(经验值)。
  • 笔记:二次转述,细节会流失。
  • 查文档:散在手册、论坛和源码里,找对版本要半天。
  • 试错:最贵,要拿真实项目和时间去换。

这还是一本写得清楚的书,更麻烦的是,这条链路只能串行。你得先读完,才能判断值不值得读。

卡在这一段的,多半是没时间确认该不该学,不是学不会。

互联网把前几段压缩了:搜索引擎让你几分钟内找到资料,网课让你跳过排队。但它没有压缩后面几段。

找资料变快了,内化和应用还是原来的速度。人眼的读取带宽有限,阅读基本是串行的。这个瓶颈没有变。

Agent 改变的正是后几段。

大语言模型(LLM)把大规模语料压进参数,再用外部检索(retrieval)补上长尾。知识不再是一条必须从头爬的阶梯,而是一组可以按需调起的接口,后文简称“知识即接口”。

你描述目标,Agent 提取对应的知识、生成步骤、调用工具、返回结果。中间那几层“先学懂再动手”的环节被折叠了。

以 C++ 的 3D 打印项目为例。过去一个不熟悉 C++ 的人想改打印路径生成模块,先要装编译环境,再理解 CMake 的依赖关系,然后处理 Eigen、OpenCV 这类库的版本冲突。

光是让项目编译通过,可能就要两三天(示意,实际看项目规模)。

现在可以把这段工作交给 Agent。前提是它能执行命令、读日志。它读 CMakeLists.txt,定位缺失的依赖,按当前系统版本改写编译参数,遇到报错就回到日志里找原因。

前面六段里,写书、讲课、读者阅读已被互联网压过一轮;剩下没被压的是三类:查文档(在具体项目里定位依赖、查 API)、复述(整理与转述)、试错(改参数、读日志)。

对照这三类:装环境、查依赖属于查文档这一类,改 CMake、读日志属于试错,Agent 直接给出方案,则把复述这一类折叠掉了。

人要做的,是说清楚“把层厚从 0.2 毫米改成 0.12 毫米,并保持拐角速度不变”,以及判断打出来的件是否合格。拐角速度不归这个估算器管,由切片器负责。

这里有一条边界需要说清楚。被压平的是“查文档、复述、试错”这三类,不是“判断与担责”这两类。

Agent 可以把这段工作压到几十分钟量级,给你一份可编译的代码(示意,实际看项目规模与报错情况)。但它不知道这个零件装到机器上会不会卡料。验收标准仍然由人定义,后果也仍然由人承担。

换句话说,知识调用变便宜了,判断没有变便宜。把这两件事混为一谈,就会得出“人不再需要学习”的错误结论。

注意:把 Agent 生成的构建脚本直接用于生产环境,会导致依赖版本与线上不一致,编译通过但运行时报符号错误。先在隔离环境跑一遍完整构建,再合入主分支。

我们可以用一段很小的代码,看清“知识即接口”是什么意思。下面这个脚本把“按层厚换算打印时间”封装成带范围校验的工具,任何 Agent 只要按 Schema 传参就能调用。

python
import json, sys
SCHEMA = {"layer_height_mm": (0.05, 0.4), "layers": (1, 100000), "seconds_per_layer": (0.1, 600.0)}

def estimate(p):
    for k, (lo, hi) in SCHEMA.items():
        if not lo <= p[k] <= hi:
            raise ValueError(f"{k} out of range: {p[k]}")
    return p["layers"] * p["layer_height_mm"], p["layers"] * p["seconds_per_layer"] / 60

h, m = estimate(json.loads(sys.argv[1]))
print(f"height={h:.1f} mm, time={m:.1f} min")

运行方式很简单,环境只需要 Python 3.8 及以上(示例在 3.10 验证),不依赖第三方库:

bash
python3 print_time.py '{"layer_height_mm":0.12,"layers":1333,"seconds_per_layer":18}'

输出是 height=160.0 mm,time=399.9 min。代码里的 SCHEMA 常量,和 10.1 的规则卡是同一思路:字段固定,模型读到的边界就固定。把老师傅的经验写成机器可校验的边界,知识就从“口口相传”变成“带边界的接口”。这里只保留最小形态。

扁平化的真实含义也由此确定:不是人不用学了,而是学习的重点从“记住参数”转向“定义参数、校验结果”。

10.3.2 社会分工的重塑 ​

传统分工的基础是知识垄断与协调成本。你会前端,同事不会,页面就归你;你会运维,别人不会,集群就归你。

岗位名称本质上是“某段知识”的产权标记。这套分工有两个前提:知识稀缺,学会需要时间;人与人协作有摩擦,所以需要专人对接。

Agent 同时削弱了这两个前提。一方面,当知识可以按需调起,按“会不会”划分岗位的意义就下降了。初级测试这类岗位的共同点是输入输出清晰、判断空间小、知识更新慢,通常最先被 Agent 接管。另一方面,Agent 作为标准接口降低了对接摩擦:字段、协议、验收统一之后,来回确认的成本随之下降。专人协调的必要性也随之减弱。

但接管不等于消失,岗位内容会向上移动。以测试为例,过去时间主要花在写用例、跑回归、提 Bug。现在这些由 Agent 完成。

测试工程师的工作变成三件事:定义什么叫“通过”,设计覆盖边界条件的验收用例集,判断一次失败是产品缺陷还是用例问题。三者各管一段:标准是判据,验收用例集是覆盖边界的样本集合,失败归因是责任入口。

以翻译为例,在机器翻译普及的团队里,过去按千字计价的笔译正在拆成两段:术语库维护和译后审校。这两件事仍然需要人,而且比逐句翻译更考验判断。

这不是个别现象。分工的轴心正在从“技能”转向“问题定义与资源编排”。

谁能把模糊需求拆成可验收的任务,谁能给 Agent 划出正确的边界,谁就掌握定价权。

这里有一个容易被忽略的代价:新人的成长阶梯断了。过去一个初级工程师靠反复做同类工作积累手感,往往两三年后才能独立判断。

现在重复工作被 Agent 拿走,新人直接面对“定义问题”的高阶任务,往往接不住。

注意:把初级岗位的重复任务全部交给 Agent,会导致新人缺少基本功训练,两三年后团队无人能判断 Agent 的输出是否正确。保留一部分刻意练习,是组织必须支付的成本。

分工重塑还会改变组织形状。传统金字塔靠中间层传递信息、分解任务、监督执行。Agent 承担了分解与执行,中间层的价值就必须重新证明。

能定义标准、能做例外裁决的中层会留下。只做信息转发的层级会被压掉。

压掉之后,分工的收益回到产出侧:协调成本下降,单位人力的产出上升,这正是生产力跃迁在组织层面的落点。分工重排之后,人和 Agent 各做什么需要固定下来。这就是下一节要说的共同体。

10.3.3 人机共同体:三个接口与稳定协作 ​

先说分层。10.1 讲个人怎么把任务拆开。这里的拆解、接口、验收,落成共同体层的意图、执行、验收三个接口。拆解产出目标与约束,对应意图接口;接口定义工具与数据,对应执行接口。在个人层面,这是工作方法;在共同体层面,这是可接入 CI 的门槛、有边界的授权和可追溯的记录。

“共同体”这个词容易被写虚。这里给一个可操作的定义:共同体 = 三个接口 + 授权边界 + 责任划分的制度。三个接口是意图接口、执行接口、验收接口;责任划分放在 10.3.4。

三接口都有明确格式,协作才能重复发生。

意图接口规定人要给什么。至少包括目标、约束、验收标准。缺一项,Agent 就会用默认假设填补,结果通常不是你想要的。

执行接口规定 Agent 能碰什么。可用的工具、可读的数据、可写的目录、失败后的重试次数。边界不清,Agent 会把“能做的事”当成“该做的事”。

授权可以分三层:只读、可写但需复核、可写且自动执行。层级按后果定,不按 Agent 的能力定。

验收接口规定怎么判成败。可自动校验的写成测试,不能自动校验的写成抽样规则,比如每 20 条抽 1 条,错误率超过 5% 就全检(示意)。

没有验收接口,所谓“人机协作”就退化成“人给任务、Agent 交任务、人凭感觉接受或打回”。

使用工具和共同体的差别正在这里。前者是单次调用:人临时下一个指令,没有验收,也没有授权边界。后者是三接口稳定、可重复、可追溯:同一类任务反复下,标准不变,责任清楚。

三者之中,验收接口往往最容易被省略,也最容易出事故。下面这段脚本是一个最小验收器:人把标准写成断言,Agent 的产出先过断言,再交给人看。

python
#!/usr/bin/env python3
"""accept.py: 按规则表校验 Agent 产出的指标报告。"""
import json
import sys

OPS = {
    ">=": lambda a, b: a >= b,
    "<=": lambda a, b: a <= b,
    "==": lambda a, b: a == b,
    ">": lambda a, b: a > b,
    "<": lambda a, b: a < b,
}


def check(report, rules):
    failures = []
    for rule in rules:
        field = rule.get("field")
        op = rule.get("op")
        target = rule.get("value")
        if field not in report:
            failures.append(f"{field}: missing")
            continue
        actual = report[field]
        func = OPS.get(op)
        if func is None:
            failures.append(f"{field}: unknown op {op}")
        elif not func(actual, target):
            failures.append(f"{field}: {actual} {op} {target} is false")
    return failures


if __name__ == "__main__":
    report = json.loads(sys.argv[1])
    rules = json.loads(sys.argv[2])
    problems = check(report, rules)
    if problems:
        print("REJECT")
        for item in problems:
            print("-", item)
        sys.exit(1)
    print("ACCEPT")

运行示例:

bash
python3 accept.py '{"pass_rate":0.98,"p95_ms":820,"files":12}' '[{"field":"pass_rate","op":">=","value":0.95},{"field":"p95_ms","op":"<=","value":1000}]'

输出 ACCEPT。把 pass_rate 改成 0.9,输出 REJECT 并以退出码 1 结束。退出码可直接接入 CI,作为合并前的硬门槛。脚本同样只依赖标准库,Python 3.8 及以上(示例在 3.10 验证)即可运行。

10.3.4 共同体的度量、追溯与责任 ​

共同体要长期运转,还需要度量。度量分两层。产出侧看交付周期、吞吐量、返工工时、单位产出成本;协作质量看一次通过率、返工率、人工介入率。返工率按次数算,返工工时按时间算。

产出侧不改善,协作形式再漂亮也没有意义。验收接口只判单次产出;协作三项判的是协作机制本身。

一次通过率低,通常先怀疑意图接口没写清楚。返工率高,先查验收标准;人工介入率高,先查授权范围;单位产出成本不降,先查串行环节。先怀疑不等于只查这一项。

这些数一起看,才能判断问题出在人、出在 Agent,还是出在接口。

我们的建议是,团队先测一个迭代的基线(至少覆盖两个完整迭代),再谈优化。没有基线,这些数只是几个孤立的百分比。这一步不能省。

长期运转还要求可追溯。每次执行留下轨迹:输入、调用的工具、中间产物、验收结果。

没有轨迹,出问题只能靠猜。有轨迹,才能定位是意图错了、执行错了,还是验收标准错了。

最后是责任划分。Agent 可以执行、可以建议、可以在授权范围内自主决策,但它不能承担后果。

签字的人、上线的人、面对客户的人,仍然是人。把责任推给模型,是管理上的失职。

举个具体场景。一次上线事故里,Agent 按预设规则自动回滚了服务,损失却已经发生。签字上线的人要对外说明,值班的人要负责复盘,Agent 的日志只能证明它按规则执行。谁定规则、谁签字、谁对外、谁复盘,这四件事必须在事故之前就写清楚。

10.3 讲的是“所有人”这一层的变化。知识链路被压平,查文档、复述、试错这三类折叠进 Agent;判断与担责仍留给人。岗位从“会不会”转向“能不能定义问题”,组织中间层被压掉。协调成本下降,收益回到产出。人和 Agent 的关系从单次使用变成稳定制度。它靠意图、执行、验收三个接口重复运转,用产出侧与协作质量两组指标检验,靠轨迹追溯,靠人担责。

下一节讨论认知、感知与想象力这三件事为什么不会过时。

10.4 人类在 Agent 时代终极价值与定位 ​

10.1 到 10.3 讲了三层变化:个人的知识被重构;团队的流程被重建、规则被重排;整个社会的生产力跃迁与分工重排。

执行变便宜这件事,10.1 已经讲过,这里只问一件事:什么替不了。10.1 讲个人要练什么,落在操作层;10.3 讲社会分工怎么重排;本节讲重排之后,人剩下什么、为什么不会过时,落在边界层。

“终极价值”这个词有点大。我们更愿意把它拆成三样具体的东西:认知、感知、想象力。

这是我们选的分析框架,不是定理。这三样对应 Agent 的三条边界:它给得出答案,给不出认知;读得懂数据,读不出现场;擅长收敛已知,不擅长发明未知。边界背后是模型的三个结构性事实:知识来自训练语料,有截止日期;感知来自采样,没有现场;方向来自外部目标。最后一条也是对齐要解决的问题。

10.4.1 答案与认知 ​

先区分两个词:答案和认知。

答案可以被检索,也可以被复制和转发。你问 LLM:CAP 定理是什么。它两秒内就能给出定义和 CP/AP 两种取舍,措辞比多数教材清楚。

认知不是这样长出来的,它要你自己做过取舍、承担过后果,才知道哪个选项在什么条件下会咬人。

举个具体的例子。系统选型上最明显。真正的判断藏在业务细节里。

Agent 可以把 MySQL 和 PostgreSQL 的差异列成一张很长的表,事务、索引、扩展性、生态,一项不落。

这张表是对的,但它不会告诉你一个假设场景:你们团队只有两个运维,过去五年所有值班手册都是按 MySQL 写的。

换数据库省下的那点性能,可能还不够补一次凌晨三点的故障处理。选型选到最后,选的不是数据库,是团队扛得住的复杂度。

再看一个线上的场景。服务变慢,Agent 能在几分钟内列出十几条可能原因:慢查询、连接池耗尽、缓存击穿、GC 停顿、下游超时。

这份清单很全,但它排不出优先级,也说不清哪一条最值得先查。真正定位问题的人,靠的是对一个系统的长期认知:这个服务上个月改过哪里,哪个下游最近在扩容,哪条报警以前是误报。同样的日志摆在两个人面前,认知深的人十分钟能定位,认知浅的人只能一条条试。

同一套 Agent 摆在两个人手里,产出却差出好几倍。

这里有一条技术上的原因。LLM 的预训练目标是预测下一个 Token,它主要优化文本分布的拟合;世界模型是副产品,不是训练目标。

它能复述连接池耗尽会导致超时,但它没有经历过一次连接池耗尽的凌晨。它也不知道一次扩容为什么安排在周五晚上。训练数据还有截止日期。

不接检索、不接工具时,模型对截止日期之后发生的事只能靠推理去猜,猜出来的东西往往缺少细节;Agent 可以接上检索和工具补这一段,但补进来的是资料,不是它自己的经历。

这就是知道答案和形成认知的差别:前者可以下载,后者必须自己一步一步走完。

有人会说,那就把知识都灌给模型,让它替我理解。这条路走不通,原因不在模型这一侧:认知不是存储,是连接。你得知道这条知识和那条经验在什么场景下会冲突。这种连接只能在实战里长出来。

而且认知是有复利的。你每处理一次事故,就多一条自己的判断线索;下一次遇到相似的现象,你能提前动手。

提前的那段时间不写在任何文档里,也不在任何公开语料里。写进文档的是结论,没写进去的,是当时为什么这么判断。这份判断是你区别于通用模型的那部分资产。

所以知识可以被压缩,认知不能;知识获取变便宜了,认知反而更值钱。而且认知会过时,值钱的不是存量,是更新它的能力。

认知最终体现在你给 Agent 的约束里。约束是认知最硬的执行形态,具体怎么落到指令上,10.1.2 已经讲过。

10.4.2 感觉与感知 ​

先把两个词分开:感觉是身体当下收到的信号,感知是把这些信号在经验里连成意义。感知以感觉为输入,两者都离不开现场。

Agent 的输入是采样后的符号,不是连续的世界本身。多模态模型确实能读图、能听声音,但它读到的是像素与音频特征(波形或频谱),不是一个站在现场的人感到的那点不对劲。

量得出却量不准的异常,是第一层。工业现场最能说明这件事,因为那里的信号从来不是为模型准备的。一台老设备快出问题时,声音会变,外壳的温度会变,操作工走过路过就能察觉。

传感器能测振动,模型能按阈值报警。但阈值通常是人定的,报警之前那段模糊的异常,往往只有长期在场的人才感觉得到。

注意:把现场判断全部交给模型,弱信号会被漏掉,设备可能直到停机才被发现。

医疗场景更直接,因为判断的代价落在具体的人身上。医生判断一个病例,不只看 CT 上的结节大小和边缘,还要看问诊时病人的神态和家属的语气。

片子上的阴影可以量化,人身上的犹豫不能。Agent 能把影像报告写得规范,但要不要手术、什么时候做,是另一回事。

说不清的好坏,是第二层。产品评审是另一个场景,数据只能覆盖被量化的那一部分。两个方案的数据都能达标,A 的转化率高两个点,B 的留存好一点,表上各有胜负,看不出该选哪个。

可你坐十分钟,会觉得 B 的返回按钮位置别扭,A 的提示语让人紧张。这些细节不会写进需求文档,但会写进用户的身体记忆。

审美也是感知的一部分,而且是最难被指标化的那一部分。Agent 可以生成一万张图、一万行代码、一百个方案,但它不知道哪一个会让人停一下。

判断这件事,需要你见过足够多的好东西,也见过足够多的坏东西。审美(判断)不是天赋,是长期对比出来的。

调香师、厨师、录音师这些行当更明显。仪器能测出成分和分贝,但那一口、那一闻、那一声,最后的取舍仍由人签字。

情绪与责任,是第三层。情绪需要真人载体,责任需要真人签字。客服 Agent 能解决大量标准问题,剩下的投诉最后还是要转给人。

责任怎么划分,10.3.4 已经讲过。这里只看载体:一句由真人说出的话,和一段措辞完美的模板,重量不一样。

这件事不神秘,也不浪漫,只是载体的差异。人是碳基生命,靠五官和身体活在一个连续的世界里。Agent 活在这个世界的描述里。

描述可以很细,但描述不等于现场。所以感知不会过时,只会变得更稀缺。

感知也不是天生的。你在一线待得越久,能分辨的差异越多。看一百套房子,才分得清什么叫采光好。

Agent 可以帮你记录、对比、回放,把感知的过程变得可复盘。但它替不了你站在那个房间里,抬头看一眼层高和窗外的光。

10.4.3 想象力与好奇心 ​

Agent 擅长在给定目标下收敛,人负责定方向、向外发散。这个分工不是情怀,是能力边界使然。10.4.1 讲过预训练目标:模型在训练分布里找最可能的下一段。它倾向于在分布内插值强、分布外泛化弱。分布外不是完全不会,只是稳定性差,需要人兜底。所以它给得出收敛的答案,给不出那个最初的念头。

问题和目标由人提,协议由人定。MCP 就是协议这一侧的例子:函数调用 2023 年就有了,但从那个能力到一个协议该长什么样,中间这一步是人补的。

DeepMind 的 AlphaFold 能预测蛋白质结构,这项能力很强。但预测哪个蛋白质、为什么这个靶点值得做,目前仍主要是人的问题。

既然执行不再是瓶颈,竞争就落到选方向上。过去比谁能做出来,以后比谁知道该做什么。方向比速度重要。

一个团队用 Agent 一周能搭出一套 CRUD 系统。另一个团队也能。差别不在交付速度,在选的那个方向对不对。

方向选错的时候,效率越高,浪费反而越大。这一点在 Agent 时代会被放大。

好奇心的作用,是让你多问一句为什么不能反过来。很多机会就藏在这句话后面。

想象力的作用,是让你在还没有的东西面前,先看见它大概长什么样。看不见,就没法让别人和你一起做。

这两样东西很难外包,也很难在短时间内买到。你可以让 Agent 帮你查资料、做原型、跑实验,但最初那个念头只能你自己起。

好奇心问出问题,想象力把问题变成一个能验证的假设。这两步是连着的:没有假设,问题就停在感慨;没有验证,假设就停在空想。

一个可验证的假设有具体形状:如果换掉这个流程,交付时间会缩短一半;如果用户真的在意这个功能,他们会愿意为它多点一次。写不出这个形状,说明想法还没长成。

Agent 在这里能做的事很多。假设写出来,它可以帮你设计实验、找对照、跑数据、做原型。但假设本身得由你提。Agent 能做的,是在一个给定目标下找下一步的最优解;目标函数由外部给定,它不会自主、持续地提出目标。

注意:只考核执行效率、不设探索预算,团队会逐渐失去提出新方向的能力。

探索需要预算,也需要允许失败,这两条缺一条都做不成。一个团队如果每个季度都要拿出确定的结果,就没人敢碰需要半年才看得清的事。

比较实际的做法是,给探索留一块小得能承受、又大得能验证的空间,比如每周半天,只回答一个问题:如果这件事重做一遍,我们会怎么设计。这个问题看起来虚,但它会逼你把现有的流程重新讲一遍。改进往往就是从这一步开始的。

想象力的训练也有具体办法。先写一页未来新闻稿,假设三年后产品已经成功,倒推今天缺什么。或者画一张架构图,把还不存在的模块也画上去。

这些动作不需要技术,也不需要预算,只需要你肯离开眼前的待办清单半小时。

当然,不是每个人都要去做发明家。在自己的领域里多问一句,已经够用。做财务的可以问:为什么对账一定要月底做?做教育的可以问:为什么上课一定要在固定时间?做软件的可以问:为什么这个流程一定要有人点一下?问题问出来,Agent 才有活干。问题问不出来,再强的模型也只能在原地打转。

把三样东西合起来看,分工其实很清楚。认知决定你能不能判断,感知决定你能不能选对,想象力决定你往哪走。这是边界层的三分法,与 10.1.2 操作层的三步不是同一套坐标。

Agent 把执行这一段的成本压得很低。人的差距,就落在判断、感知和方向上。判断即认知,方向即想象力。

这三个词听着软,落到工程里都很硬。判断错了,架构会返工;感知差了,产品选不对;方向偏了,团队再努力也是白跑。

所以人类在 Agent 时代的定位,不是和 Agent 比谁算得快、写得多。那是它的强项。

人的位置在更前面一点,具体是三个动作。定义问题,是把一句模糊的抱怨拆成一个能回答的问题,并给出验收标准。判断结果,是能看出这个答案在你们的具体场景里站不站得住。决定方向,是选什么值得做:在几个都做得成的选项里,挑那个值得做的。

本书正文写到这里。读者可能会问,普通人到底能做什么。答案不在工具清单里。后面还有一篇后记,谈谈我们自己在这个时代的选择。

文字 CC BY-NC-SA 4.0 | 代码 Apache-2.0