AI 一做长任务就拉胯：把任务画成一张图，小模型也能赢大模型

副标题：从「原子任务图」到「地平线鸿沟」，五篇 2026 年前沿论文看智能体规划的结构革命

导读：大模型单步答题越来越强，一进入需要连续干几个小时的任务却频繁翻车：忘了早先的决定、把干了一半的活宣布完成、悄悄偏离目标。这个差距，学界称之为「地平线鸿沟」。华南理工与清华深圳的研究团队给出了一种解法：把任务画成一张显式的任务图，按图执行，能并行的并行，出错只修局部。只用 70 亿到 80 亿参数的开源小模型，就在 ALFWorld 和 WebShop 两个基准上超过了 GPT-4 驱动的传统方法（63.65 对 41.24，68.36 对 64.34）。本文综合 5 篇 2026 年前沿论文，讲清三件事：AI 做长计划为什么难，学界给出了哪几条解法，以及这对你的日常使用意味着什么。

第一章单步聪明，长程拉胯

先给结论。华南理工大学与清华大学深圳国际研究生院的联合团队，在 2026 年 7 月发布了一项名为「原子任务图」（Atomic Task Graph，简称 ATG）的研究。他们做的事情，是把 AI 解决多步任务的方式，从「边想边做的一条长文本轨迹」改成了「先画一张显式任务图，再按图执行」。结果有点出人意料：只用了 70 亿到 80 亿参数的开源小模型，就在三个长程任务基准上全面超过了 GPT-4 驱动的传统方法：在 ALFWorld 家务模拟上得分 63.65 对 41.24，在 WebShop 网购模拟上 68.36 对 64.34。同一时期，还有四篇论文从不同角度逼近同一个问题：为什么 AI 单步很聪明，一做长任务就拉胯，以及怎么治。这篇文章把它们放在一起讲，希望你看完能明白三件事：长任务难在哪，学界给出了哪几条解法，以及这些解法对你的日常使用意味着什么。

1.1 一道题秒答，一个项目翻车

先做个思想实验。你让一个顶尖大模型回答「地球到月球的距离」，它几乎不会出错。你让它写一段 50 行的 Python 代码，它也大体靠谱。但你把同一个模型放进一个智能体循环里，交给它一个需要连续干几个小时的任务，比如维护一个软件仓库、规划一次跨国旅行、管理一个电商店铺，问题就来了。

《地平线鸿沟》（The Horizon Gap）这篇 2026 年 8 月的综述，开头就描述了这种怪异现象：前沿模型可以在一轮前向计算里解决几年前还算得上研究贡献的推理题，同一个模型一旦被装进智能体循环、要求完成一个以小时计的任务，就会以单步评测永远发现不了的方式失败：忘了早先做过的决定，把干了一半的活儿宣布为完成，或者悄悄偏离最初的目标。这些话读起来很像人类员工在长期项目里的疲惫走神，但它发生在每次调用都从零开始、理论上不该「累」的模型身上。这不是某一个模型的毛病，而是这个领域普遍存在的现象。

更麻烦的是，这类失败很难在测试阶段暴露。单步评测给模型的是一道题，它答对就算对。长程任务给模型的是一连串互相依赖的决策，任何一步的偏差都会在后面的步骤里被放大。你在聊天窗口里测试一个模型，永远测不出它会不会在第四十七步突然宣布任务完成。原因很简单：测试本身根本没有第四十七步。

这种「单步很强、多步拉胯」的反差，就是整套故事的核心。它意味着，问题可能不在模型本身，而在模型周围那套组织多步行动的系统。

1.2 「地平线鸿沟」是什么

《地平线鸿沟》的作者给这个现象起了个名字：地平线鸿沟（horizon gap），定义为「模型单步能做什么」与「围绕它的系统在多步上能可靠完成什么」之间的距离。他们用了相当扎实的功夫来论证这个问题值得研究：系统性采集了 2024 到 2026 年间 1547 篇 arXiv 论文，做了两阶段离题过滤，剔除了 26.8% 的原始命中（主要是经典多智能体强化学习、机器人操作和时间序列预测），再定向补充了 128 篇理论安全方向的文献，把整个领域对长程智能体的回应梳理成六大类：规划与分解、记忆与上下文管理、执行控制与恢复、长程训练、评测与度量、基础限制与安全。

为什么要把「鸿沟」单独拎出来命名？因为它在现实中确实拦住了人。模型能力涨得再快，只要「可靠完成长任务」这关过不去，AI 就只能当参谋，当不了执行者。你可以让 AI 帮你起草一份方案，但不敢让它独立跟进一个项目到交付。这个差距，就是所有长程智能体产品的成本线。

综述作者在梳理这 1547 篇论文时，发现了一个横跨所有类别的结构规律：随着任务变长，只看最终结果的信号会变得越来越没用。所谓最终结果信号，就是「一个奖励、一次通过或失败的判定」。任务只有三步时，这个信号够用；任务有一百步时，你只能知道它失败了，却完全不知道失败发生在哪里、为什么失败。于是整个领域都在做同一件事：制造更密集的、逐步的信号，训练侧用过程奖励模型和信用分配，评测侧用轨迹级诊断替代通过失败判定。这个规律在后面讲 OTAP 那一章会再次出现，它是理解评测变革的钥匙。

综述里还报告了一个趋势：以固定可靠度为门槛，前沿模型能完成的任务长度（按人类完成时间计）在最近几代模型间近似指数增长。换句话说，AI 能干的长活正在变长，而且长得很快。但作者很谨慎地标注，这只是「测得并报告」的趋势，不是铁律。「同一个任务」跨模型世代是否可比、基准上的人类时间能否推广到真实部署，都有争议。

重点在于：即使能力在涨，可靠完成长任务这件事，仍然是模型能力之外的另一个问题。能力跑在了可靠性前面，中间的差距就是鸿沟。而填补这道鸿沟的，未必是更大的模型。

这篇综述还提出了三个开放问题，值得做产品的人留意：长程能力到底有多少在模型里、多少在模型外面的脚手架（harness）里；训练和评测用的过程信号如果共享同一套假设，会不会带来关联偏差；以及长程可靠性到底有没有普遍可预测的理论。这三个问题没有一个有现成答案，但它们划出了未来几年研究的战场。

1.3 三个词别混：长程任务、长上下文、长期记忆

这篇综述最有用的贡献之一，是澄清了三个经常被混用的概念。

长程任务（long-horizon），说的是任务本身的属性：完成它需要多少步。长上下文（long-context），说的是模型的属性：它一次能看多少 token。长期记忆（long-term memory），说的是系统的属性：信息能不能跨步骤、跨会话保留下来。

三个词看起来像一回事，其实是三根独立的轴。一个长程任务可以不需要长上下文，把每步要用的信息单独喂给模型就行；一个模型可以上下文很长，但没有任何记忆，窗口一关就全忘；一个系统可以记忆很持久，但任务本身只有三步。举一个具体的例子：让 AI 在一天里分三次完成同一项调研，每次都是新会话。任务是长程的（跨越三个时段），上下文却每次都是短的；如果每次会话之间能保留一份进度笔记，那就是长期记忆在起作用。这三个属性完全可以自由组合，讨论时却常常被当成一件事。

把这三根轴混在一起讨论，最常见的后果就是在错误的层级排查问题：任务变长失败了，以为是上下文不够，拼命加窗口，结果真正缺的是步骤之间的依赖管理；以为是模型记性差，拼命加记忆，结果真正的问题是每一步的决策压根没有结构可依。地平线鸿沟综述里反复强调的，正是这种诊断上的混乱比技术本身的缺陷更耽误事。

这个澄清为后面所有章节立下了坐标系。我们讲的「规划」，落在这三根轴之外的另一根轴上：不改变模型、不改变记忆，只改变「多步行动怎么被组织」。这也是接下来几篇论文共同的立场：与其等模型变强，不如把周围的组织结构做对。

1.4 五篇论文要讲的故事

接下来五篇论文，正好是从不同角度回答「长任务为什么难、怎么治」。

原子任务图（ATG）是主角，它给出最完整的解法：把任务画成图，按图执行，出错只修局部。它的实验横跨三个基准、三个开源模型，结论是结构带来的收益可以稳定复现，甚至让 80 亿参数的小模型在两项基准上超过 GPT-4。图增强树搜索（GATS）走了一条相反的极端路线：规划时干脆不调用大模型，靠系统性搜索加分层世界模型，在压力测试里做到 100% 成功，规划阶段的大模型调用次数是零。自进化世界模型（WorldEvolver）给智能体装上「预演未来」的能力，同时警告我们：预演质量差反而有害，所以它加了一道「没把握就闭嘴」的闸门。最优传输轨迹评测（OTAP）回答「怎么知道一条轨迹规划得好不好」，结论是只看成败在长任务里越来越没用，得把轨迹画成图再算距离。而《地平线鸿沟》综述提供了把这一切串起来的框架。

五篇论文，五个角度，指向同一个结论：让 AI 可靠地干长活，关键不在更大更聪明的模型，而在更聪明的结构。小模型加上一张任务图，就能在不少场景里打赢大模型加裸循环。这个结论对每一个把 AI 当生产力工具用的人，都有直接的参考价值。接下来的每一章，我们会把其中一条路拆开看：问题出在哪，解法长什么样，数据怎么说，以及它有什么边界。

第二章问题出在哪：线性轨迹的三个坑

上一章我们确认了症状：AI 单步聪明、长程拉胯。这一章要回答病因：为什么按现在的主流做法，长任务注定会越做越乱。答案藏在「怎么做」里。现在绝大多数智能体，是沿着一条越来越长的文本轨迹，一步一步往前走的。把这条路看清楚，后面的解法才有落脚点。

2.1 现在的主流做法：边想边做（ReAct）

线性轨迹与任务图：左边一颗红珠碎裂带动整串歪斜，右边同一批珠子组成网状结构、红珠被单独圈出

先认识一下当下最普及的智能体工作方式，它有一个名字叫 ReAct（Reasoning and Acting，推理与行动）。这个名字听起来很学术，机制却非常朴素：模型每走一步，先写一句「思考」（Thought），再选一个「行动」（Action），比如调用一个搜索工具或者点一个按钮；环境返回「观察」（Observation），也就是结果；然后模型把这三样东西全部追加到自己的上下文里，进入下一步。

举一个具体的场景。让一个 ReAct 智能体去「帮我在网上找一台 5000 元以内的笔记本电脑，要求续航长、重量轻」。它的工作方式大致是：思考「我需要先搜索笔记本」，行动「打开购物网站搜索」，观察「返回了 30 条结果」；然后思考「我需要按价格筛选」，行动「点击价格区间」，观察「剩下 12 条」；再思考「我需要对比续航参数」……每一步都依赖前面所有步骤留下的文本。这个过程本身没什么不对，但它埋下了后面三个坑的种子。

听起来很顺。问题在于，这个循环里没有任何「计划」的概念。模型每一次决定下一步做什么，都要把从第一步到现在的全部历史重新读一遍。它没有一张地图，只有一条走过的路。走对了，这条路是经验；走错了，这条路就是负担。

ATG 论文在开头画了一张对比图，把这种范式和它的方案并排放在一起：左边是线性决策范式，任务、轨迹、依赖像一根绳子上的珠子，一个错误嵌在某颗珠子里，前后珠子全都受影响；右边是任务图，错误被圈在一个小区域里，可以单独修补。这张图是整个研究动机的缩影：线性结构本身，就是长任务失败的温床。

2.2 坑一：越做越长，越长越容易幻觉

第一个坑是上下文膨胀。ReAct 每走一步，历史就长一截。任务做到第五十步，模型眼前就是一大段自己写的思考、自己做的动作、环境返回的观察。这段历史里既有用信息，也有大量噪音，还有早期错误留下的坏影响。

模型要从这一大团文字里找到「我现在到底在哪、接下来该干嘛」，这本身就越来越难。ATG 论文给了一个很有说服力的数字：在 ALFWorld 家务基准上，ReAct 有 42.86% 的轨迹包含无效或幻觉动作。所谓幻觉动作，就是模型生成了环境里根本不存在的操作，比如对不存在的物体说「拿起来」。轨迹越长，这类动作越多，因为模型越来越分不清哪些历史是真实的、哪些是它自己编的。

直观理解：一个人如果每做一步都要把整本工作日志从头读一遍，读到后面他也会开始胡言乱语。模型的「上下文」就是它的工作日志，日志越长，注意力被稀释得越厉害。而 ReAct 体系里，模型没有别的选择，它必须读完所有历史才能决定下一步，因为没有任何外部结构替它记住「哪些信息仍然有用」。

2.3 坑二：一步错，步步错

第二个坑是错误传播。在 ReAct 的线性轨迹里，每一步都建立在前一步的基础上，前面错了，后面所有的判断都会跟着歪。

这有点像多米诺骨牌，但比多米诺骨牌更隐蔽：它不一定是立刻倒塌，而可能是「带病前进」。模型在第 10 步误解了某个状态，第 11 步的推理就会基于这个错误理解，第 12 步又基于第 11 步的结果……每一步的错误都会叠加、变形，最终和最初的失误看起来毫无关系。等到任务失败，你回溯现场，会发现问题根源可能埋在第 10 步，而第 10 步看起来完全正常。

更麻烦的是，在长程任务里，错误远非「算错了」这么简单。ATG 论文指出，线性范式下错误与前序步骤耦合在一起，沿着轨迹传播；随着文本上下文不断增长，后期阶段还更容易产生幻觉动作。两个问题叠加，长任务的成功率就会断崖式下跌。数据上也确实如此：在 ScienceWorld 科学推理基准上，ReAct 用 80 亿参数模型只能拿到 23.67 分，而 GPT-4 版本的 ReAct 也才 66.16 分。注意，这是人类五年级学生能做的科学实验题。

有个细节值得展开：错误传播不一定是「一步错步步错」那么直白。模型在早期步骤里可能没有错，只是漏了一个关键信息；这个缺口会在后续推理里被模型用猜测填上，猜测又变成下一轮推理的「事实」。等到任务结束，你检查每一步，发现每一步都「合理」，但整体结论是错的。这种隐性的错误积累，比显性的执行失败更难抓，因为它藏在推理链条的内部，单看任何一环都看不出毛病。

2.4 坑三：出了错，不知道修哪里

第三个坑最致命：失败无法定位。既然整个任务是一条线，那么任何一个环节出错，你都很难说清楚是哪里错了。修复的时候，常见做法有三类：继续修正（错了就再试一次）、回溯（退回某一步重来）、或者干脆整个重新规划。这三类做法的共同点是：不管三七二十一，把已经做对的部分也一起推倒重来。

想象一个装修现场：墙砌错了，正确的做法是把那面墙拆了重砌，其他房间照常施工。线性范式的做法却是把整栋楼推倒重建，因为施工队根本不知道是哪面墙错了，甚至不知道墙错了。他们只知道最后验收没过。

换到智能体身上，同样的困境放大了好几倍。一次重规划不是「推倒重来」这么轻巧，而是要把已经消耗的 token 再烧一遍、把已经验证过的中间结果全部作废。任务越长，作废的成本越高，智能体就越不敢停下来纠错，于是错误被继续带着走，直到彻底失败。ATG 论文里对比的几类基线，修复方式基本都是这三种：继续修正、回溯、或者整个重规划，没有一种能做到「只修错的那部分」。

这就是为什么 ATG 团队认为必须换一种组织方式：让任务的依赖结构显式可见。依赖关系一旦画出来，哪一步依赖哪一步、哪里错了、哪些部分仍然有效，就一目了然。有了结构，才能谈得上定位和局部修复。这也是「任务图」这个想法的起点。下一章，我们来看这张图具体怎么画、怎么用。

这一章的结论还有一个更广的含义：当我们抱怨「AI 智能体不靠谱」的时候，很多问题其实不是模型的问题，而是默认的工作方式太简陋。给模型换一种组织方式，往往比换一个更大的模型更便宜、更有效。这个判断会贯穿后面的每一章。

这一章的三坑总结下来就是一句话：不是模型不够聪明，是组织方式把聪明浪费掉了。把多步任务当成一条线来推进，就等于放弃了定位、并行和复用的一切可能。要治这个病，得先换坐标系。

第三章解法一：把任务画成一张图

3.1 菜谱流程图：任务图的直觉

做饭这件事，没人会凭空乱做。你心里其实有一张流程：先洗菜、再切菜，这边起锅烧水，那边顺手腌肉。有些步骤有先后，菜不洗就没法切；有些步骤能同时干，烧水和腌肉谁也不等谁。把这套「先做什么、后做什么、什么能一起做」画出来，就是一张流程图。

菜谱流程图的精髓，在于它同时讲清了两件事：顺序和并列。哪一步必须在哪一步之后，这是顺序；哪几步可以同时开工，这是并列。少了其中任何一维，这张图就不完整。只写顺序，你会傻等；只写并列，你会乱套。

AI 做长任务，本质上也在做菜。它要查天气、订票、比价、下单，每一步都调用一个工具。把这些步骤也画成一张任务图：每个圆圈代表一步操作，每条箭头代表「这一步的产出喂给下一步」。图里的箭头只能朝前走，不能绕回来，这就是计算机里说的「有向无环图」（Directed Acyclic Graph），简称 DAG。「有向」是说箭头都有方向，「无环」是说沿着箭头走，永远走不回起点。要是能绕回来，任务就会卡进「先有鸡还是先有蛋」的死循环，永远做不完。

图中的箭头，就是「依赖」。查完天气，才知道要不要带伞；知道了要不要带伞，才能给出穿衣建议。没有依赖关系的步骤，谁先谁后都无所谓，甚至可以同时做。这张图最大的好处，是把「谁依赖谁」这件事，从模型的脑子里搬到了纸面上，摊开来给人看。

上一章讲的 ReAct，是边想边做、走一步看一步，像一条越拉越长的录音带。而任务图，是动手之前先把整条路画出来。这个差别，决定了后面所有事：能不能并行、出了错能不能定位、要不要从头重来。

3.2 递归编译：大任务拆到原子步骤

那么问题来了：这张图，谁来画？答案是模型自己画，但不是一步画成。原子任务图（Atomic Task Graph，简称 ATG）的做法，是「从粗到细」地画。

举个例子。你丢给模型一句话：「查北京明天天气，并给出出行建议。」模型不会一上来就把它拆碎，它先画一张很粗的图，可能只有两个圆圈：一个「查天气」，一个「给建议」，中间一条箭头连过去，表示建议要依赖天气结果。这个天气的例子虽小，却把任务图的三个要点都装了进去：有顺序、有并列、有边界。

接着，它把每个粗圆圈继续往下拆。「查天气」这个圆圈，会变成一个子图，里面可能是「定位北京」「调用天气工具」「读出明天温度和降雨」三小步。「给建议」这个圆圈，同样被拆成「判断温度区间」「匹配穿衣方案」「生成一句建议」。

拆到什么时候停？拆到每个圆圈都变成「可以直接执行的一步」为止。论文里管这种一步叫「原子工具单元」（atomic task unit），意思是它小到没法再分，模型拿起来就能直接调用工具。借用化学里的「原子」，它想强调的就是「不可再分」这个属性。这一层一层往下拆的过程，论文叫「递归图编译」（recursive graph compilation）。

这个「递归」值得多说一句。它和写代码里的递归是一个意思：先写一个大的函数名，再在函数内部调用更小的函数，直到落到最基本的语句。ATG 把同样的思路用在了任务规划上：粗任务是一个节点，节点内部又是一整张图。为什么非得一层层拆，而不是一口气拆到底？因为中间层次的信息是在拆的过程中慢慢浮现的。直接让模型从一句粗话跳到几十个原子步骤，它容易顾此失彼；而每一步只把一个节点换成几个子节点，每一步都简单，合起来却能拆得很深。

3.3 接口保持：改内部不动外围

拆图的时候，有一个细节特别关键，叫「接口保持」（interface-preserving）。它说的是：一个粗圆圈被细化成子图之后，这个子图对外接收什么、吐出什么，必须和原来的粗圆圈一模一样。

还用写代码来打比方。你把一个函数从冒泡排序换成快速排序，只要函数的入参和返回值不变，所有调用它的地方一行都不用动。ATG 细化节点时守的，正是这条规矩。

为什么这条规矩这么要紧？因为它让「细化」这件事可以安全地进行。父节点换成子图，周边的节点根本感知不到，因为它们看到的输入输出没变。这样一来，拆得再细，整张图的结构也不会乱套。反过来讲，如果接口变了，周边所有节点都得跟着改，那细化就成了牵一发动全身的苦差事，谁也不敢轻易动手。

接口保持还带来一个附带的好处：可组合。因为每个子图的输入输出是固定的，你可以把已经拆好的子图当积木，反复拼进更大的图里。这就像写代码时，一个写好的函数可以被无数地方调用，每处都能放心地用。

这条规矩还埋了一个后手，跟「改错」有关。ATG 每细化一层，都会把这一步的历史记下来，形成一张「图演化序列」。任务执行失败了，模型就沿着这份历史往回找，找到最初出错的那一层。接口不变，才能一层层稳稳地回退。这正是下一章要展开的「局部修复」的地基，这里先留个钩子。

3.4 按图执行：能并行的就并行

图画好之后，就该执行了。ATG 的执行方式，叫「依赖感知执行」（dependency-aware execution）。原则只有一条：严格按照依赖的先后顺序来，谁先被依赖，谁先做。「依赖感知」里的「感知」二字，点的是这层意思：模型不是机械排队，而是真正读懂了每条边的方向。

具体说，模型会按照「拓扑序」（topological order）推进。你可以把它理解成：把图摊平，排出一条合法的先后队伍，保证每个节点都被安排在它所依赖的所有节点之后。这条队伍不一定唯一，但每一条都保证不会「没准备好就动手」。

关键省时间的地方来了：那些谁也不依赖谁的节点，可以同时做。查天气、查汇率、查目的地的开放时间，三件事互不相干，那就并行执行。而并行的一整组，只算「一步」。这是 ATG 计数方式里很关键的一点：并行不是省了一半时间，而是把它压成一步。反观 ReAct，它是一条线往前走，每一步只能等上一步的结果，哪怕两件事八竿子打不着，也得老老实实排队。

这一步的账，直接反映在论文表 2 的平均执行步数上，数字越低越好。以做家务的 ALFWorld 为例，ReAct 平均要 31.42 步，ATG 只要 18.36 步。模拟电商购物的 WebShop，从 8.76 步降到 5.84 步；做科学推理的 ScienceWorld，从 47.35 步降到 29.72 步。

更关键的是，ATG 跟最强结构化基线 PoG 比，还能再省一截。在三个基准上，它分别少走 25.3%、18.0% 和 21.7% 的步数。也就是说，即便对手已经会用图结构了，ATG 的并行调度仍然占优。为什么执行步数这么要紧？因为每一步通常对应一次模型调用加一次工具调用，步数越少，时间越短、成本越低，出错能钻的空子也越少。

3.5 业界同款：Graph 工程正在流行

其实，把任务画成图的想法，不止论文里在做。业界早就在往这个方向跑了。最典型的例子，是 LangChain 推出的 LangGraph。

LangGraph 的火爆程度，用一个月下载量来说话：超过 6500 万次。它的核心思路，和 ATG 如出一辙：把工作流画成一张图，节点（node）负责干活，边（edge）负责定义下一步该发生什么。

这套说法的精髓，是把系统「应该怎么运转」这件事，显式地写进图的结构里，而不是全靠模型临场判断。这也解释了它为什么流行：它在确定性的路径和智能体的自由发挥之间，找到了一个平衡点。该卡死的地方卡死，该放手的地方放手。

业内把这种打法起了一个名字，叫「图工程」（Graph engineering）。它的口号是：把工作流拓扑显式表达。节点干活，边定义下一步。在 LangGraph 的语境里，图还被看成一种「状态机」：每个节点读入当前状态、改一改，再交给下一条边决定走向。把图当状态机，最大的好处是好推理：你随时知道系统卡在哪个节点、下一步有哪几条路可走。这和 ATG 的「先画图、再执行」，是同一个趋势的两端：一边是论文里的方法，一边是工程里的落地。

还有一个有意思的呼应。在这个圈子里，图结构被归进一个更大的词：「认知架构」（cognitive architecture），意思是智能体不是孤零零一个大模型，而是模型加记忆、加工具、加控制流程的一整套设计。LangGraph 的构建者说得更直接：图本身就是一种领域知识，就像提示词里写进去的知识一样。把任务结构画进图里，等于把「这件事该怎么做」的世界知识提前编码了进去。这和 ATG 让模型自己编译出一张任务图，讲的是同一件事：结构，本身就是智能的一部分。

到这里，图的好处已经讲清楚了：它让依赖显式、让并行可能、让结构可读。但图不是万能的，画错了、执行到一半崩了，怎么办？这正是下一章要讲的东西：出错之后，怎么只修一小块，而不是推翻重来。

第四章解法二：出错只修一小块

4.1 先彩排一遍：思维预演

演出前为什么要彩排？演员不是不会背台词，彩排是为了在正式开演前，把灯光、走位、道具这些容易出岔子的细节先过一遍。发现哪个道具不对，提前换掉，比上台那一刻砸在台上强得多。ATG 给大模型智能体装了一个类似的东西，叫思维预演（thought experiment）。

什么叫思维预演？先补一个背景：ATG 把一个多步任务画成一张任务图，图里每个节点是一次工具调用，节点之间的线是输入输出的依赖关系。执行一个计划之前，ATG 不急着动手，而是让模型在内部把这个计划先演一遍，检查它到底能不能跑通。工具选得对不对、节点之间的依赖接不接得上、每一步的输入输出接口对不对得上、路径走不走得通，这些都在模拟里过一遍。这四样，正是计划在真实环境里最容易翻车的地方。工具选错，后面全白搭；依赖没接上，执行就断在中间。这一步成本极低，因为什么都没有真实执行。

彩排花的是几分钟，救场花的是整场演出。思维预演的道理一样：在模拟里发现问题的代价，几乎可以忽略；等它在真实环境里爆出来，可能已经烧掉一大串后续步骤。把坑在排练厅里踩掉，而不是在观众面前踩。换句话说，预演买的是一份廉价保险：花一点模拟成本，避开一次昂贵的真实失败。

如果预演发现了问题，就说明这是一个风险计划，照着执行大概率会卡住。ATG 的处理方式很直接：先别碰真实环境，把计划改对再说。把恢复的成本，从真实环境搬进便宜的内部模拟里，这就是思维预演的核心价值。这一步的意义，在于提前把可能失败的节点挑出来，而不是等它真的失败再补救。

这套预演到底有没有用？论文在 Mistral-7B 上做了统计：思维预演能提前检出 24.6% 的风险计划，这是在 ALFWorld 这个家务环境里的数字。在 WebShop 电商环境里是 18.9%，在 ScienceWorld 科学推理环境里是 27.4%。这三个环境，分别对应具身家务、电商决策、科学推理三种长程任务形态。也就是说，四分之一左右的坏计划，还没执行就被拦了下来。

有人会问：预演会不会误报，把好计划也当成风险计划？论文给出了一个指标，叫失败精度（failure precision），衡量「被判为风险的计划里，有多少真的会失败」。在多数设置下，这个数字超过 74%。换句话说，预演点名的计划，绝大多数确实有问题，不是草木皆兵。误报率够低，这一道关卡才敢放心常开。

4.2 坏了只换零件：最小必要子图修复

电路板局部修复：绝大多数元件亮绿灯，只有右下角一个红色故障被圆环圈出，机器人只拆那一小块

预演再充分，也拦不住所有坑。真实执行中，某个节点还是可能失败。这时候最笨的做法是什么？把整张任务图推倒重来，从头再规划一遍，前面已经跑通的步骤，成果全扔掉。

ATG 不这么干。它换了一个思路：电路板上哪个元件坏了，就只换那个坏元件，不把整块板重新焊一遍。这个机制叫最小必要子图修复（minimal necessary subgraph repair）。

具体怎么做？分三步。第一步，失败定位，搞清楚是哪个节点在执行时翻了车。第二步，沿细化历史回溯，找到这个失败节点的最低公共历史祖先。所谓细化历史，就是当初把粗任务一层层拆成细子图时留下的演化记录。粗任务一层层往下拆，直到每个节点都变成一个能直接执行的原子工具调用，拆分才算完。这个从粗到细的拆解过程，论文叫递归图编译。这套拆分还有个规矩：每一层都保持父节点的输入输出接口不变，就像改函数的内部实现、不改函数签名。回溯到那个祖先，等于找到了这一小块的共同起点。

第三步，只重新细化这一块，把它修成能覆盖失败的最小子图。其余已经跑通、验证过没问题的部分，全部冻结复用。坏在哪个角落，就只在哪个角落动刀。

为什么强调「最低」和「公共」？回退得太远，等于把没坏的部分也推倒重做；回退得不够，又盖不住失败。最低公共历史祖先，正好卡在「刚够覆盖失败」的那一层：往上是没被波及的已验证区域，往下是重新细化的最小子图。这个分寸，是局部修复不误伤的关键。

冻结已验证区域，还有一层现实考量。已经跑通的步骤，重跑一遍不只要再花一次算力，还可能因为这一次的随机性，把原本正确的部分改错。留着不动，既省钱，又不冒新的风险。反过来，如果放任一次失败不管，它会顺着任务轨迹往后传染，越滚越大。这也是为什么它对长任务尤其值钱：任务越长，能保住的已验证成果就越多。全局推倒重来，到这里就变成了局部精准修复。

4.3 数据说话：幻觉率从 42.86% 降到 12.14%

两个机制各有用处，但哪个更值钱？论文用消融实验（ablation）给出答案。做法很朴素，就像拆零件测试哪个部件最关键：把某一个机制拆掉，看成绩掉多少。掉得越多，说明它越重要。

结果很有意思。去掉思维预演，Mistral-7B 在 ALFWorld 掉 4.87 分，在 ScienceWorld 掉 3.99 分。去掉子图修复，ALFWorld 掉 7.72 分，ScienceWorld 掉 6.48 分。两者都有效，但局部修复的贡献明显更大。

这个结论也符合直觉。预演是在事前拦错，拦不住的才漏到执行阶段；修复是在事后兜底，只要任务还在跑，就总有出错的一天。事后兜底覆盖的场景更广，权重自然更高。

最能说明问题的一组数字，是幻觉动作率。什么叫幻觉动作？就是模型生成了一个根本不存在的动作，比如伸手去拿一个房间里根本没有的东西。动作一旦是幻觉，整条执行必然失败。而且任务越长、上下文越膨胀，这种幻觉越频繁。

论文在 ALFWorld 上测了各家方法的幻觉动作率。ReAct 是 42.86%，Reflexion 是 38.57%，CAMEL 是 35.71%，ToT 是 31.43%，PoG 是 28.57%。一路看下来，大家都在三四成附近打转。ATG 是多少？12.14%。

为什么 ReAct 的幻觉率最高？它把每一步的思考、行动、观察串成一条不断变长的文本，模型每走一步都要重读全部历史。打个比方，它就像一条从头录到尾的长录音带，每前进一步，都要把整卷带子从头再听一遍。上下文越滚越长，模型越容易漂移，生成一个历史上从没出现过的动作。任务越长，这条链越容易断。

换算成相对降幅更直观。相对 ReAct，ATG 把幻觉率砍掉了 71.7%；相对表现最好的结构化基线 PoG，也砍掉了 57.5%。换句话说，原来每十次会犯的幻觉，有七次以上被这套结构消掉了。一半以上的「伸手拿不存在的东西」，就这样被挡了下来。

4.4 小模型为什么能赢大模型

ATG 主结果：80 亿参数的小模型加任务图，在 ALFWorld 与 WebShop 上超过 GPT-4 驱动的 ReAct（数据来自论文 Table 1，重绘）

先看结果。Llama-3-8B 挂上 ATG，在 ALFWorld 拿到 63.65 分，而 GPT-4 挂上 ReAct 只有 41.24 分。在 WebShop 上，Llama-3-8B 加 ATG 是 68.36 分，GPT-4 加 ReAct 是 64.34 分。一个开源小模型，靠换一套控制框架，在两项任务上反超了闭源大模型。

这怎么可能？一个开源小模型，凭什么打赢闭源旗舰？答案藏在前几节里：小模型单步能力弱，但 ATG 用任务图、思维预演和局部修复，把每一步都约束在窄而正确的范围内。错误的动作在生成之前就被卡掉，跑错的方向在第一时间被局部修正。本该让大模型硬扛的容错，被拆成了两道便宜的关卡。结构把「模型不够聪明」这个短板，用流程上的冗余补了回来。

如果把完整成绩摊开，差距更刺眼。还是 Mistral-7B，挂 ReAct 时在 ALFWorld 只有 6.57 分，挂上 ATG 变成 55.73 分；WebShop 从 14.63 升到 62.75，ScienceWorld 从 19.12 升到 49.81。同一个模型，什么都没改，只换了一套控制框架，成绩翻了好几倍。连 GPT-3.5-Turbo 挂 ReAct 在 ALFWorld 的 7.30 分，也被所有 ATG 变体远远甩在身后。

结构还带来另一项收益：步数少了。ATG 平均执行步数，在 ALFWorld 是 18.36 步，ReAct 要 31.42 步；WebShop 是 5.84 对 8.76，ScienceWorld 是 29.72 对 47.35。相比最强的结构化基线 PoG，分别又省下 25.3%、18.0%、21.7%。背后是依赖感知执行：没有依赖冲突的独立分支可以并行推进，并行分支只算一步；ReAct 只能一条线串行往下走，一步都省不了。

最关键的一点是，ATG 全程没动模型本身。它不需要针对任务微调，不需要额外的监督信号，不需要外部的示范数据，也不更新任何参数。它纯粹是在推理期加了一层结构，可以原样套在任何一个骨干模型上。换句话说，不用重新训练，不用换模型，部署当天就能用上。顺便算一笔账：论文的实验只用 6 张 RTX 4090 和 7B、8B 级别的开源模型就跑完了，成本比动辄堆更大模型的方案轻得多。

这样的反超不是孤例。论文用三个开源骨干都跑了完整对比，看的是相对各自最强基线的平均提升。Mistral-7B 从 25.51 拉到 56.10，Gemma-7B 从 19.75 拉到 58.56，Llama-3-8B 从 29.52 拉到 62.93。三个模型全部翻倍还多。

这件事对职场人的意义很直接：与其花大价钱上更大的模型，不如先把控制框架做对。一张任务图、一次预演、一处局部修复，这些结构上的投入，可能比单纯堆算力更划算。模型是发动机，结构是变速箱。光有大马力，不一定跑得快。花小钱把结构做对，是这一章最值得带走的一句话。

第五章另一种极端：规划时干脆不用 LLM

5.1 每步都问 LLM，又贵又不稳

想象你写一封重要邮件，每写一句，都要停下来拨一通电话，问顾问"这一句对不对"。顾问每次的回答还略有不同。十句话的邮件，你得打十通电话。电话费、等待的时间、还有答案里时有时无的偏差，全都算在你头上。

LATS（语言智能体树搜索，Language Agent Tree Search）干的就是这件事。它在规划时把 LLM（大语言模型，Large Language Model）当成"每走一步都要咨询的军师"：先让模型随机采样出一批候选动作，再逐个打分挑出最好的。每一步，都要来回打好几次电话。

这种做法的代价直接写在数字里。LATS 在搜索预算 b=10 时，平均每个任务要打 37 次 LLM 调用。每打一次，就多付一次钱，还多一分等待。这还不算完：LLM 每次调用都要把整段历史一起喂进去，输入越长越贵，步数一多，成本像滚雪球一样往上滚，远不是线性叠加。这也解释了为什么在长任务上，"每步问一次"的方案会迅速变得不可承受。

更麻烦的是不稳定。随机采样意味着同一个任务跑两遍，结果会漂移。论文测出的方差从 1% 到 5% 不等。LATS 自己 b=10 是 ±1.0%，放宽到 b=5 是 ±2.0%，而不做搜索的 ReAct（推理与行动，Reasoning and Acting）干脆到 ±5.0%。这个方差对生产环境是要命的：今天能跑通的任务，明天重跑一次可能就失败，你没法向客户承诺"一定成功"。

根子还在"随机"两个字上。模型采样用的是概率分布，同样的输入，两次采样出来的动作可能不一样。搜索越依赖采样，结果就越飘。LATS 想用更多采样去对冲这种飘，却又把成本推得更高：想稳，就得多花钱；想省钱，就得接受不稳。

又贵、又慢、又不稳。有没有可能，把"规划"这件事从"问 LLM"的循环里彻底拿出来？

5.2 三层世界模型：符号、统计、生成

GATS（图增强树搜索，Graph-Augmented Tree Search）给的答案是：规划时干脆不用 LLM。它换上一套"分层世界模型"，专门回答一个问题：做了这个动作，世界会变成什么样？世界模型，就是下棋高手脑中的那个模拟器：走完这一步，对手会怎么应，局面会怎么变。高手不必每步都问人，因为他脑子里有一张动态的地图。GATS 的野心，是把这张地图交给机器自己维护。

这张地图分三层。第一层 L1 是符号匹配：对已知动作，用 STRIPS 式的前件与效果做精确匹配。STRIPS 是经典规划里的老语言，给每个动作写清楚两件事：做之前需要什么前提，做完之后产生什么结果。就像电器说明书，输入和输出都印在纸上，照着查就行。

拿网页导航举例：一个"点击链接"动作的前件，是页面上确实存在这个链接；它的效果，是浏览器跳转到新页面。这些条条框框写死之后，机器不必猜，查表就能推演下一步会到哪儿。

第二层 L2 是学习统计：从执行日志里学"转移统计"，也就是过去这么干，多数时候会发生什么。置信度有个简单公式，出现次数除以 10，最多封顶为 1。一个动作被观察过 10 次，就完全信任；只见过 3 次，就只信三成。这像老员工的经验，干得多了，心里自然有谱。

第三层 L3 才是 LLM 预测，而且只对前两层都没见过的全新动作才动用。预测结果会缓存下来，下次直接查表，不再重复问。整套系统只需在引导期一次性调用 L3 约 50 次；到了规划期，L3 调用是 0，合成任务里 L1 的覆盖率是 100%。所谓引导期，就是系统上线前的一次热身：把没见过的动作集中起来，一次性问完 LLM，把答案存进表里。

这三层的分工很朴素：能用符号查到的就用符号，查不到就看统计，再不行才搬出 LLM。LLM 从"每步必问的军师"，退成"只在最陌生处出场的专家"。这套设计真正的聪明之处，是给预测分了等级：LLM 的预测是软性的、带概率的，可能出错；符号匹配是硬性的、确定的，几乎不会错。把能确定的部分交给符号，把不确定的部分留给模型，系统整体的可靠度就上去了。

5.3 系统性搜索 vs 随机引导

有了世界模型，下一步是搜索。GATS 用的是 UCB1（置信上界，Upper Confidence Bound）树搜索，名字唬人，其实是一台老实的"多臂老虎机"。多臂老虎机是个经典比喻：你面前一排拉杆，每根的中奖率不同，可你一开始不知道。UCB1 的策略是，每次选"平均收益加探索项"最高的那根：既照顾已经证明能赚钱的杆，也强迫自己给没试过的杆留机会。

探索项的存在，是为了防止"过早自信"。假设某个动作一开始赚了点小钱，如果只看平均收益，系统会一直薅它，再也不碰其他杆；探索项给没试过的杆一个起步分，逼系统把每条路都走一走，哪怕暂时亏一点。

于是每个动作至少会被试一次。这跟 LLM 的随机引导是两回事：LLM 采样靠概率，概率低的动作可能一次都不被抽到，关键路径就这么被漏掉；UCB1 靠的是"保证都试一遍"的纪律。

试出来的结果不会白费。GATS 维护一张状态转移图，跨步骤持久复用：相同的状态合并成一个节点，这就是换位表（transposition table）；走进过的死路会被标记，下次绕开。就像在迷宫里边走边用粉笔画记号，走过的冤枉路，绝不再走第二遍。这张图还是"越用越值钱"的资产：同一个动作、同一个状态，这一次任务里摸清的关系，下一次任务还能接着用。

5.4 100% 成功与 0 次调用

这一套组合拳的效果，放在 100 个合成多步规划任务上，数字几乎是羞辱性的。

先看参照系。不做搜索的 ReAct 只有 64.0% 成功率，最优性 0.54（1.00 是满分，衡量找到的解离理论最优有多近），每个任务 13 次调用，方差 ±5.0%。LATS 把预算拉到 b=10，做到 92.0%，最优性 0.99，代价是 37 次调用。

GATS 在 b=10 时做到 100% 成功率，最优性 1.00，规划期 0 次 LLM 调用，0 方差。要知道，表里唯一同样拿到 100% 的是 Greedy Oracle，那是个偷看答案的"上帝视角"基线。Greedy Oracle 是这条赛道的天花板：它等于提前知道了每个动作的后果，走一步是一步。GATS 用 100% 追平它，等于摸到了"开了上帝视角"的高度。

压力测试更说明问题。12 类共 120 个任务，GATS 100.0%，LATS 88.9%，ReAct 23.9%。在最难的编程（coding_task）、网页导航（web_navigation）、深地平线（deep_horizon）三类里，GATS 是 100%，LATS 掉到 63.3%，ReAct 直接 0.0%。这三类恰好是长程智能体最头疼的场景：动作多、步数长，中间一步错就全盘皆输。任务越硬，ReAct 摔得越惨。

预算消融把选择题摊得最开。b=1 的贪心搜索是 0%；b=5 升到 84%；b=10 到 100%；再往上 b=20 还是 100%，白烧预算。换句话说，搜索预算要够，但过了一个点就是浪费。论文还做了统计检验，GATS 对 LATS 的差距，McNemar 检验 p 值小于 0.01，不是运气。

把三列数字摆在一起，结论很干脆：ReAct 靠单条推理链硬闯，成功率低还不稳；LATS 靠堆搜索和堆调用，把成功率拉上来了，代价是 37 次调用；GATS 靠一张会记账的图和一台老实的搜索器，在 0 次调用的前提下拿到满分。更深一层看，这个结果呼应了整篇文章反复出现的一个判断：结构比规模更可解释地省钱。GATS 不靠升级模型，只靠把规划从模型手里移出来，就把成本和方差一起压到了零。

5.5 这张牌的边界

数字这么漂亮，作者自己在论文里主动泼了冷水。第一条：评估用的是"已知动作规格"的合成任务，这对 GATS 天然有利：动作的前件和效果都写得明明白白，L1 符号匹配正好大显身手。

第二条：BFS（广度优先搜索，Breadth-First Search）式的值估计，最坏复杂度是指数级的。论文实际把它限在 15 到 20 个动作、深度 20 以内，这是一张为小动作空间量身定做的牌。动作一多，牌局就散了。

第三条也最要命：到了开放域，情况会变。论文自己估计，开放域里 L1 只覆盖约 60%，L2 约 30%，剩下约 10% 得靠 L3 的 LLM 兜底。L3 依赖越重，GATS 的效率优势就越小，慢慢退回它想取代的那条路。

还有个容易被忽略的细节：单步任务里所有方法都接近 100%，根本分不出高下。这提醒我们，GATS 的胜利是"多步规划"语境下的胜利，别把它当成万能钥匙。换句话说，它的长处和短处来自同一个根：把世界的规律提前记进了图和规则里。规则越全，它越神；规则一空，它就得回头去求 LLM。

这套方案和主论文的 ATG 恰好站成两个极端：ATG 用 LLM 递归编译图、执行前还要预演一遍；GATS 主张规划阶段零 LLM 调用。同一道题，两个方向，各有各的地盘。

说到底，这两条路不是谁对谁错，而是对同一个难题的两种押注。前者赌模型越来越强，后者赌结构越来越省。对读者来说，真正要回答的问题只有一个：你手上的任务，动作空间是封闭的，还是开放的？

落到实操上，这张牌能打的地方很清楚：动作空间有限、规则能写清楚的任务，比如固定工具集里的自动化流程，GATS 式的零调用规划既省钱又稳。反过来，面对开放世界、动作五花八门的任务，还是得老老实实把 LLM 请回来。判断的钥匙，就是那张动作清单：能不能事先把"有哪些动作、每个动作的后果"列全。

第六章会预演未来的智能体

6.1 先想一步再动手：世界模型

棋手机器人闭眼预演：头顶水晶球映出未来棋局，光线被一道闸门部分挡住，代表选择性预演

高手下棋，落子之前脑子里会先过一遍。他盘算的是：这一步出去，对手大概怎么应，几步之后棋盘会变成什么样。等他真的把棋子按下去，这盘棋其实已经在脑子里「预演」过好几轮了。真正的棋力，一半在现场，一半就在这提前想好的几步里。智能体要完成多步任务，缺的正是这样一台脑内模拟器。

论文给这台模拟器起名叫「世界模型（world model）」。它的工作只有一件：预测「在状态 s 做动作 a 之后，世界会变成什么样」。有了它，智能体就能在执行之前预演后果，把试错的成本从真实环境搬到想象里。原本走一步看一步的智能体，从此多了一种选择：先想清楚，再动手。这一步，就是「预演未来（foresight）」能力的来源。

「状态」和「动作」两个词一点也不玄乎。在 ALFWorld 这类文字家务场景里，状态可以是「手里拿着锅、站在灶台边」，动作可以是「打开炉子」。世界模型要回答的，就是打开炉子之后锅会不会热、下一步该怎么办。抽象的公式落到具体任务上，翻译过来就是一句朴素的「我做了这一步，会怎样」。

为什么这件事重要？因为规划的本质，就是在一堆可能的动作里挑出最值得走的那一步。没有预演，智能体只能凭直觉选，错了就撞墙再回头；有了预演，它可以在动手之前，先把每个选项的后果在脑子里过一遍。省下的，是真实环境里一次次昂贵的试错。

听起来很美好。可论文紧接着泼来一盆冷水：这台模拟器不是装上去就赢。装得不对，它不但帮不上忙，还会反过来拖累决策。世界模型真正的问题从来不是「有没有」，而是「准不准」。一台天天报错天气预报的模拟器，比没有天气预报更让人无所适从。所以这章的第一课，是先承认预演会错，再想办法让它错得越来越少。

WorldEvolver 的思路就从这个判断出发。它不碰模型权重，也不重训智能体，只在推理期改一件事：记忆。智能体还是那个智能体，模型还是那个模型，变化的只是它身边积累起来的那点经验。好比不换一个更聪明的棋手，而是给他配一本越写越厚的实战笔记。这个设计，等于给规划装了一个可以自我进化的外挂。

6.2 坏预演比没预演更糟

先看一个先导实验，它直接回答「预演到底值不值得」这个问题。研究人员拿 Gemma-4-26B-A4B 做测试，把预测的未来塞给模型：一种是带噪声的预演（noisy foresight），一种是完美预演（oracle）。结果非常干脆：带噪声的预演把动作准确率往下拽，完美的预演把它往上抬。

这一组对照说明一件事：预演的质量决定一切。预演准，它是望远镜；预演不准，它是哈哈镜，还逼你按错的画面下注。真正有害的，不是「没预演」，而是「信了一份错的预演」。因为智能体会当真，会照着那个错画面调整动作。这正是全文最反直觉的判断：预演未来，用不好就是负资产。

这个判断在正式实验里反复应验。论文对比了两种现成的世界模型方案，RAWM-φ 和 ITP-I，它们的数据并不好看。在很多设置里，这两套预演系统居然跑输「干脆没有世界模型」的基线。一句话，装了一台不准的模拟器，还不如不装。这就是「不对齐的预演有害」：预测和真实世界对不上号时，它提供的不是帮助，而是干扰。

WorldEvolver 走的则是另一条路：让预测和现实不断对账，把模拟器越用越准。下一观测预测的精确匹配率（Exact Match）最能说明问题：Gemma-4-26B-A4B 从零样本（Zero-Shot）的 3.60 分（ALFWorld）和 0.41 分（ScienceWorld），一路拉到 52.88 分和 51.55 分。这不是小修小补，是从「基本猜不中」到「多数能猜中」的跨越。

6.3 双记忆：情景负责复用，语义负责泛化

凭什么能拉这么高？答案藏在双记忆的设计里。这套系统把「经验」拆成两半，各管一摊。第一层叫「情景记忆（Episodic Memory）」，存的是真实发生过的转移，写成三元组（观测、动作、下一观测）。说白了，就是「我上次在这个状态下做了这个动作，结果变成了那样」。

要用的时候，情景记忆按「动作的相似程度」去检索。两个动作越像，过去的经验越可能管用。这套检索靠 Jaccard 相似度来量距离，本质是拿动作之间共有的部分做比较，而不是死记硬背一条固定答案。用对了旧经验，就省下重新试错的力气。

第二层叫「语义记忆（Semantic Memory）」，它不记具体事件，只提炼规则。每当预测的结果和真实的观测对不上，它就把这条「不一致」沉淀成一条持久规则，再附上一个证据分值。证据越多、越一致，规则的分值就越高，越值得相信。这样，一次翻车不会白白浪费，反而会变成一条以后能躲开的经验。

打个比方，情景记忆像你的亲身经历，语义记忆像你总结出的经验法则。前者记的是「去年冬天我在冰面摔了一跤」，后者提炼成「冰面滑，要慢走」。经历只在高度相似的场景里管用，法则却能搬到任何新场景去用。两层合起来，才算一份完整的经验。

两层记忆互补：情景负责复用，语义负责泛化。一个告诉你「这件事上次怎么收场的」，一个告诉你「这类事一般都怎样」。消融实验里，情景检索是绝对的主导因素：检索数量 k_ME 从 1 加到 5，Gemma-4-26B-A4B 的精确匹配分直接涨了 16.8 分和 23.5 分。记忆，才是这台世界模型的发动机。

这套机制还能跨模型复用。换 Qwen3.5-9B 上，零样本只有 1.58 分和 0.59 分，WorldEvolver 提到 37.04 分和 29.82 分；换更大的 Gemma-4-31B，也来到 56.41 分和 62.03 分。骨架不同，方向一致：记忆驱动，不挑模型。这从侧面说明，问题不在模型本身，而在「经验有没有被好好利用」。

6.4 没把握就闭嘴：选择性预演

记忆再强，也有拿不准的时候。遇到从没见过的局面，情景记忆翻不到像样的旧经验，语义记忆也没有现成规则，预测就可能跑偏。这时第三个模块上场了：「选择性预演（Selective Foresight）」。它的原则朴素得近乎保守：没把握，就闭嘴。

怎么判断有没有把握？它算一个置信度：把模型预测下一观测时每个词元（token）的概率乘起来，取几何平均。每个词元的概率都高，乘积才高；只要有一个词元没谱，整体就会被拉下来。这个数越高，说明模型对自己预测的未来越笃定；反过来，低到某个阈值之下，就认定这次预演不可信。

这个置信度，有点像医生决定要不要下诊断。症状清楚、证据充分，诊断就敢下；模棱两可的时候，硬给一个结论反而误事。选择性预演把同样的克制用在了智能体身上：笃定的时候给预测，含糊的时候保持沉默，把决策权交还给智能体自己。

一旦不可信，系统干脆不把预测交给智能体，这叫弃权（abstention）。宁可让智能体不预演、按自己的判断走，也不把一份带误导性的未来塞给它。这一步看似消极，其实是把住最后一道闸门：因为前面已经证明，坏预演比没预演更伤。

这套「闭嘴机制」的效果很稳。在全部 8 个实验设置里，加了选择性预演的版本没有一个输给对照，多数还更好。它像是给预演加了一道质检关口：合格的放行，不合格的拦截。允许系统说「我不知道」，反而比硬塞一个答案更可靠。

6.5 越强的模型，越不需要帮忙

最后一组数据，讲的是外挂的边界。Gemma-4-26B-A4B 用 ReAct 跑 AgentBoard，没有世界模型时，ALFWorld 成功率 23.88、ScienceWorld 44.44；配上带选择性预演的 WorldEvolver，涨到 26.12 和 52.22。增幅实实在在，两个任务都往上走。

换一个更强的骨干，故事就变了。GPT-5.4-mini 加 ReAct，没有世界模型时是 49.25 和 65.56，起点高出一大截。装上 WorldEvolver，ALFWorld 只多了 1.50 分，ScienceWorld 反而掉了 2.23 分。外挂几乎没帮上忙，还添了点乱。

这说明一条耐人寻味的规律：规划者越强，留给外部预演的改进空间越小。强模型自己就能在脑子里把未来推得八九不离十，外部那台模拟器能补的缝隙就窄了；预测稍微不准，反而成了拖累。世界模型的红利，更多属于那些「想不了那么远」的小模型。换句话说，它更像给新手配的拐杖，高手带着反而碍事。

同样的骨架，换一种循环方式结论不变。Gemma-4-26B-A4B 用 ReflAct 跑，没有世界模型时是 26.12 和 42.22，WorldEvolver 提到 27.61 和 50.00。做这些实验的规模也不小：Word2World 每个环境测 195 条轨迹，AgentBoard 用 134 个 ALFWorld 加 90 个 ScienceWorld 任务，每任务跑 5 次、每次最多 30 步。

任务图里的「思维预演」和这章的世界模型，其实是同一件事的两面：一个是在执行前的一次性彩排，一个是可以持续积累进化的外挂。二者都指向同一个方向：与其让模型闭着眼睛硬闯，不如先给它一副能看清下一步的眼睛。对做产品的人来说，与其迷信更强的模型，不如先给系统配一份会自我修正的记忆。

第七章怎么知道规划得好不好

7.1 只看成败的问题

一场考试，两个学生都拿了满分。一个靠的是每一步的扎实推理，另一个靠的是蒙对了好几道选择题。只看卷面分数，你根本分不出谁真会、谁靠运气，分数越高，这种盲区反而越隐蔽。换句话说，分数只能回答「做对了吗」，回答不了「这次对得牢不牢」。智能体的规划评测，卡在的正是同一个地方。

今天主流的评测方式主要有三种。第一种只看最终结果，学术界叫它 outcome-only：成功记 1 分，失败记 0 分，分不出「侥幸成功」和「稳健成功」。第二种拿参考答案做字面比对，BLEU、ROUGE 都是这个路数。第三种让大模型当评委，业内叫 LLM-as-judge，看着聪明，实则又贵、结果还不确定、对提示词的措辞高度敏感，还容易偏爱自己写的答案。

一条规划可能每一步都踩在悬崖边上，只是运气好才没摔下去；另一条规划四平八稳，只是最后一步碰了壁。在二元成败的眼里，前者 1 分，后者 0 分，结论和事实刚好颠倒。蒙对的满分，换个条件再考一次就露馅；扎实的满分，换十套卷子还是满分。你要的是「可复现的好」，它只认得「这一次成没成」。

第 2 章讲过的「地平线鸿沟」综述里，有一个反复出现的共识：outcome-only 信号会随着任务变长而失效。任务越长，越多的关键信息藏在中途的步骤里，而最后那一格成不成功，能告诉你的东西越来越少。到了几十步的长任务，成败几乎退化成了一个掷硬币。这个共识还解释了领域里的一条主流回应：造出更密的逐步信号，比如给每一步单独打分的「过程奖励模型」，就是在成败这两个极端之间补上一格一格的中间刻度。

于是问题来了：如果只看成败不行，那到底该怎么看？答案是：看过程。而要看过程，第一步得先把「过程」本身变成一个可以比较、可以打分的对象。

7.2 把轨迹画成图，再算两张图的距离

这就引出了本章的主角，一篇叫 OTAP 的论文。它的思路很朴素：把智能体执行一条任务留下的轨迹，建模成一张带属性的有向无环图。轨迹不再是长长的一串文字，而是有节点、有方向的几何结构。

什么叫带属性的图？图上的每个节点是一次原子动作，比如「查一下天气」「打开一个网页」；节点之间连的边，表示谁依赖谁：要先查到天气，才能根据天气给出出行建议。边是有方向的，而且不能绕回来成环，所以叫有向无环图（directed acyclic graph）。属性指每个节点自己带的信息，它查了天气、调用了哪个工具、产生了什么状态变化，都记在节点上。

有了图，下一步是定义「距离」。OTAP 借用了数学里的最优传输（optimal transport）。你可以把它想成运土：一堆土要运到几个坑里，求一种最省力的搬法。如果土和坑的位置天然吻合，搬运费就是零；错位越厉害，费用越高。OTAP 要搬的不是土，而是图上的节点，它想算清楚「执行图」和「一组合法解图」之间差多远。搬运的总代价越低，说明两张图越像。

这里用的是一版更精细的工具，叫非平衡融合 Gromov-Wasserstein 最优传输。说人话，它同时对齐两样东西：节点的属性像不像，以及整张图的结构像不像。普通的文本相似度只看字面，它看的是图的形状。所谓「融合」，是把属性比较和结构比较揉进同一个目标函数里一起优化；「非平衡」则允许节点多出来或缺失，不会顾此失彼。

这个距离度量有几个关键性质。第一，独立的步骤可以换序，只要依赖关系保持不变，先做 A 再做 B、还是先 B 后 A，都不算错，这叫依赖保持的排列不变性。第二，软对齐，一步可以对应多步，不必一一配对。第三，容忍缺失和幻觉步骤，少做一步、多做一步，都不会被强制要求硬凑。第四，执行锚定，它把节点调用了什么工具、引起了什么状态变化都算进相似度里，不会只看文字。第五，支持多个参考解，拿一组合法解当尺子，比单一把尺子更不容易出错。

论文用 20 个由人精心策展的任务来考它。结果很直接：OTAP 的 AUROC 是 82.0，而随机猜只有 50。作为对照，把轨迹文本转成向量再硬性配对的 Embed+Hungarian 方法，只拿到 46.2，比随机猜还低。这个 AUROC 衡量的是「判断两个方案孰好孰坏」的准确率，不是简单的对错。而且它跑起来不贵，六步轨迹对比三个参考解，在 CPU 上只要 28 到 33 毫秒。

最漂亮的一个数字来自「合法换序」这一类测试：OTAP 拿了 100.0 的满分。也就是说，两个只是步骤顺序不同的方案，在它眼里距离是零，判断完全正确。它还能输出一个最优耦合矩阵，把「哪个步骤对上了哪个步骤」一条条列出来，评分可审计，不是黑箱。

7.3 文本指标会怎么冤枉好方案

轨迹评测对比：结构感知的 OTAP 得分 82.0，纯文本相似度指标低于或贴近随机水平 50（数据来自论文 Table 1，重绘）

现在可以看清文本指标的问题了。精确匹配、BLEU、ROUGE 这些指标，本质是拿生成结果和参考答案做字面上的比对。它们天生就默认「顺序和用词必须接近」才是对的。

但合法换序不该被罚。一个学生先写结论再写过程，另一个先写过程再写结论，两份答卷思路都对，只是字面顺序不同。BLEU 这类指标会狠狠扣分，把一个好方案，排到一个因果倒置的坏方案下面。对一道开放题而言，「一样」本身就是个过高的要求。它罚的是「不一样」，而不是「不对」。

数据把这种「冤枉」写得很明白。在 20 个策展任务里，BLEU 只拿到 59.9，ROUGE-L 只有 67.4，都比 OTAP 的 82.0 低一大截。而 Embed+Hungarian 的 46.2 更是跌破了随机线，等于说它连「随便猜」都不如，把「合法换序」误判成了最差的方案。

OTAP 还有一项「损坏阶梯」的检验。研究者把好方案故意破坏成五级，从轻微到严重。一个合格的指标，应该随着损坏程度加深而打分稳步下降。OTAP 的相关性 ρ 达到 0.923，另一个指标 τ 也有 0.837，只算被破坏的那部分 ρ 也有 0.851，而且跨任务的离散度最低，说明它的表现很稳定，不是某一两个任务上的偶然。

还有一个反直觉的消融实验。论文把「结构」这一项关掉，让 θ 等于 0，OTAP 立刻从 82.0 掉到 54.5，退化成一个普通的最优传输，重新暴露了文本指标低于随机的老毛病。另有两个对照：只用一个参考解，AUROC 再降 17%；把步骤压成一条固定总顺序，AUROC 是 65.8。结构，才是它和文本指标拉开差距的根本。

7.4 有验证器时请用验证器

OTAP 不是万能钥匙。论文把它放到三个公共基准上测：PlanBench 拿到 80.4，其中「合法换序」那一类照旧是 100.0 满分；WebArena 拿到 85.9；GAIA 只有 69.8。三个数字之间的落差，恰好标出了它的能力边界。

GAIA 的答案大多是自由文本，研究者只能靠启发式规则去推断步骤之间的边。图的结构推断得不准，评分就跟着变差。损坏阶梯的相关性也印证了这点：PlanBench 有 0.92，WebArena 有 0.90，GAIA 只有 0.53。这说明 OTAP 的效果，高度依赖「能不能把轨迹画成一张准确的图」，图越准，评得越好。

更诚实的一个实验来自 PlanBench。作者拿了 720 条真实的 LLM 计划，去和形式化验证器做对比。结果 OTAP 只拿到 79.2，而严格的「步骤精确匹配」有 85.3，BLEU 有 86.7。在这个局里，OTAP 是最弱的代理。这组对照的价值在于：它提醒大家，指标选型要先看任务有没有「标准答案」。

这个结论值得记牢：当你有形式验证器（也就是能机械地判定对错的工具）时，严格的表面指标反而更好。OTAP 真正的用武之地，是那些没有验证器、只能靠人来判断的开放域任务。论文自己也说得很克制：OTAP 度量的是「离一组合法解的距离」，不是正确性本身，它和结果信号是互补关系，不是替代关系。

7.5 业界呼应：给 Agent 做「CT」

论文讲的是「怎么给一条轨迹打分」，业界关心的是同一件事的另一面。InfoQ 上有一篇火山引擎钱世俊的分享，标题就叫「给 Agent 做 CT」。

它的出发点是黑盒困境：传统的日志，几乎无法还原一个 Agent 的思考机制、规划逻辑和执行链路。你只能看到它最后输出了什么，看不到它中途是怎么一步步走过来的。就像一个只报体温、不报病因的医生，你既不知道哪儿病了，也不知道该怎么治。

要打破黑盒，这篇分享提出一套「CT 系统」，回答三个问题：可见性，全过程发生了什么；可解释性，为什么它会变慢、报错、成本飙升；可行动性，怎么形成优化的闭环。三个问题层层递进：先看得到，再看得懂，最后才能动手改。它还指出监控存在四层断层，业务应用层、Agent 框架层、模型推理层、云基础设施层各管各的，中间漏了一大截。

它还点出一个更具体的事实：Agent 的逻辑偏差可能在极短时间内触发巨量模型调用，token 消耗指数级飙升。没有过程级的可见性，这种事故根本无从查起。

一篇论文说「不要只看成败，要看轨迹图」，一篇行业分享说「要给 Agent 做 CT，看穿它的内部」。两个声音从不同方向出发，讲的是同一句话：智能体的规划好不好，得看过程，而且得用结构化的方式去看。

第八章这意味着什么

8.1 给 AI 一张任务图，今天就能做

会做饭的人都知道，照着菜谱流程图做菜，比丢下一句"今晚做顿好的"要稳得多。流程图写清每一步的先后与依赖，还能让"烧水"和"切菜"两条线同时推进。反过来，全凭手感下锅，一步出错就是整锅翻。给 AI 派长任务，道理一模一样：先画图，再动手。

这一章要收的，是全书五篇论文指向的同一个动作。五篇论文的结论其实高度一致，都落在同一件事上：把任务的结构显式画出来。换句话说，这一代 AI 的胜负手，已经从模型本身，移到了围着模型搭的那套结构上。AI 真正难的不是回答一个问题，而是连着做几十步不跑偏。要让它跑得稳，就得给它一张任务图，而不是一段自由发挥的提示词。

ATG 的做法最直白：把整件任务拆成节点，节点之间画上依赖线，谁先谁后一目了然。这张图带来三件实打实的好处：显式的依赖关系、可以同时推进的并行分支、以及坏一处只修那一处的局部修复。其中局部修复尤其值钱，传统做法一步错了往往从头再来，任务图却能顺着记录往回找，只修最受影响的那一小块。执行前它还多做一次"彩排"，先用模型自己检查计划有没有坑，查出问题再动手。消融实验拆过这些机制的贡献：只去掉局部修复，ALFWorld 掉 7.72 分，去掉思维预演也掉 4.87 分，可见局部修复是主力。

这套东西今天就能用，因为它不要求重新训练模型。ATG 明确是纯推理期的方法，不加微调、不喂示范、不动参数。你手里现成的模型，配一张图画好任务结构，立刻就能受益。它还更少犯错：在 ALFWorld 上，模型发出无效动作的幻觉率被压到 12.14%，比最常用的 ReAct 低了 71.7%。

它和业界正在发生的事是同一条线。业内把智能体工程拆成三层：运行环境（Harness）、反馈循环（Loop）、流程拓扑（Graph），口诀是"环境、反馈、流程"。Harness 提供条件，Loop 决定如何重试与改进，Graph 定义下一步允许发生什么。Graph 这一层干的，正是把工作流画成图。把三层混为一谈，会在错误的层级排查问题。

这件事有多热，第三章已经用数字说过一遍：LangGraph 月下载量超过 6500 万次。人们愿意为"把系统画成图"付这么大的使用量，说明结构化不是论文里的冷门术语，而是工业界正在兑现的方向。

落到你手上，动作很简单：下次给 AI 派活，别写一段自由发挥的提示词，先画一张流程图。谁先做、谁后做、哪几件事能并行、哪里容易出错，画清楚再交给它。哪怕只是把一个大任务拆成三五个带先后顺序的步骤，也比一段长提示词强。

8.2 评估长任务，别只看成败

只看考试成绩，不看解题步骤，会漏掉很多信息。两个学生都拿到了同样的高分，一个步骤扎实，一个是蒙对的，能力天差地别。评估 AI 的长任务，我们长期只盯"成功还是失败"这一个数字，问题就出在这里，而且任务越长，错误越容易顺着轨迹悄悄累积。

《地平线鸿沟》（Horizon Gap）这篇综述翻遍 1,547 篇论文，得出一个绕不开的结论：任务越长，单一的成败信号就越失效。一条几十步的轨迹，最后一步对了就记满分，前面胡来也看不见，这样的评分根本指导不了改进。综述把这种现象叫作只看结果的信号失效，领域的回应是制造更密的逐步信号，比如给中间步骤也打分。

所以评估要改成双轨：一边仍是二元的成败，另一边加上过程级的信号。步骤有没有顺着依赖走、每一步质量如何、轨迹结构合不合理，都要能看、能打分。过程信号就像体检报告，不看它，等出了大问题再查，往往已经晚了。

这正是 OTAP 在做的事。它不问你最后成功没有，而是拿整条轨迹的结构，和一组"已知的好解"去比距离。换个说法，它考的不是答案，是解题过程写得像不像样。今天的评测基本是三条老路：只看成败、拿文本相似度硬比、让大模型当裁判，各有各的毛病，OTAP 想补的正是结构这一环。

业界的诉求和它是同一件事。近来有人提出"给 Agent 做 CT"，理由就是传统日志还原不了智能体的思考与规划链路，逻辑偏差可能在极短时间内触发巨量模型调用。这套"CT"要回答三问：全过程发生了什么、变慢报错的原因是什么、如何优化闭环。要让规划链路白盒化、可观测，这不就是论文里"看过程"的翻版吗。

8.3 小模型 + 好结构 = 省钱

买车的人都知道，换一台更贵的发动机，不如先把路线选对。堵在路上的豪车，跑不过抄了近道的小车。选 AI 模型也是这个道理：结构对了，小模型也能跑赢大模型。

ATG 的实验给了一个相当反直觉的数字。Llama-3-8B，一个 80 亿参数的开源模型，配上任务图，在 ALFWorld 上拿到 63.65 分；GPT-4 加最常用的 ReAct 循环，只有 41.24 分。小模型加好结构，反超大模型加裸循环。这不是个别配置的运气，换成 Mistral-7B、Gemma-7B 也一样，全部 ATG 变体都大幅超过 GPT-3.5 加 ReAct。

这还不是孤例。同样是这组对比，在 WebShop 上 Llama-3-8B 加 ATG 拿到 68.36 分，GPT-4 加 ReAct 是 64.34 分。两个基准都超了，说明这不是运气。结果好，过程也更省：把可并行的分支合成一步，执行步数比最强的结构化基线再少了两成多。

省钱的账还要往深处算。GATS 干脆主张规划阶段一次大模型都不用调，用系统性的搜索加世界模型顶上，结果在测试集上拿到 100% 的成功率，且零次调用大模型。它把最贵的大模型调用从规划环路里剥离出去，只在遇到全新动作时才兜底查一次。这一步棋，等于把智能体最烧钱的部分换成了便宜的系统计算。结构设计得好，词元（token）的消耗可以直接降下来。

对预算敏感、又要长期跑 AI 的团队，这一条是本章最该记住的。别急着上更大更贵的模型，先把任务图理清楚。往往结构省下的钱，比换模型省得多，推理成本会实实在在地降下来。

8.4 还没解决的：局限与开放问题

话说到这份上，也得泼一盆冷水。这几篇论文自己都老老实实写了边界，我们不该替它们夸口。这几篇论文的可贵之处，正在于没有把话说满。知道边界，才能不把结论用错地方。

ATG 自己承认四件事：它依赖骨干模型先把任务分解清楚；观测有噪声或依赖链太长时，失败定位会变难；目前只测了文本基准，多模态和真实场景还没验证；简单任务反而背上了额外开销。

GATS 的软肋在评估方式。它用的合成任务，动作规格是预先知道的，这天然对系统搜索有利。更实在的限制是广度优先搜索（BFS）在最坏情况下指数级增长，所以实际只限 15 到 20 个动作、深度 20 层，再长就得另想办法。而且这套优势有个前提：一旦动作超出已知规格、需要动用大模型预测新动作，效率优势就会缩水。

WorldEvolver 的短板在于，它靠词元（token）概率来估预测的置信度，闭源接口未必把这些概率吐出来，方案就无从落地。它的实验还提醒我们，不可靠的预演会被忽略、误用，甚至反过来损害决策，所以它宁可闭嘴。OTAP 承认粒度不变性还没解决，而且它度量的是"离已知好解的距离"，不是正确性本身，只能当结果信号的补充。

Horizon Gap 则抛出三个开放问题：一个长任务的表现，到底该归功于模型还是外面的框架；过程级信号会不会带着关联偏差；长程可靠性到底存不存在一条一般性的预测理论。这三个问题，目前没人能答。

8.5 源势AI 的观点

把这些论文和业界的动向放在一起，源势AI 有三点看法。第一，结构大于规模，这是一段窗口期。眼下用一张好的任务图，加上 7B 到 8B 的开源模型，就能在不少长程任务上达到甚至超过闭源大模型。等大模型厂商把这类结构原生地吸进模型里，这个红利窗口就会收窄，先动手的人吃得到。

第二，过程级评测是刚需，不是锦上添花。长任务时代，只报一个成功率等于没报。模型在几十步的轨迹里，单步能力早就不缺，缺的是连续可靠性，而这只能靠过程信号来量。谁先把"过程"做成可观测、可打分的标准件，谁就能在智能体的质量保障上领先一步。

第三，有一批方向值得持续盯。任务图的局部修复还能不能再细；规划阶段能否彻底少调大模型；预演未来怎么做得可靠；轨迹评测怎么度量得又准又便宜。这些都是还没落定的地盘。这也是为什么我们把这些论文放进同一期长文里：它们拼出的，是一张智能体规划的未来拼图。

最后说回开头的菜谱。这一代 AI 的真正门槛，已经从"能不能答对"，挪到了"能不能连着做对几十步"。而跨过这道门槛的钥匙，不在更大，在更清楚。结构，就是把那几十步串起来的图纸。图纸对了，再小的模型也能走远。