Skip to content

第9章 Agent 的局限性 ​

在前面的章节中,我们系统性地拆解了 Agent 的底层原理、五层能力模型、系统架构以及它带来的生产力跃迁。站在时代的大背景下,从今天往前看,所有人都感觉到这个时代没有 Agent 是万万不能的。

然而,作为一名在软件架构领域探索了 25 年的工程老兵,我更想在这一章给所有的读者注入一针清醒剂:Agent 绝不是万能的。

从本质上讲,Agent 再神奇,它依然是一个运行在硅基芯片上的程序,它的操作介质依然是经过采样、映射和符号化的数据。而人类所生存的,是一个以“原子”为底层依托的物理世界,是一个由复杂的碳基生命、微妙的感官体验、高随机性的环境以及脆弱的社会规则交织而成的复杂体系。

当比特世界的计算,试图全面接管或替代原子世界的运转时,这种介质上的天然落差与逻辑缺陷就会暴露无遗。

了解 Agent 能做什么,能让你快速入门;但深刻理解 Agent 不能做什么、在哪些领域会失效,远比了解它的优点更为重要。只有清醒地划清它的能力边界,我们才不会在盲目的技术崇拜中迷失,才能在复杂的工程实践中避开致命的坑洼,真正做到高效、精准地驾驭 Agent。

本章将从物理依赖、隐性知识、数学逻辑、经济性价比以及治理克制五个维度,为你剖析 Agent 在可见未来里无法逾越的现实局限。

9.1 生产资料高度依赖“原子物理”的领域 ​

第 8 章导语说,技术的本质是人的延伸,并非人的替代。延伸有个前提:被延伸的东西得先能被读取、被改写。

代码、文档、报表可以,一吨钢、一台手术、一栋楼不行。这一节只讨论最硬的一条边界:当生产资料是原子时,Agent 能走到哪一步。

9.1.1 比特能复制,原子只能搬运 ​

人类社会的日常运行,最后都落在原子上。吃饭是原子的摄入,住房是原子的堆叠,看病是原子的修复,出行是原子的位移;比特的消耗在涨,这几样一样也省不掉。

Agent 是纯比特世界的产物。它的输入是采样后的数据,输出是符号或指令。这两端都不产生力、热和位移。它能做的是判断,不是搬运。

比特和原子有一个根本差别,就是可回滚。一段代码写错了,回滚通常只要几分钟;一份报价单算错了,改完重发,成本接近零。比特的复制边际成本趋近于零,错误可以撤销,试错可以重来。

原子没有这个待遇。混凝土浇下去,养护期按天算。普通硅酸盐水泥配制的混凝土要养护 7 天以上;强度达到 1.2 N/mm² 之前不能上人,常温下通常 1–2 天就能达到;28 天是强度评定的标准龄期。浇错了只能凿掉重来。钢材割短了要接回去重新探伤,手术切错了没有 Ctrl+Z。

物理世界还有两个属性,一起把试错空间压小。一是延迟,反馈以小时、天、月计,Agent 的分钟级循环等不起;二是摩擦,搬运、装配、检验都要消耗能量与人力,每一步都有成本。

Agent 的强项是快速试错,而加上前面的可回滚,这三条属性恰好让试错变得昂贵。所以在原子领域,Agent 的输出只能停在建议和方案这一层,落地那一步不归 Agent。

9.1.2 从指令到动作,中间隔着四道关 ​

很多方案把接管想成一条直线:模型出指令,设备执行。真实链路要长得多,至少包括感知、理解、决策、执行四道关。

  • 感知:把物理状态变成数字,温度、压力、位置、图像都要先采样。
  • 理解:把采样数据变成可判断的模型,这一步 Agent 能做。
  • 决策:在约束下选出动作序列,这一步也能做。
  • 执行:把动作序列变成力、热、位移,这一步必须靠执行机构。

四道关里,中间两关 Agent 能过,过不去的是首尾两关。

感知这一端,传感器给的是离散采样。一个 10 Hz 的振动传感器,采样间隔是 100 毫秒。按采样定理,它只能还原 5 Hz 以下的信号。人手对 200–300 Hz 的振动最敏感,手本身的生理震颤是 8–12 Hz,两者不是一回事。采不到的信号,模型再强也补不回来。

传感器的精度还会漂移,标定一次只能管一段时间。温度变了、振动大了、零件磨损了,读数就会偏,Agent 拿到的输入本身已经失真。

执行这一端,机械臂的重复定位精度可以到 0.02 毫米,这是高精度机型的典型值,但抓取成功率和对象强相关。我们见过的产线里,同一台机械臂抓标准纸箱可能到 99.5%,抓软包装、透明件、线缆时会掉到 80% 上下(项目实测,样本有限)。

想把它拉到 99%,往往要换夹具、加视觉、重新标定,成本按项目算。不是按软件授权算。

注意:把实验室里的抓取成功率直接搬到产线,会导致节拍估算失真,整条线的产能规划跟着错。

更麻烦的是长尾。多数工件是标准件,少数异形件偶尔出现。Agent 擅长规则明确的高频任务,而异形件恰好是规则写不全的部分,也是老师傅最值钱的部分。

数字孪生(仿真)能缓解长尾样本不足的问题,但不能消掉映射成本。所谓物理映射机制,是把物理状态变成 Agent 可判断的信号,再把 Agent 的判断变回物理动作的一整套设施与方法。把它建起来、维护住所花的代价,就是这里的映射成本。

仿真可以跑一万次,结果仍然要回到物理世界验证一次。仿真与现实之间的偏差,就是这项成本的隐性部分。

采样失真的主因在传感器,分辨率与漂移决定输入的上限。抓取成功率的主因常在夹具与视觉,不在映射机制本身。长尾的难处是规则写不全、样本又稀。三条共享的只是物理状态与符号之间的互译环节,这个环节还不完整,非结构化场景尤其如此。

传感器负责把状态变成信号,执行机构负责把指令变回动作,具身智能机器人负责把两者组织成一条闭环。

具身智能机器人指机器人本体加控制,是一套系统,不是单个部件。

传感器与执行机构在结构化场景已规模化部署,但部署规模不等于能力上限。传感器受分辨率与漂移限制,执行机构受夹具与对象限制。具身智能机器人在非结构化场景仍偏弱,抓取与长尾样本尤其明显。Agent 的强项便到此为止。

9.1.3 几个行业,同一条边界 ​

先说制造业排产。Agent 能在几分钟内读完订单、库存、设备状态,排出一版周计划,这一步已经能替掉大量计划员的案头工作。

但计划落地要过三关:物料到没到、设备坏没坏、人够不够。任何一关出问题,计划都要重排。Agent 能给出重排方案。它替不了仓库收货,也替不了维修班换轴承。

再看建筑业施工。一个标准层的钢筋、模板、混凝土,工序和工期都有成熟定额,Agent 可以核对图纸、算量、排工序、生成验收清单。

但绑钢筋、支模板、浇筑、养护,仍然是人的动作。一层楼的工期以天计。Agent 的优化空间在少返工,不在把养护期压成几小时。

医疗也一样。影像初筛、病历摘要、指南匹配,Agent 已经能给出可用的辅助结论。但穿刺、缝合、置管还是要医生动手。手术机器人是医生的手加一个稳,不是 Agent 自己上台。责任链条也没变,签字的是医生。

农业、物流、餐饮、护理、维修可以归到一处看。Agent 能根据天气、土壤和市场价格(有期货的品种看期货价)算出明天收哪块地、卖什么价,能排班、能写菜谱、能生成维修工单。

但采摘、分拣、装车,仍然要靠人或者专用设备。端盘子、翻身拍背、拧螺丝,也一样。软果的采摘力度、磕碰程度,至今没有一套通用参数能覆盖所有品种。

这些行业的共同点是,交付物就是一次物理服务。

反过来看软件行业,同样一件事为什么能端到端跑通?因为发布、回滚、扩容都是 API 调用,动作的边际成本接近零。Agent 调错了接口,重跑一次就行,物理世界里没有几乎零成本重跑这个选项。

正反两面指向同一条边界:Agent 吃掉了信息段,把动作段留给了人和专用设备。交付物的原子含量越高,Agent 能吃掉的占比越低。

9.1.4 一条可执行的判断线 ​

那怎么判断一个环节该不该交给 Agent?我们按交付物分三类。

  • 交付物是符号:文档、代码、报表、决策建议,可以端到端交给 Agent,人做验收。
  • 交付物是符号+物理动作:施工、装配、护理,Agent 做前半段,人做后半段。
  • 交付物是原子(物理实体或纯物理动作):冶炼、种植、物流运输、手术,Agent 只做外围的信息汇总与异常提示。

这条线不是永久的。执行机构在进步,成本在下降,能交给 Agent 的占比会往上走。但判断依据不是机器人会不会更便宜,而是三条判据:错误能不能撤销、反馈能不能及时、长尾能不能覆盖。三条里有一条不成立,就别指望全自动。

下面这段代码,是我们内部用的一张粗筛表,也是三条判据的操作化。输入是一组环节,每个环节标注交付物类型、可回滚(代码里记作 reversible)、反馈周期和人工介入比例。输出是建议的自动化方式。

参数对应的判据
交付物类型(符号 / 符号+物理动作 / 原子)错误能不能撤销:决定撤销的代价,越靠近原子越贵
可回滚错误能不能撤销:决定有没有撤销这条路
反馈周期反馈能不能及时
人工介入比例长尾能不能覆盖

第一条判据由两个参数共同回答:可回滚回答有没有退回的路,交付物类型回答退回去要付多少代价。

人工介入比例是个代理指标,估的是这一步里有多少比例必须由现场的人兜底。比例越高,说明越多活落在规则写不全的长尾上,长尾覆盖这一条就越难成立。代码里把“符号+物理动作”记作“混合”。这只是标签更短,不影响判定。

这一段是给需要自己算系数的读者的,可以跳过,直接看后面的结论。

python
# Python 3.10+,无需第三方库
# 用法:python3 screen.py
# 说明:分数用于排序与分档,系数与阈值均为示意值、未标定,只用于相对排序,不作预测。


def pad(s, width):
    return s + " " * (width - sum(2 if ord(c) > 127 else 1 for c in s))


STEPS = [
    # 名称, 交付物(符号/混合/原子), 可回滚(1/0), 反馈周期(小时), 人工介入比例
    ("合同条款比对", "符号", 1, 1, 0.05),
    ("施工进度排程", "混合", 1, 24, 0.30),
    ("仓库拣货", "混合", 1, 2, 0.55),
    ("混凝土浇筑", "原子", 0, 168, 0.80),
    ("精密装配", "原子", 0, 8, 0.65),
]


def score(kind, reversible, feedback_h, human_ratio):
    base = {"符号": 0.9, "混合": 0.6, "原子": 0.2}[kind]
    score = base * (1.0 if reversible else 0.7)
    score *= 1 - min(feedback_h, 168) / 336
    score *= (1 - human_ratio)
    return round(score, 2)


for name, kind, rev, fb, human in STEPS:
    s = score(kind, rev, fb, human)
    if s >= 0.5:
        advice = "可端到端交给 Agent,人工验收"
    elif s >= 0.25:
        advice = "Agent 做前半段,物理动作留给现场"
    else:
        advice = "Agent 只做信息辅助,不接管动作"
    print(f"{pad(name, 14)}得分 {s:<5} {advice}")

在已装 Python 3.10 的机器上直接运行,输出如下:

text
合同条款比对  得分 0.85  可端到端交给 Agent,人工验收
施工进度排程  得分 0.39  Agent 做前半段,物理动作留给现场
仓库拣货      得分 0.27  Agent 做前半段,物理动作留给现场
混凝土浇筑    得分 0.01  Agent 只做信息辅助,不接管动作
精密装配      得分 0.05  Agent 只做信息辅助,不接管动作

排序与三条判据的方向一致:越靠前越适合交给 Agent,越靠后越只能做信息辅助。系数未经标定,只用于相对比较。这张表不是精确预测,它的用处是把争论从“能不能做”拉回到四个参数背后的三条判据上。

四个系数可以说清来历,但不能当成标定值。交付物类型取 0.9、0.6、0.2,对应符号、混合、原子三档,越靠近原子越低。可回滚取 1.0 或 0.7,差别就是撤销代价的粗分。

反馈周期除以 336,等于把它归一到一个两周的尺度。人工介入比例直接折算成可自动完成的份额。系数与阈值均为示意值、未标定,只用于相对排序,不作预测。

还有一处要提醒。0.27 与 0.39 分别贴近 0.25 和 0.5 两条阈值,边界样本必须人工复核。参数动一档,档位就可能翻转,这张表不承担这种精度。

还有两条附加约束。它们不改变上面的判定顺序,但决定这张表能不能用。

先说成本结构。Agent 的边际成本按 Token 计,按我们常用的模型与上下文规模,一次调用几分钱;物理执行的边际成本按人天、设备折旧和停机损失计,改一条产线的回收期通常以年计,项目差异很大。前者可以试一百次。后者试错一次就可能停产。

再说验收标准。物理环节的验收往往写不进 Prompt。焊缝不合格,要看探伤片子;墙面平不平,要靠靠尺。Agent 可以读检测报告,但不能代替检测。

这一节讲的是物理边界,结论只有一句:生产资料是原子的领域,Agent 自身只能停在信息段。动作段要靠执行机构。

但还有一类领域更麻烦,生产资料不是钢和混凝土,而是老师傅手上的感觉、老系统里的隐性记忆。这些东西不是采不到(振动、声音、力矩都能测),而是采到的数据没人说得清对应什么状态。9.2 讨论这条更长的映射路径。

9.2 知识与经验“数字化映射路径极长”的领域 ​

9.1 的边界很清楚:交付物落在原子世界,Agent 就接不住。但还有一类工作,交付物是比特,支撑它的却是难以编码的经验,Agent 照样做不好。

卡点在数据。这类领域的知识没有现成的检索入口,也没有可验证的形式。

这一节先拆一个常见的误解,再看三道路障,最后给出一个可以量化的判断方法。

9.2.1 容错率划出的两类经验 ​

有人会问:绘画、短视频、文案这些也没有公式,AI 不是做得挺好吗?照这个逻辑,所有凭感觉的经验,Agent 都该能学会。

这个推论错在把凭感觉当成了一类东西。它其实是两类,中间隔着容错率。

第一类是高容错的感性创作:错了可以扔掉重来,短视频、插画、广告文案都属于这一类。它的验收方式是从一堆里挑一个,没有唯一正确答案。

创作者一次生成二十张图,挑一张能用的,其余全部丢掉。这个浪费是模式本身允许的。

Agent 在这个结构里不需要理解美。它只要让候选足够多、让人挑得出东西。合格率低一点没关系,数量可以补。

第二类是零容错的硬经验,老师傅装轴承的手感、老系统排障的直觉、手术台上的临场判断,都属于这一类。这里举的是经验的类型,不是领域的介质:装轴承、做手术最终仍落在原子世界(见 9.1);本节关心的是这类经验为何难以数字化。

这些经验同样没写进 SOP。但它们不接受“挑一个”这种做法,装错一毫米轴承就咬死,接错一根线整柜设备就跳闸。

归类看的是容错率,不看隐性程度:显性但零容错的动作,同样在这一类。

两类领域的差别可以用两个函数看清。前者是并联,多试几次就能兜住。后者是串联,每一步都必须对。

python
# Python 3.10+,无需第三方库
def best_of_n(p, n):
    """n 个候选里至少有一个可用的概率;p 为单个候选的合格率"""
    return 1 - (1 - p) ** n

def chain(p, steps):
    """steps 步串联、每步都必须对的概率;p 为单步正确率"""
    return p ** steps

print("单次合格率 0.2,抽 8 个候选:", round(best_of_n(0.2, 8), 3))
print("单步正确率 0.99,串 100 步:", round(chain(0.99, 100), 3))

跑出来是 83.2% 和 36.6%(代码输出为小数,正文已换算成百分数)。同样的模型能力放在两种结构里,结局完全不同。

前者用 20% 的单次合格率做到了 83.2% 的交付成功率。后者单步 99%,已经比大多数人稳定,走完一百步却只剩 36.6%。

这两个都是理想化估计:前者的前提是候选之间相互独立,算出来偏高;后者的前提是各步错误互不相关,方向取决于相关结构,误差正相关时实际更高,负相关时更低。真实系统里这两个前提都不完全成立,但趋势不会变。

所以 AI 会画画这件事,推不出 AI 会装配。前者靠采样兜底,后者靠一次做对。

反过来说,装配车间里也有能被采样的部分,比如拧紧力矩、装配顺序、检验尺寸。这些环节一旦被数字化,可验证性上去了,容错率却没有变。拧错一个力矩照样报废。它们仍在第二类,只是从不可验证变成可验证。

容错率由错误代价与是否可回滚共同决定,数字化改不了它。可验证性由能不能采样、能不能标注决定,数字化可以抬高它。两个轴要分开看。

9.2.2 没有现成的数据载体 ​

第一道路障最难绕,经验没有现成的数据载体。

老钳工车一根轴,靠手掌的震动判断刀具磨到什么程度;老中医号脉,靠指尖的触感分辨脉象。这些判断每秒都在发生,却没留下一个字。

不是没有记录,是判断本身记录不下来。语音转文字能留下他的描述。描述和判断之间,还隔着几十年的手感校准。

数字化的一条可行路径是装传感器,振动、声音、温度、力矩都可以采样。采到的是物理信号,不是判断本身。代价有两项。

一是标注:波形对应什么状态,要请老师傅逐条标。二是泛化:为一个型号的刀具、一种材料标出的模型,换个工况就要重标。

传感器的精度也不是无限的。手掌能分辨的细微震动,换成加速度计之后,还要经过滤波、降噪和特征提取,每一步都会丢信息。

这里没有现成的样本量可以照抄。我们的判断是:只要标注还得靠人逐条做,这条路的边际成本就不会随规模下降。

这就是路径长的第一个来源:不是技术不会,是每个点位都要单独铺一遍。

9.2.3 高于收益的编码成本 ​

9.2.2 说的是数据不存在,要从零采;这一节说的是数据在专家脑子里,编码出来太贵。

第二道路障是经济账。要把资深专家的系统直觉编码出来,变成 Prompt、规则库或决策表,前期投入常常超过收益。

这里的成本分三块:访谈与对齐、规则编写、验证与维护。前两块是一次性的。第三块是持续的。

算一笔账。一位架构师的访谈按 20 天计、每天 2000 元,是 4 万元;300 条规则的编写加验证按每条 200 元计,又是 6 万元,前期投入 10 万元;300 条按每份规范约 150 条估,属示例假设。

2000 元/天按 8 小时折 250 元/时,再假设这套规则每月省下 40 小时、按每小时 300 元计,一年 12 个月,收益是 14.4 万元;收益侧的 300 元/时含外协与加班的机会成本,比内部工时高约 20%。

python
# Python 3.10+,无需第三方库
def roi(interview_days, day_cost, rules, rule_cost,
        saved_hours_per_month, hourly_cost, months=12,
        rewrite_ratio_per_half_year=0.5, maintenance_rule_cost=200):
    """首年成本、净额与回本期;维护费每半年计一次"""
    setup = interview_days * day_cost + rules * rule_cost
    maintenance = rules * rewrite_ratio_per_half_year * maintenance_rule_cost
    monthly_benefit = saved_hours_per_month * hourly_cost

    cumulative, last_negative, shortfall = -setup, 0, -setup
    for m in range(1, months + 1):
        cumulative += monthly_benefit
        if m % 6 == 0:
            cumulative -= maintenance
        if cumulative < 0:
            last_negative, shortfall = m, cumulative
    payback = last_negative + (-shortfall) / monthly_benefit

    cost = setup + maintenance * (months // 6)
    benefit = monthly_benefit * months
    return {
        "前期投入": setup,
        "半年维护": maintenance,
        "首年成本": cost,
        "首年收益": benefit,
        "首年净额": benefit - cost,
        "投入产出比": round(benefit / setup, 2),
        "不计维护回本": round(setup / monthly_benefit, 1),
        "含维护回本": round(payback, 1),
    }

for k, v in roi(20, 2000, 300, 200, 40, 300).items():
    print(k, v)

结果是:前期投入 10 万元;先不计维护,8.3 个月回本,一年收益 14.4 万元,不计维护的投入产出比 1.44,含维护的首年口径为 0.9(14.4 ÷ 16)。

但账还有后半段:规则会过期。系统升级、业务改口径、组织调整,都会让一批规则失效。

维护不是一次性支出,会一直发生。按本例参数,每半年有一半规则要改,半年维护费 3 万元。

首年成本因此是 16 万元,超过 14.4 万元的收益,净额是 -1.6 万元。回本期从 8.3 个月拉长到 13.3 个月,约 1.6 倍。

roi() 只算单团队基准,复用次数不进这个函数。365 倍只说明摊薄幅度,不参与回本计算。若收益也按 250 元/时计,首年净额由 -1.6 万降至约 -4 万,结论方向不变。

注意:把过期规则直接喂给 Agent,会导致旧口径混进新流程,出错后比不用更难排查。

很多项目死在这里。不是做不出来,是首年现金流为负,要十三个月才回本。

这类领域真正该问的是:同一套知识的密度够不够高,复用次数够不够多。密度决定能不能编码,复用决定编码划不划算。

一个简单的判据是复用次数:同一套知识只在一个团队用,按本例要 13.3 个月回本;被更多团队复用,编码成本按次数摊薄,回本期同步缩短。

我们建议先算这笔账,再谈接入。账算不过来,后面的架构设计都是空转。

这是路径长的第二个来源:成本不在建,在养。

9.2.4 只存在于人脑的历史上下文 ​

第三道路障最隐蔽,多数经验不在知识里,在历史里。

运行十几年的工业或金融系统,几乎都有这种角落。下面是脱敏后的示意案例。一个字段叫 flag2,取值 7 时要反向冲正,为什么是 7、为什么反向,代码里没有注释,文档里也没有记录。

知道的只有两个人。一个是当年写这段代码的人,一个是接过三次故障的人。

Agent 拿到这套系统,只能读代码。它看得到 if (flag2 == 7),看不到五年前那次对账事故,也看不到七年前那次重构留下的兼容逻辑。

这类上下文的特点是不可检索:它不在日志里,不在工单里,也不在任何一份文档里。它留在事故复盘的口头结论里,留在当年的邮件里,留在几个人的共同记忆里,还会随人离职而消失。文档补不上,因为写文档的人也不知道。

有一种补救办法,是把专家排障的过程录下来,做成轨迹回放(Trajectory Replay)。第 4 章(轨迹回放)讲的是 Agent 自身调试;录制专家排障是另一条路,要单独建采集与标注。

但它有前提:专家得愿意讲,而且讲得出来。这类判断多是条件反射,问他为什么,他只会说“看着不对”。

到了这一步,这类上下文,Agent 补不齐,也推不出。

这是路径长的第三个来源:上下文只在人脑里,无法批量复制。

注意:依据不完整的上下文下结论,会把猜测写成结论,出错后比不做核对更难排查。

9.2.5 数字化知识密度决定上限 ​

三道路障不是并列的三条。第一道路障最难绕,第二条商业上最常见,第三条最难发现。

三条最终都落在同一组因子上,核心是两个:知识密度与复用次数。

第三条同时压在两个因子上:历史上下文补不齐,能写进规则的知识比例就低,知识密度上不去;它只存在于个别人的记忆里,无法批量复制,复用次数也上不去。

密度是第一个因子。它的定义很朴素:这个领域的关键知识,有多少比例能被写成文字、结构化成规则,并且能被验证。

复用是第二个因子。同一套知识,一年只用十次;一天用十次,一年就是 3,650 次。两者相差 365 倍,编码成本摊到每次上,也差 365 倍。

密度高的领域,Agent 的上限就高。客服话术、代码补全、文档摘要、发票录入,知识基本都在文本里。

知识密度低、总分落在 5 到 7 分的领域,Agent 只能做外围(人做复核与决策)。它可以查规范、调记录、汇总参数,但拍板那一步要留给人。

还有一条底线是容错率。它不随数字化改变,但决定这个环节该不该交给 Agent。

这个判断可以量化。先分清三套工具:9.1.4 的粗筛表筛单个环节,看四个参数:交付物类型、可回滚、反馈周期、人工介入比例。

下面这段评分脚本筛领域整体,两层分数各管一层,不能相加。9.4.3 的放行清单管交付能不能放行,用法写在那一节。9.2.1 的容错率,在这套评分里拆成错误代价与是否可回滚两项。

这段脚本把五个问题等权折算成分数,给出一个粗略的分档;等权是经验分,只用于排序与分档,不代表各项等距。

python
# Python 3.10+,无需第三方库
def score(encodable, has_data, error_cost, reversible, repeat):
    """
    五项各 0-2 分:
    encodable  关键知识可文本化/规则化的比例(0 低 / 2 高)
    has_data   是否有历史数据或日志可查(0 无 / 2 全)
    error_cost 单次错误的代价(0 极高 / 2 可忽略)
    reversible 错误是否可回滚(0 不可 / 2 可)
    repeat     同类任务每年的复用次数(0 个位数 / 2 上千)
    """
    total = encodable + has_data + error_cost + reversible + repeat
    if total >= 8:
        return total, "可考虑端到端"
    if total >= 5:
        return total, "Agent 做外围,人做复核与决策"
    return total, "不建议接入"

for name, kw in [
    ("发票字段录入", dict(encodable=2, has_data=2, error_cost=2, reversible=2, repeat=2)),
    ("精密装配调机", dict(encodable=1, has_data=2, error_cost=0, reversible=1, repeat=2)),
    ("老系统故障定位", dict(encodable=0, has_data=0, error_cost=0, reversible=0, repeat=1)),
]:
    print(name, score(**kw))

五项各两分,总分 10 分。总分只做粗筛,具体动作要看分项。

8 分以上可以考虑端到端,5 到 7 分做外围,1 到 4 分不建议接入。

三个例子的得分是 10、6、1:发票录入可以端到端,装配调机只能做外围,老系统排障 1 分,不建议接入。

这里的分数有两处要说明。发票录入的 error_cost 按示例假设为 2,未计合规与审计成本。装配调机的 has_data 有 2 分,来自力矩与检验记录,但这不等于专家的判断已经可编码。

分数相近的两个领域做法可以完全不同,边界要看分项,不能只看总分。

不必把分数当成精确刻度。它只用来排除明显不该做的场景。

9.2.6 分档之后怎么用 ​

以装配调机为例,它的可编码项只有 1 分,数据项却有 2 分。这说明判断暂时写不成规则,但过程可以留痕。所以先做记录和预警,不做自动调机。

以老系统为例,五项全低。这种地方接入 Agent,主要产出是一份看起来很像答案的错误结论。它比没有结论更危险。

对 1 到 4 分的领域,最明智的工程策略是放弃端到端;只有存在文档化子系统时,才做有限的检索辅助。核心判断不接,留给有隐性经验的人。

这是成本最低的分工,谈不上技术退让。Agent 越便宜,越应该把可数字化的外围交给它;核心判断的机会成本反而更高。

最值得注意的一种例外,是传感与标注成本被摊薄。同一型号、大批量、工况稳定的产线,数据攒得快,模型可以往“外围”这一档挪。前提是可度量、可回滚。

第二种例外是复用次数足够高。同一套知识一天用十次,只要可编码比例不为零,即使密度不高,编码成本也摊得开。

读者可以拿自己手上的领域试一遍。我们试过的领域里,多数得分落在 5 到 7 分之间,这正是 Agent 现在的真实位置。

把这一节收成一句:Agent 的上限不只取决于模型多大,还取决于这个领域的知识有多少被写成了机器能读的形式,又被复用了多少次。

下一节换一个方向。有些领域的知识早就数字化,甚至本身就是纯计算,Agent 依然不能接手:问题出在概率引擎与确定性引擎的分工。

9.3 数学计算与零误差逻辑的领域 ​

9.2 讨论的是知识与经验的数字化映射路径极长、提纯(编码)成本高于收益。还有一类领域更硬:知识早就数字化了,Agent 依然不能接管。这就是数学计算与零误差计算,以及这条边界该划在哪里。

原因不在数据,而在引擎:Agent 的大脑是概率引擎,这类领域要的是确定性。这里的零误差说的是结果精度。零容错说的是业务对错误零容忍。两者相关,但不是一回事。两种引擎的差别,决定了谁能做计算。本节判的是零误差计算:结果精度可被定义、可被核验;零容错是业务态度,不单独构成技术判据。

9.3.1 两种引擎,两种正确 ​

CPU 是确定性引擎:同一输入、同一指令序列,输出逐位相同。它执行数学运算、条件分支、状态跳转与符号推导,结果唯一确定,不会模棱两可。整数运算精确,浮点运算按 IEEE 754 规则舍入,所以“确定”不等于“精确”。

GPU 与 CPU 同属确定性引擎,只是并行度不同。在固定算法与归约顺序的前提下,同一输入仍得到同一输出;一旦累加顺序随调度改变,末几位就可能不同。

为免后文混淆,先把三个词定下来。引擎指执行计算的机制:确定性引擎是 CPU、GPU 这类执行器,概率引擎是以概率模型为核心的范式。工具指 Agent 可调用的外部能力:库、求解器、解释器、数据库。程序指被调用的函数或服务。

概率引擎是一类范式,概率模型是它的实现,大语言模型(Large Language Model,LLM)是其中一种具体模型。这类系统擅长模式识别、语义理解、模糊推理与上下文联想,给出的是概率分布下的最佳拟合,不是唯一解。

Agent 依赖的是后者。业务里充满数值运算、财务结算、物理模拟或密码学校验。这些场景让 Agent 在神经网络内部做长链路硬计算,就是用概率引擎干确定性引擎的活。

打个比方,CPU 像账房先生,算盘珠子拨几下,每一步都按固定规矩,结果可以逐笔复核。LLM 像一位见多识广的顾问,话说得漂亮,但你不能让他替你记账。

顾问可以帮你判断该记哪一笔,记账这个动作必须交给账房先生。Agent 的定位也是如此。

9.3.2 概率引擎做算术,错在哪里 ​

概率引擎并不是完全不会计算,它在训练数据里见过大量算式,能够把常见的结果直接检索出来。问题在于这种能力没有算法保证,只有统计相关性,题目稍微换个数位或换一种表述,结果就可能漂移。具体错在三类。

第一类错误是长链路放大。假设单步计算的正确率是 99.9%,且各步相互独立,连续 100 步之后,整体正确率约 90.5%;连续 1000 步之后,只剩约 36.8%。

这是指数衰减,不是线性衰减,步骤越长,可靠率掉得越快。99.9% 已经是很乐观的假设,真实模型的单步正确率只会更低,长链路更危险。

第二类错误是不可复现。LLM 的采样温度、模型版本、上下文长度都会影响输出,同一个问题问两次,可能得到两个答案。

很多在线服务即使把温度参数设为 0,也不承诺逐位复现相同的输出。原因不只是采样:不同批次的浮点累加顺序不同,硬件差异与模型热更新也会掺进来;同一个请求的末几位可能就不一样。

对创意任务,这种差异不是问题。对账务和审计,它就是不可接受的变量。

在审计场景里,这比错误本身更麻烦:你无法向审计员解释,为什么昨天的账和今天不一样。在同样的版本、环境和输入下,确定性引擎就能复现同样的结果(条件见 9.3.3)。

第三类错误是表示层不对齐。数字进入模型前会被切成 Token,模型看到的是向量,不是数位对齐的竖式。在单次前向、没有外部工具或显式中间步骤时,它没有借位、进位、小数点对齐这些机制。

更准确地说,模型学到的是一套关于数字的语义联想,而不是一套可以逐步执行的算术规则。它知道乘法这个词附近通常出现什么形态的答案,却不会像 CPU 那样按固定规则逐位执行。BIG-bench 的算术(arithmetic)任务里,多位数乘除的失分更明显。这就解释了它为什么偶尔能解开竞赛题,却在这类题上出错。

所以模型能背出“1+1=2”,也能算出常见的乘法,但面对 20 位整数、循环小数、复合单位换算,它是在猜,不是算。

9.3.3 三类必须交给确定性工具的活 ​

下面三类任务,都按“结果精度可被核验”落到判据上。

第一类任务是高精度数值与精确算术。数值矩阵交给 NumPy;符号推导与精确矩阵交给 SymPy。精确账目汇总交给 Decimal 与 Fraction。

NumPy 默认用 float64,适合高性能浮点计算。它不解决 0.1+0.2 的表示误差。把它和高精度混为一谈,是常见的误用。

先从最基础的精度说起。多数十进制小数无法用二进制浮点精确表示(0.5、0.25 这类可以),这是 IEEE 754 标准的固有特性。看一段可以直接运行的代码。

python
# 环境:Python 3.10+,仅使用标准库
from decimal import Decimal
from fractions import Fraction

print(0.1 + 0.2 == 0.3)
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3"))
print(Fraction(1, 10) + Fraction(2, 10) == Fraction(3, 10))

输出是 False、True、True:浮点数的 0.1 和 0.2 相加,结果不是精确的 0.3。金额结算里,这种误差会累积。

注意:用 float 做金额累加会产生舍入误差,最终对账时差几分钱,账目无法平。

精度只是下限,数值推导同样要交给确定性工具。看一个符号积分的例子:Agent 可以负责写表达式,计算和验证交给 SymPy。

python
# 环境:Python 3.10+,pip install sympy
import sympy as sp

x = sp.symbols("x")
expr = sp.integrate(sp.sin(x) * sp.exp(x), x)
print(expr)
print(sp.simplify(sp.diff(expr, x) - sp.sin(x) * sp.exp(x)))

第一次输出 exp(x)*sin(x)/2 - exp(x)*cos(x)/2,第二次输出 0。把结果求导再减回被积函数:差为零,说明积分正确。simplify 是启发式化简。它不能当通用判定器。这里能用,是因为被积函数简单。

第二类任务是必须严格成立的逻辑约束。安全审计、编译优化、协议校验,都属于这一类,系统对错误的容忍度是零。

这类领域的正确工具是解析器、类型系统、模型检查器(model checker)和可满足性模理论(Satisfiability Modulo Theories,SMT)求解器。Z3 是微软研究院开发的常用 SMT 求解器。把约束写成公式交给它,由它给出可满足性或反例。

以支付系统为例,幂等键(idempotency key)的去重、余额的扣减、订单状态的流转,都必须满足严格的不变量(invariant)。这些不变量可以用数据库事务和约束来保证,也可以写成 SMT 公式交给求解器检查。让 LLM 读代码找漏洞,只能作为辅助,不能作为最后一道防线。

Agent 在这里可以做两件事:把自然语言需求翻译成约束,或者解释求解器给出的反例。它不能替代求解器下结论。

第三类任务是高吞吐与高一致性数值计算。高吞吐指调用次数多,高一致性指跨批次逐位一致。批量定价、风险计算、物理仿真,一次要算几百万次,这类活应该交给 CPU 或 GPU 上的数值库。

让 LLM 参与其中,延迟和成本都不划算。一次云端 LLM 调用通常在数百毫秒到数秒之间,取决于模型规模与输出长度。CPU 执行一条加法指令只需纳秒级时间。两者不在一个量级。

这个差距在单次调用里看不明显,放到批处理里就会被放大。假设一天要算 100 万次价格,每次都走一遍 LLM,账单和延迟都会失控。换成数值库,同样的计算可以在秒级完成。

成本只是表面,真正的问题是一致性。在固定硬件、固定库版本、固定归约顺序下,CPU 和数值库对同一输入给出逐位相同的输出。你可以据此写单元测试、做回归、回溯历史。概率模型的输出依赖上下文和采样,测试只能覆盖分布,不能保证跨环境逐位锁定。

再比如报表汇总,Agent 可以把自然语言问题翻译成 SQL,但 SUM、AVG、GROUP BY 这类聚合,工程上最合适的是交给数据库执行。数据库的 DECIMAL 类型能精确保留小数位,执行计划也能被审计。

9.3.4 正确姿势:Agent 当调度员,不当计算器 ​

我们建议把 Agent 放在调度层,而不是计算层。它负责理解意图、补齐参数、选择工具、发起独立校验、解释结论。具体来说,有四条工程规则。

第一,能调用工具就不要心算。让 Agent 生成 Python 代码,由解释器执行;生成 SQL,由数据库执行;生成约束,由求解器验证。

第二,工具契约要写清楚。输入的单位、精度、舍入规则、错误码,都要在 Schema 里定义,不要让模型猜“元还是分”“四舍五入还是银行家舍入(round half to even)”。

第三,验证要独立。Agent 可以发起校验,但校验器必须独立。不要用同一个模型检查自己的答案,那是自己批改自己的卷子。要用另一套确定性程序交叉验证,或者用不变量和边界条件检查。

第四,保留审计轨迹。记录工具调用的输入、输出、版本号和耗时,出错时能复现,才能定位。

四条规则管 Agent 一侧;落地时还有两个系统侧约束。第一个约束是参数校验,它听起来简单,落地时最容易漏掉。模型可能把万元填成元,把含税理解成不含税,工具本身算得再准,输入错了,结果还是错的。所以 Schema 里要写单位、范围和枚举,服务端要再校验一遍。

第二个约束是人工复核无法规模化。如果每一笔计算结果都要人再看一遍,Agent 带来的效率提升就会被复核成本吃掉。真正能规模化的结构,是让确定性程序做自动校验,人工只看异常和边界。

所以正确的工程顺序是先把计算逻辑写成可测试的函数,再让 Agent 去调用这个函数。函数负责正确,Agent 负责灵活,两者各司其职,系统才不会把灵活性建立在不确定的算术之上。

注意:把未经校验的模型输出直接写进合同、账本或控制指令,错误会沿着下游流程扩散,事后追溯只能靠日志。

9.3.5 什么时候仍然可以用 Agent ​

看到这里,读者不要走向另一个极端,不是所有带数字的任务都要拒绝 Agent。

把任务拆开看,真正不能放手的是最后一步,也就是数字进入合同、账本或控制指令的那一刻。

判断的主标准是两条。第一,错误能否被低成本地发现和回滚。第二,错误代价是否远高于确定性工具(不含验证器)的建设成本。

这两条标准之前,还有一个前置门槛:验证器本身也要开发。写一个能独立检查答案的程序,难度有时不低于直接解决问题,这在形式化验证里很常见。如果验证器建不起来,Agent 的输出就只能靠人看,规模一大就会失控。

门槛过了,再看两条标准交叉出的四种组合,处置并不一样。

错误能否被低成本地发现和回滚错误代价是否远高于确定性工具(不含验证器)的建设成本处置
能否Agent 可以参与,人工验收,比如生成报表草稿、提炼会议纪要里的数字、把自然语言需求转成计算脚本
不能是最终计算权交给确定性工具,Agent 只做外围的翻译、编排和解释
能是优先建工具;工具建成之前,Agent 的输出必须经独立校验加人工验收
不能否不用 Agent 做最终计算,改流程、加人工复核,或者直接拒绝

验证器是前置门槛,单列,不计入工具成本。

后两种组合共用一条原则:拿不准的时候,按更保守的一条走。

因此,判断标准可以再收紧成一句口诀:先看错了能不能便宜地发现和回滚,再看这个错误值不值得为它建确定性工具。数字要写进合同、账本或控制指令,就先问一句:错了能不能自动发现?如果答案是不能,或者发现成本高于人工从头做一遍,那么最合理的选择就是不用 Agent 做最终计算。人工从头做一遍,是工具成本的可比基准,不是第三个比较对象。

这条边界,和 9.2 的结论是一致的。9.2 的门槛是知识与经验的数字化映射路径极长、编码成本高于收益,属于会随工具降价移动的成本边界。9.3 的门槛是零误差计算不能交给概率引擎,属于硬边界。工具换代只移动 9.2 的成本边界,不改变 9.3 的硬边界。两节说的是同一件事的两面:门槛没过的环节,交给人和确定性工具把关。

到这里,三类局限已经清楚:原子世界的物理依赖、数字化映射的路径问题、零误差计算的概率短板。下一个问题更实际:面对具体业务,我们到底该在什么时候拒绝 Agent。9.4 给出判断框架。

9.4 什么时候拒绝 Agent ​

9.1 到 9.3 划的是三类领域边界:生产资料依赖原子;知识与经验的数字化映射路径极长,提纯(编码)成本高于收益;结果要求零误差。三类边界都写在业务属性里。但它们不是同一类边界。

9.1 和 9.3 是硬边界,换团队、换模型、换一代产品,它们都不会移动。9.2 是成本边界。工具降价、数字化程度提高,它的可行区间会移动。

本节要讨论的是另一类边界,它不写在业务里,写在用法里。同一套 Agent,用对了是杠杆,用错了就是负债。

差别不在模型能力,在有没有人验收结果,更在出错之后由谁承担,这一层才是工程问题。本节给两条拒绝线。

一条对着“一键躺平”的工具宣传,一条对着“无需专业即可跨界”的妄念。两条线背后是同一个判断:结果由谁验收,责任由谁承担。

Agent 不签字,签字的必须是人。这句话听着简单,落到项目里就是验收标准归谁定,出了事又由谁去改。责任不能外包。

两条线走完,9.4.3 把它们收进一张放行清单,作为全章的收束。所以本节的结构是两条拒绝线,加一张放行清单。

9.4.1 全自动交付的边界 ​

责任既然不能外包,就先看那些宣称不需要人负责的工具。市场上这类工具的描述高度相似。一键托管、自动涨粉、自动成交、躺着收钱,四句话覆盖了这几类工具的主要卖点,也回避了全部责任。

它们的共同点,是把“执行”和“交付”混成一件事,执行是一个动作,交付是结果被别人接受。其实是两件事。

Agent 能把执行做得非常便宜,便宜到接近零边际成本,便宜到可以每天重跑一遍。但结果是否被接受,不由它决定。

我们见过的最常见的失败,不是模型不会写,而是它写得很像样。像样到没人看得出来哪里错了,包括写它的人自己。问题不在能力,在可观测性:失败不报错,只体现在结果上。

假设有一条内容发布流水线,Agent 每天生成 20 条文案,自动发布到三个平台,中间没有人复核。前三天数据正常,第四天开始掉推荐量,后台看板还显示正常。

原因是其中几条文案踩了平台的营销内容规则。Agent 没有“这会被限流”的先验知识,平台规则也不在它的上下文里。

它只是按模板把关键词填进去,然后如实返回一个成功状态。这个错误不会在流水线里报错,指标要到两天以后才掉下来,报警规则也没覆盖这一类。

不报错才可怕,等你发现的时候,流水线已经跑了将近一周。

换个场景更直接,后果也更贵。财务对账时,Agent 把两笔金额相近的订单判成同一笔,然后自动核销掉其中一笔。这笔账没有人认。

系统状态是干净的,账却是错的,等到月度对账时,这笔差额已经沉在 30 天的流水里,追起来要翻每一笔凭证。如果月度对账也没人认真做,这笔差额就一直挂在账上。

一条没有人的全自动流水线,等于把监控一起关掉了。

Agent 的定位是杠杆,它放大的是你已有的判断,也包括错误的判断。目标给得模糊,它就把模糊的目标执行成 20 条方向各异的产出,然后等你挑。

验收放得松,它就把松标准执行到底,还会给你一份漂亮的通过报告。这是杠杆的物理属性。杠杆不会替你负责。

任务能不能无人值守,就看无人值守三条件是否同时成立。

  • 幂等(idempotent):同一操作执行多次,对系统状态的影响与执行一次相同,响应可以不同
  • 可回滚:出错后能退回上一个已知正确的状态
  • 有独立监控:失败能被外部指标发现,不依赖 Agent 自报

无人值守三条件全满足,才可以无人值守,这三条是准入门槛。无人值守指执行期无人盯守,验收与异常处置仍有人。缺一条,就必须保留人在回路(Human-in-the-loop)。

这三条挡得住可观测的失败,挡不住语义与方向错误。所以无人值守不等于无人验收,仍要在验收与异常处置两个日常抽检节点上留人抽检。定目标只在启动时签一次,不计入日常抽检。三者合起来是人在回路三节点。

人在回路三节点,不是“偶尔看一眼”:每个节点都由人签字,留记录,记录要能追溯。少一个,人就还没有真正回到回路里。

第一个是定目标,目标里出现“更好”“更合适”这类词,就得由人先拆成可以判定的条件。拆不出来,说明目标本身还没想清楚。

第二个是验收,产出能不能用,要有人能在 15 分钟内给出对错,并且为这个结论负责,而不是口头说一句还行。

第三个是异常处置,也是最容易被省略的一个。遇到训练分布之外的状态,模型倾向于给出一个看起来合理的动作,而不是停下来问一句。

三个节点里,验收最不能省。它是唯一能在交付之前挡住“看起来对”的环节。验收先于信任。

9.4.2 跨界使用的前提 ​

第二条拒绝线,对着“人人都是程序员、剪辑师、操盘手”的说法。这话在工具层面成立,在交付层面不成立。

Agent 确实能在几分钟里写出一个能跑的函数,也能剪出一条能看的片子。工具的门槛,它确实压掉了。

但交付需要判断,判断需要积累,积累没有捷径。工具门槛降下来,判断门槛并没有跟着降,这才是跨界的真实成本,而且这部分只能自己付。

短视频的壁垒,第一层在选题、前三秒和情绪节奏,在判断哪一条会被人转发,剪辑只是表层。更深的壁垒,是对平台推荐机制的理解。

Agent 能一次生成 100 条素材,问题在于选哪一条,以及为什么这一条能起量,那一条不能。这个选择靠你对受众的判断,模型的知识帮不上。

判断不了,100 条就只是 100 份素材。数量从来不解决方向问题,方向错了,产量越高,废料越多。方向比产量重要。

软件工程更明显。Agent 写的代码通常语法正确,单元测试也能过,看起来可以直接合并,评审会上也不容易挑出毛病。

出事的地方在单测之外:并发、重试、缓存一致性、事务边界,以及跨服务调用失败后的补偿。这五项单测通常覆盖不足,要靠压测和线上观测补。补不齐就等着出事。

让 Agent 给支付接口加重试,它会加一个循环,加一个 sleep,再补一段日志。

但非幂等操作的重试必须配幂等键。否则第一次其实成功了、只是响应超时,第二次调用就是重复扣款,对账时才会发现金额翻倍。重试不是重跑。

HTTP 规范(RFC 9110《HTTP Semantics》§9.2.2)对幂等的定义是:同一请求执行多次,对服务器状态的影响与执行一次相同。这一定义只适用于 PUT、DELETE 与安全方法(safe methods),POST 通常不幂等。

重试逻辑不满足这个定义,就不该上线。少了幂等键这个缺陷,常规单测跑不出来;用故障注入可以复现,压测或对账时最容易暴露。

一个没做过支付系统的人,看不出这里少了什么,他会觉得重试就是多试几次。他不知道的是,重试之前要先保证幂等。

这正是 9.4.1 的幂等条件。在这里,它是重试能不能上线的前提,不只是支付系统的特殊要求。

这就是“一看就会,一做就废”的技术解释:教程给的是步骤,专业给的是步骤失效的边界,边界那一半没人教。

所以跨界不是不行,是有前提的,这个前提还得自己攒。这个前提是验收能力:写不出来,但判得出对错,能指出哪一项合格、哪一项不合格。判断力没法外包。

跨界三检验,任何一个答不上来,就先别让 Agent 独立做这件事。检验的是你自己。常规验收 15 分钟,跨界判断放宽到 30 分钟,多出来的时间用来补领域背景。

  • 能否在 30 分钟内判断一份产出的对错(鉴赏力:对好坏的快速判断)
  • 能否说出这个领域三个典型的失败模式(失败模式储备)
  • 能否给出三个以上验收样例,其中至少一个反例(标准固化程度)

三条都过,Agent 是加速器。过不了,Agent 是放大器。产量不是答案。

用极高的效率生产专业垃圾,比低效率更糟,因为它看起来像成品。垃圾还要花时间清理,清理成本也按产量放大。

9.4.3 拒绝清单与放行条件 ​

把本章前三节的领域边界,加上本节的两条用法边界,收进一张放行清单。上项目之前过一遍,比事后复盘便宜得多。

五条红灯:命中任何一条,先不要上无人值守的 Agent。

  • 生产资料是原子,Agent 只能做信息段,做不了动作段(对应 9.1)
  • 知识与经验的数字化映射路径极长,编码成本高于收益(对应 9.2)
  • 数学计算与零误差逻辑,结果必须可证明绝对精确(对应 9.3)
  • 没有可执行的验收标准,只有“看着还行”(对应 9.4.1)
  • 出错之后找不到具体的人担责(对应本节导语)

前三条来自本章前三节的领域边界。9.1 与 9.3 是硬边界,换工具也改不了。9.1 的三条判据不移动,可交付占比会随工具进步移动。9.2 是成本边界,会随工具降价和数字化程度提高而移动。硬上只会把成本推到下游,让错误在更贵的地方暴露。

后两条来自本节的两条用法边界。它们是工程选择,可以改。按我们经手的项目看,多数“不能上”其实卡在后两条,改造之后可以再上。

前面三套工具各有分工,不能相加:9.1 的粗筛表筛单个环节,9.2 的密度评分筛整个领域,9.3 的四象限表定该不该建确定性工具;这张放行清单管交付。前三套决定值不值得做,这一张决定能不能放行。

改造的方向只有一个:把“信任 Agent”换成“验证 Agent”。验证要落到脚本,口头约定不算验收标准。

下面是一个最小验收脚本,环境是 Python 3.10 及以上,只用标准库。核心只有这个 check(),FIELDS 与 MAX_AMOUNT 定义在完整脚本里。

python
def check(payload: dict) -> list[str]:
    errors = [f"缺少字段 {k}" for k in FIELDS if k not in payload]
    errors += [f"字段类型错误 {k}" for k, t in FIELDS.items()
               if k in payload and (isinstance(payload[k], bool)
                                    or not isinstance(payload[k], t))]
    amount = payload.get("amount")
    bad = isinstance(amount, (int, float)) and not isinstance(amount, bool)
    if bad and not 0 < amount <= MAX_AMOUNT:
        errors.append(f"金额越界 {amount}")
    return errors

跑法只有两行,第二条命令打印上一条的退出码。

bash
python3 accept.py < out.json
echo $?

退出码 0 表示结构合格,1 表示拒收。流水线只看退出码,不看模型的自评。脚本不认人情。完整脚本见本书配套资料,另外处理了非法 JSON、非对象输入与布尔值冒充数字。

注意:验收脚本只校验结构、不校验语义时,字段填错位置也能返回 0,错误会留到下游对账才暴露。

脚本挡得住缺字段、类型错、金额越界,挡不住语义错位、字符串格式与多余字段,更挡不住方向错误。语义这一层没有脚本可写。它只能靠人看,而且看的人得懂行。

任何自动化管线都同理。每一步留产物,能退回上一版。自动检查脚本跑一遍,退出码非 0 就不合并。

有人觉得写验收脚本是给自己找麻烦。麻烦在前面,省在后面。这笔账很好算。返工一次的成本,远高于写一次验收脚本。

脚本只是“可验收”的一个实例,放行还要看另外两条。

放行三条件:可拆分、可验收、可回滚。三个词都不新鲜,难的是做到,做到之后还要维护。

这三套不是同一组:无人值守三条件管准入,人在回路三节点管签字位,放行三条件管交付放行。只有无人值守三条件与放行三条件共用可回滚;人在回路三节点管的是签字位,不参与这组比较。

可拆分,指任务能切成边界清楚的步骤,每步有输入和输出,没这个前提,验收就无从下手。

可验收,指每步的结果能被脚本或人快速判对错,不需要反复解释背景。条件写不出来,就说明这一步还没定义清楚。

可回滚,指的是出错之后能退回上一个已知正确的状态,而不是从零重来,这要求每一步都留版本。版本就是退路。

三条都满足,Agent 的产能才能变成你的产能。缺一条,Agent 产出的是待清理的中间状态。中间状态最贵。

回到本节的问题:什么时候拒绝 Agent。领域上,拒绝原子依赖,拒绝编码成本高于收益的经验领域,拒绝必须绝对精确的计算。

用法上,拒绝没有验收的全自动交付,拒绝没有判断力的跨界。拒绝不是保守,它把有限的注意力放在杠杆最长的那一段。

Agent 的价值不在无所不能,也不在替人做决定。它在于边界划清之后,每一次产出都有明确的验收路径,不可验收的部分能被及时发现。看清它不能做什么,才有资格谈接下来能做什么。

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