测试时计算
目的
为什么在单个智能体决策上多投入计算，可以让智能体更加自信，却未必让它更加正确？
一次模型调用只返回一个提案，而在困难决策中，该提案往往是对错误假设的流畅承诺。在它行动之前，运行时可以购买更多推理：让模型推理更久、采样多个候选，或运行一次检查并将结果反馈回来供其修订。每一次购买都消耗 token、秒数与美元，而其中只有部分购买能够改变运行时所知的信息。更长的推理与无引导的重新采样都再次依赖同一组权重与同一提示词，因此它们增加成本的速度快于增加证据的速度；而一次廉价且可能否决候选的检查，却可能直接定论。选择本身也暗藏陷阱：用大量候选去对抗一个不完美的检查，恰好会选出那些检查无法捕捉的候选。因此，工程问题不在于想多少，而在于某一次投入能买到何种证据、哪些检查可以接受某个结果，以及何时停止。以 H·S·A 术语而言，测试时计算本身并不增加任何暴露（exposure），因为候选必须经运行时认可才会被采纳；但每一轮修订都在单个决策中消耗时延，而该投入只有在提升了最终被采纳提案的闭合证据（closure evidence）时才配得其所。
学习目标
- 解释为什么一次模型提案会过早地对某个假设作出承诺，以及为何在不补充新证据的情况下重新采样会增加成本却不增加信息。
- 从每个 token、秒与美元所买到的证据出发，比较深度、广度与反馈，包括推理模型与思考预算（thinking budgets）。
- 分析候选选择，涵盖投票、学习得到的验证器与 LLM 评判者，并将 pass@\(k\) 视为 best-of-k 选择的上界。
- 计算验证器所接受集合的精度，并解释为何在不完美的验证器之上进行更强的搜索反而会选出利用行为（exploits）。
- 将多步计划表示为可修订的依赖图，其失败在本地修复，而非重新生成。
- 针对硬性上限、经认证的提前退出与边际收益，设计停止与升级规则。
- 以每次被接受任务的成本与截止时延处的延迟为指标，评估一种测试时策略相对于单候选基线。
为何单个候选会失败
在每步成功概率为 95% 时，40 步轨迹中不到 15% 能够存活，即开环上限 时间跨度拉伸：从纳秒指令到千秒级轨迹。
一个部署于多个可用区的高吞吐分布式 KV 缓存，在高写入并发下开始出现尾延迟劣化以及间歇性陈旧读取异常。运行监控显示，副本同步滞后会周期性超过 120 毫秒；然而网络接口遥测却显示丢包与链路重传，且与基线噪声无法区分。两种互斥的缺陷机制以同等表面可信度解释了这组遥测：一是未经校准的集群心跳超时，过早将健康副本降级并触发昂贵的重新同步突发；二是并发租约失效协议中的竞态条件，在多键更新期间丢失内存屏障，使得读取副本在租约撤销时间戳传播到整个集群之前便提供了已失效的条目。
当工程师将这段模糊日志轨迹呈现给交互式会话中的非特权基础模型时，自回归解码循环仅依据提示词及其学到的参数权重来采样 token。由于网络套接字超时与心跳调整在训练语料中的开发者论坛和开源仓库中高频出现，模型的解嵌入投影会赋予心跳假设很高的条件似然。模型生成一个增加套接字超时的补丁，用流畅的诊断理由将其包装起来，并提交该提案。在交互式场景中，这一错误假设只是轻微的对话性挫折：人类工程师检查该建议，注意到网络接口计数器正常，否决该假设，并补充额外的系统指标。但当系统工程从对话式辅助转向自主委派——智能体运行时直接将多步诊断、代码修改和部署委托给非特权模型，而无需人类介入——一次前向传播便成为关键单点故障。将模型未经验证的补丁部署到生产环境，会使底层的租约失效竞态原封不动地保留下来，从而使静默的数据损坏在下游存储引擎之间传播。
一次模型调用无法可靠地解决复杂的诊断或工程任务，因为序列似然的可信度并非运行真值的代理。 在自主系统中，主要的计算性失败既不是语法无效性，也不是表面不连贯；而是在缺乏区分性证据的情况下，对未获支撑的假设过早承诺。基座模型 曾对一类此类提案按输出 token 定价，结果显示它只能通过运行时的验证边界（候选序列验证）才能到达环境。在那条边界接纳它之前，该提案只是一份被扣留在托管中的未经验证的缓冲区。
解码循环使得此类承诺难以摆脱。一旦某个 token 被采样，其键向量和值向量便加入 KV 缓存，而流中的每个后续 token 都会对其进行注意力计算，流中没有任何内容可以将其收回（自回归生成）。如果早期 token 将轨迹承诺到一个错误前提，例如断言集群异常源于心跳超时，那么流中所有后续隐状态都会对该断言进行注意力计算。由于生成式预训练优化的是连贯序列的对数似然，模型不会察觉底层的物理矛盾并停止。其后续 token 会合理化、辩护并进一步发挥这一初始错误，从而产生流畅但虚构的论证，使文本保持一致。这就是 **上下文污染动力学** 的上下文污染，其作用发生在单次生成内部，而非跨轮次。
执行会陷入一条 garden path：一条执行轨迹，其中局部 token 转移概率仍然很高，但全局任务成功率却降至零。标准自回归采样对每个 token 都按固定深度的计算图进行评估，而不论问题难度或遥测模糊程度。当自主系统以开环方式运行时，单候选执行会沿着四种不同的系统失败模式崩溃：
- 认识论模糊性与先验偏差：入站遥测向量缺乏足够的信息熵以隔离真实缺陷，但采样策略强制立即做出不可逆承诺，并受预训练先验影响而偏向常见表面模式。
- 自回归承诺与前提污染：一旦一个无依据的前提进入 KV 缓存，因果注意力掩码便保证后续 token 以该错误为条件，使模型无法在同一生成流内自我纠正。
- 浅层组合视野：单次前向传播为每个 token 分配固定、恒定的计算量（\(O(1)\) 个 transformer 层）。在诊断复杂的分布式竞态条件时，组合依赖链超过了单个序列未经展开中间推理状态所能承载的即时表示能力。
- 改写谬误：请求一次无引导的第二轮，或在未注入任何新外部证据的情况下提示模型”重新考虑”，都会带来零信息增益。如果提示词包含相同的观测向量，并从同一参数分布中采样 \(\Theta\)，那么无引导的重采样只会简单地在同一概率盆地内振荡。改写一个有缺陷的前提不增加任何互信息（\(I(Y; \text{Truth} \mid X) = 0\)）。流畅的语言无法替代经验证据。
正如 诊断树与区分性验证 所示，左侧的开环生成会不可撤销地承诺于高概率先验 \(H_1\)（\(P(H_1)=0.75\)），使被污染的 KV 缓存上下文引导下游执行走向一个无效的超时补丁。在右侧，审慎推理执行 在根状态 \(s_0\) 处推迟执行，直到外部诊断探针执行一项针对性的并发测试。该探针捕获具体的运行时证据，证实套接字仍然健康而租约锁被过早释放，并且该证据明确证伪了 \(H_1\)，剪除无效分支，并引导后续生成走向位于 \(s_2^*\) 的经验证同步修复。
::: {#nbk-03-probe-versus-generation .callout-notebook title=” 探测与更长的答案”}
问题：在陈旧读取诊断中，一次 40 ms 的区分性探测替代了多少生成？
变量：模型在单流下限 加速器服务延迟 处解码，每个输出 token 消耗 \(t_{\text{tok}} \approx\) 21.1 ms。其余均为场景假设。端点计费为 $15 per million output tokens. The model’s answer runs to \(K =\) 1,024 output tokens and commits to \(H_1\) at token 16. The prior is \(P(H_1) = 0.75\) and \(P(H_2) = 0.25\)。探测在沙箱中的 CPU 上运行 40 ms，返回约 60 个 token 的输出，由下一次调用作为输入读取。
数学：完整答案约需 21.6 s，成本约 $0.015。token 16 之后的所有内容都在发挥一个未经检查的前提，这相当于 1,008 个 token，即 21.2 s 和生成量的 98 百分比。在探测之前，运行时对两个假设的不确定性为
\[H = -\left(0.75 \log_2 0.75 + 0.25 \log_2 0.25\right) \approx 0.81\text{ bits}\]
探测证伪了一个假设，使不确定性降至零。而长答案将其保留在 0.81 bits，因为其内容不依赖于存在哪一种缺陷。
系统洞见：探测的成本约为生成墙钟时间的 1/540，却解决了生成完全无法解决的全部不确定性。两者在美元成本上都不昂贵；真正昂贵的结果是部署了一个错误的补丁。运行时应当按每秒购买证据，而不是按每秒购买 token。
:::
不变式闭环原则（不变闭包原则）早已将任务正确性置于模型之外、位于应用边界，因此生成器无法通过检查其假设的内部一致性，或通过在对话中反思来为自己的假设提供认证。辩论还带来第二点。测试可以显示缺陷的存在，但永远无法证明其不存在（智能体系统时刻），而在辩论中，“存在”才是关键。当并发测试运行器发出非零退出码或断言失败时，该观测会证伪某个假设，并将真值证据注入运行时的状态。因此，外部探测所做的远不止为候选提供认证；它为候选之间提供了 判别能力，而这正是额外计算必须购买的属性。
Snell 等人 (2024年) 测量了这一后果。额外推理计算所带来的收益，无论是用于修订回答还是用于在验证器上搜索，都取决于问题难度以及计算如何被引导；与问题相匹配的分配以压倒性优势胜过朴素扩展。那些能够产生 判别信号 的分配，才是有价值的分配。在没有外部验证器的情况下，从无引导分布中采样更多候选会迅速饱和；而生成扩展的合理化论证却缺乏经验反馈，只会累积错误。只有当测试时计算获取到能够区分有效执行状态与无效状态（即原则 2）的证据时，它才具有价值。
因此，辩论本质上是一项架构层面的资源分配决策。与其将模型推理视为一个原子的、一次性的远程过程调用（要么成功要么失败），主机智能体运行时必须动态编排测试时计算：确定何时生成中间推理 token、何时分叉为并行的候选替代方案、何时派发外部执行探测，以及何时在明确的延迟、token 和内存预算下终止搜索。系统可以购买哪些类型的额外工作，以及它们的执行拓扑如何在关键路径延迟、加速器内存和区分性信息增益之间进行权衡？
三种计算分配轴
当智能体运行时面对一个失败的任务——例如合成一个并发同步屏障，或诊断一个间歇性竞态条件——为系统额外授予计算预算，并不会规定这些操作应当如何组织。如果运行时仅将一数量级的浮点运算分配给同一推理上下文内更深的自回归展开，基础模型往往会生成数千个 token 的详尽、看似合理的论证，而这些论证只是进一步加码其原有的错误前提。如果运行时转而将这些运算导向从初始提示词并行采样二十个独立的候选续写，它通常只会得到二十个针对完全相同概念性失败的轻微语法变体，因为每个候选都来自一个无条件的条件分布，因而共享着相同的盲点。如果主机监督器反而将该相同预算划分为三个迭代周期——生成一个候选、在隔离沙箱中编译并执行它、并将由此产生的回溯作为提示词前缀注入以进行针对性修正——那么竞态条件会在数秒内被诊断并消除。
测试时计算并非一种不分高低的标量货币。其架构效用完全由其在三个正交轴上的执行拓扑决定：深度（顺序 token 扩展）、广度（并行候选探索）和反馈（观测条件驱动的修订）。每个轴都在模型调用之间建立起根本不同的依赖图，呈现出截然不同的关键路径延迟与加速器内存剖面，并以不同的方式与模型的认知边界相互作用。
如 图 1 中所形式化的，测试时计算涵盖三种不同的架构拓扑。在深度拓扑（左）中，计算量沿由 \(K_{\text{ext}}\) 个自回归词元构成的串行链扩展；虽然这使展开的中间推导成为可能，但实际耗时严格按 \(O(K_{\text{ext}})\) 增长，且在批大小为 \(B=1\) 时内存带宽达到饱和。在广度拓扑（中）中，运行时将执行分叉为 \(N\) 路并行候选流；实际耗时与单次轨迹采样 \(O(K_{\text{cand}})\) 相当，但若不剪除前景不佳的分支，加速器高带宽内存占用就会按 \(O(N \cdot K_{\text{cand}})\) 增长。在反馈拓扑（右）中，计算在 \(M\) 个离散轮次中循环调用外部执行沙箱；每个候选方案都会被编译，并通过实证探测进行证伪，从而打破自回归生成中无法撤回既有输出的困境，同时将工作内存限制在单个活跃生成上下文的范围内。
要理解如何分配推理时计算，需要将这三种执行拓扑分解到其物理基础和信息论基础层面。智能体运行时的设计者必须权衡关键路径的实际耗时（\(T_{\text{wall}}\)）、浮点运算总量（\(C_{\text{FLOP}}\)）、保留在加速器内存中的活跃状态占用（\(M_{\text{KV}}\)），以及最终生成方案的实证有效性。
Definition 0.1: 测试时审慎推理轨迹采样
测试时审慎推理轨迹采样 是一种有向轨迹扩展算子 \(\mathcal{T}_{\text{delib}}: \mathcal{S}_{\text{ctx}} \to 2^{\mathcal{A} \times \mathcal{O}}\)，智能体运行时借此沿深度、广度和反馈三个轴动态分配推理计算，在产生不可逆的环境副作用之前，探索、模拟并验证候选动作序列。
- 意义：将模型调用从单次开环词元输出转变为闭环搜索过程，缓解误差累积导致的漂移，并通过扩展测试时计算，使问题求解能力不再受固定参数权重的束缚。
- 区别：与单轮自回归解码不同，后者沿单个不可逆的 KV 缓存前缀，为每个词元执行固定的 \(O(1)\) 计算图；审慎推理轨迹采样则维护一个可修订的候选搜索前沿，将并行分支探索与带外验证探测交错执行。
- 常见误区：仅沿深度轴或广度轴分配测试时计算，而不引入实证反馈或验证预言机；开环轨迹采样会受到改写谬误和古德哈特偏离的影响，消耗 GPU 内存带宽和浮点运算预算，却无法提高任务成功率。
深度：顺序词元扩展
在达到领域饱和上限之前，测试时审慎推理随验证预算呈对数线性扩展。
增加测试时计算最直接的机制，是延长单次自回归生成的顺序长度。在这种拓扑下，运行时允许模型在输出最终方案之前，先生成一条包含 \(K_{\text{ext}}\) 个中间词元的连续轨迹，这些词元通常组织为暂存存储器、执行轨迹或扩展推导。
形式上，给定初始提示 \(\mathbf{x} = (x_1, x_2, \dots, x_P)\)，自回归解码引擎按顺序生成词元：
\[y_t \sim P_\Theta\left(y_t \mid \mathbf{x}, y_1, \dots, y_{t-1}\right), \quad t \in \{1, 2, \dots, K_{\text{ext}}\}\]
其中，\(\Theta\) 表示神经网络的冻结参数。从信息处理的角度看，深度扩展了模型的计算表达能力。标准 Transformer 解码器对每个词元所能执行的计算操作数量存在限制；通过 \(L\) 层的一次前向传播无法模拟任意数量的状态转移。通过将中间推理串行化到词元序列中，模型实际上执行了一种展开的递归过程：较早的中间词元 \(y_{<t}\) 被写入键值（KV）缓存，使后续词元 \(y_t\) 能够通过注意力回溯中间推导，将复杂的组合约束分解为逐步完成的步骤。
然而，从系统角度看，深度构成了一条严格串行的关键路径。词元 \(y_t\) 必须等到词元 \(y_{t-1}\) 完成前向传播、且其键值向量在内存中实体化之后才能计算，因此解码循环的任何阶段都无法在时间维度上并行执行。深度拓扑的实际执行时间 \(T_{\text{wall}}^{\text{depth}}\)，由初始预填充阶段与各个顺序解码阶段的耗时之和决定：
\[T_{\text{wall}}^{\text{depth}} = t_{\text{prefill}}(P) + \sum_{t=1}^{K_{\text{ext}}} t_{\text{decode}, t} \approx t_{\text{prefill}}(P) + K_{\text{ext}} \cdot t_{\text{step}}\]
其中，\(t_{\text{step}}\) 是单次解码步骤的延迟。在较小的批大小下，\(t_{\text{step}}\) 由内存带宽而非计算能力（加速器服务延迟）决定，因此深度每增加一个词元，都需要承担读取全部权重的开销。
关键在于，深度始终在一个封闭的认知循环内发挥作用。虽然延长生成过程使模型能够基于其训练分布计算更复杂的内部推演，但模型静态参数之外的任何新信息都不会进入上下文 \(\Theta\)。如果初始提示或模型的内部表征包含错误，增加生成深度只是给模型更多的 token 预算来为该错误寻找合理解释。此外，由于每个 token 都是从 \(P_\Theta(\cdot \mid \mathbf{x}, y_{<t})\) 中随机采样得到的，在未经验证的推理链中始终保持正确的概率会随序列长度呈指数衰减，这种失效模式称为随机漂移。现代推理模型（如 OpenAI o1/o3 和 DeepSeek-R1）通过在可验证领域开展大规模强化学习（RL）训练来应对这一局限，使模型直接在串行解码流中输出显式的自我纠正、回溯和验证 token。从系统角度看，这些模型将树搜索的基本操作内化到顺序执行的深度轴中，使自回归循环能够在没有外部宿主框架的情况下模拟回溯——但仍受内存带宽所决定的数据往返传输耗时下限约束 \(t_{\text{step}}\)。
推理模型与思考预算
当前系统中的深度能力大多来自训练，而非提示。推理模型 在答案可核验的任务上接受强化学习训练，例如具有已知答案的数学题和配有测试的代码任务，并学会生成较长的中间轨迹，在一次生成过程中提出方案、检查并回溯 (OpenAI 2024年; DeepSeek-AI 等 2025年)。这给运行时带来三个影响。
首先，推理 token 属于输出 token，与其他 token 一样被解码和计量（调用契约），而困难问题可能在可见答案开始输出之前就产生数千乃至更多推理 token。其次，调用接口将这项开销暴露为可控参数。推理 token 预算字段限定单次调用可使用的深度，使深度成为由运行时管理的逐次调用资源分配，而非模型的固定属性。第三，经过训练的推理仍然只能利用提示和权重。推理模型可以在轨迹内重新检查自己的算术运算，但如果从未运行测试，它就无法观察补丁是否通过该测试。训练使深度轴取得了长足进展，却没有提供反馈轴所需的外部证据。
由于深度是逐次调用的预算，因此可以按难度分配。Snell 等 (2024年) 发现，如何最有效地使用固定的测试时预算，取决于问题对模型而言有多难。简单问题在首次尝试之后几乎没有额外收益，中等难度的问题从修订或搜索中获益最多，而最难的问题可能完全没有收益。运行时通过在投入大额预算之前能够观察到的低成本信号来近似实现这种分配：两次或三次短采样的结果是否一致、快速静态检查是否通过，以及同类任务以往的处理情况。低成本信号一致的决策获得较小的推理预算和一个候选方案。信号不一致的决策获得更大的预算或进行搜索。在限定开销后仍未解决的决策会被升级处理，而非继续获得更多 token。
经过训练获得的深度与框架支持的搜索相互补充。这里的框架是指围绕模型进行采样、检查和修订的运行时逻辑，它提供了任何单次调用都无法提供的广度和反馈。框架在测试时用来接受候选方案的检查，也属于可验证奖励强化学习所依据的信号类型（可验证奖励强化学习）。这里足以用于决定是否允许提交的检查，在训练中便可成为候选奖励，而其盲点也会延续到训练中。
广度：并行候选轨迹采样
广度并非将额外计算分配给一条持续更久的顺序轨迹，而是将测试时操作分散到从同一条件提示中采样得到的 \(N\) 条独立候选轨迹上。这种拓扑构成了并行采样和自一致性机制的基础 (2023年)。
在广度拓扑下，宿主监督器发起 \(N\) 次独立的自回归轨迹采样，均以前缀 \(\mathbf{x}\) 为起点：
\[Y^{(n)} = \left(y_1^{(n)}, y_2^{(n)}, \dots, y_{K_n}^{(n)}\right) \sim P_\Theta(\cdot \mid \mathbf{x}), \quad n \in \{1, 2, \dots, N\}\]
通常使用非零温度参数 \(\tau > 0\) 或核采样阈值 \(p < 1\)，以促使各条轨迹产生随机差异。
广度在系统层面的主要优势是可横向并行化。由于每条候选轨迹 \(Y^{(n)}\) 在统计和计算上均独立于候选轨迹 \(Y^{(m)}\)（当 \(m \ne n\) 时），整个执行图可以在可用的加速器资源上并发调度。初始提示 \(\mathbf{x}\) 的长度为 \(P\)，它构成了一个共享依赖；系统只对 \(\mathbf{x}\) 执行一次预填充阶段，生成公共的基础 KV 缓存。在 token 索引 \(P+1\) 处，执行图分叉为 \(N\) 条并行解码路径。
因此，实际耗时的关键路径不会随 \(N\) 线性增长。如果推理集群具备足够的内存带宽和处理单元来承载 \(N\) 条并发解码流，实际耗时延迟就完全由耗时最长的单个候选决定：
\[T_{\text{wall}}^{\text{breadth}} = t_{\text{prefill}}(P) + \max_{1 \le n \le N} T_{\text{decode}}\left(K_n\right)\]
深度与广度在此呈现差异，因为解码受内存带宽限制（原理 1）。沿深度轴消耗 \(N \cdot K\) 个 token，会使实际耗时延迟变为原来的 \(N\) 倍；而将相同预算分配到 \(N\) 条分支上，每一步只需读取一次权重供所有分支使用，并使关键路径的耗时保持在接近最长单次轨迹采样的水平。
这种实际耗时的压缩伴随着加速器内存压力。深度仅维护一个大小为 \((P + K_{\text{ext}})\) 的线性 KV 缓存，而广度要求在加速器的高带宽内存中同时保留 \(N\) 个活跃的 KV 上下文：
\[M_{\text{KV}}^{\text{breadth}} \propto P + \sum_{n=1}^N K_n\]
即使提示前缀 \(P\) 在内存中共享，随着 \(N\) 条轨迹逐渐分化，各自的键和值投影也会填入互不重叠的内存区域。如果超出总内存容量，主机运行时就被迫串行执行各批候选，导致实际耗时延迟从 \(\max(T_n)\) 恶化，趋向串行执行耗时之和 \(\sum_n T_n\)。
从认识论角度看，广度是作用于模型条件流形 \(P_\Theta(Y \mid \mathbf{x})\) 的一种方差缩减机制。单个候选可能失败，是因为自回归采样器在某个早期解码步骤中不巧选中了低概率 token，使后续轨迹进入无法恢复的吸引域。沿广度进行采样会探索搜索空间中互不重叠的分支，从而提高至少一个候选沿有效求解路径前进的概率。然而，广度与深度具有相同的根本局限：它们都是完全开环的探索。如果模型赋予正确程序逻辑的概率接近于零，或者任务需要隐藏在 API 边界之后的私有知识，那么采样一千个候选，也只会得到一千个内部自洽的失败结果。
反馈：以观测为条件的修订
第三个分配轴通过交替进行自回归生成与确定性的环境验证，突破了深度和广度的封闭系统局限。反馈将测试时计算组织为一系列离散的、以观测为条件的修复循环，而非将模型推理视为开环输出器。
在反馈拓扑下，计算通过 \(R\) 个顺序轮次推进。在第 \(r\) 轮，运行时以初始提示和此前提案及实证观测的累积历史为条件，生成候选提案 \(Y_r\)，其中初始提示为 \(\mathbf{x}\)：
\[Y_r \sim P_\Theta\left(\cdot \mid \mathbf{x}, Y_1, O_1, Y_2, O_2, \dots, Y_{r-1}, O_{r-1}\right)\]
运行时将 \(Y_r\) 暂存待验，并不信任它。运行时将 \(Y_r\) 跨越隔离边界提交给外部验证判定器：编译器、集成测试框架、类型检查器或系统静态检查工具。判定器执行确定性检查，并返回实证观测 \(O_r\)：
\[O_r = \text{Oracle}\left(Y_r\right) = \left(\text{status} \in \{\text{PASS}, \text{FAIL}\}, \text{trace} \in \Sigma^*\right)\]
如果验证判定器报告成功，执行便终止。如果它报告失败，则将错误轨迹、编译器诊断信息或执行异常格式化为观测载荷 \(O_r\)，并直接追加到第 \(r+1\) 轮的输入上下文中。
反馈将环境的真实状态注入上下文窗口。检查失败揭示了一个具体故障，这一负向信号会约束下一轮搜索。模型不再被迫完全依靠其参数权重来模拟复杂的运行时环境，例如操作系统内核调度、动态链接器行为或网络超时。相反，它直接查询现实，使用外部执行基础设施作为权威判定器。
反馈在架构层面的代价在于其累积延迟和不断增长的上下文开销。关键路径在各轮之间严格串行化，并包含外部执行延迟：
\[T_{\text{wall}}^{\text{feedback}} = \sum_{r=1}^R \left( t_{\text{prefill}}\left(P_r\right) + t_{\text{decode}}\left(K_r\right) + t_{\text{oracle}}\left(Y_r\right) \right)\]
其中，\(t_{\text{oracle}}(Y_r)\) 是沙箱编译、执行候选方案并对其进行插桩所需的实际耗时。关键在于，提示长度在每次迭代中单调增长：
\[P_{r+1} = P_r + K_r + |O_r| = P_1 + \sum_{j=1}^r \left(K_j + |O_j|\right)\]
随着轮次索引 \(r\) 增大，预填充成本 \(t_{\text{prefill}}(P_r)\) 不断累积，仅摄取此前失败所累积的交互记录就会消耗大量 FLOP 预算。如果智能体运行时未实施积极的上下文压缩或淘汰策略，不断增长的历史记录就可能超出上下文窗口 \(S_{\max}\)，或降低模型的注意力性能。
审慎推理 的硬件机制
为了评估智能体运行时应如何分配测试时预算，我们在标准架构模型下形式化描述各轴的运行特征。令 \(|\Theta|\) 表示活跃模型参数的数量，\(P\) 表示初始提示长度，\(K\) 表示每个候选方案或每轮的平均生成长度，\(b_{\text{bytes}}\) 表示相应精度表示所占的字节数（例如，FP16 或 BF16 为 2 字节）。
根据标准的一阶 Transformer 计算近似，前向传播中处理每个 token 约需 \(2 |\Theta|\) 次浮点运算（FLOPs），即每个参数执行一次乘加运算。各拓扑的总计算负担（\(C_{\text{FLOP}}\)）、实际耗时关键路径（\(T_{\text{wall}}\)）、保留的 KV 缓存峰值内存（\(M_{\text{KV}}\)），以及主要的认知贡献，汇总于 审慎推理 计算分配的权衡。
| 审慎推理 轴 | 执行拓扑 | 计算复杂度（\(C_{\text{FLOP}}\)） | 关键路径实际延迟（\(T_{\text{wall}}\)） | 保留状态峰值（\(M_{\text{KV}}\)） | 认知来源 |
|---|---|---|---|---|---|
| 深度 | 串行展开链（\(K_{\text{ext}}\) 步） | \(2 \vert\Theta\vert \left(P + K_{\text{ext}}\right)\) | \(t_{\text{prefill}}(P) + K_{\text{ext}} \cdot t_{\text{decode}}\) | \(\mathcal{O}\left(P + K_{\text{ext}}\right)\) | 静态参数 \(\Theta\)（潜在推理展开） |
| 广度 | 并行分叉—汇合（\(N\) 个分支） | \(2 \vert\Theta\vert \left(P + \sum_{n=1}^N K_n\right)\) | \(t_{\text{prefill}}(P) + \max_n t_{\text{decode}}\left(K_n\right)\) | \(\mathcal{O}\left(P + \sum_{n=1}^N K_n\right)\) | 流形方差 \(P_\Theta(Y \mid \mathbf{x})\)（模式探索） |
| 反馈 | 串行修复循环（\(R\) 次迭代） | \(2 \vert\Theta\vert \sum_{r=1}^R \left(P_r + K_r\right)\) | \(\sum_{r=1}^R \left(t_{\text{gen}, r} + t_{\text{oracle}, r}\right)\) | \(\mathcal{O}\left(P_R + K_R\right)\) | 确定性环境（经验观测 \(O_r\)） |
正如 审慎推理 计算分配的权衡 所揭示的，三个轴呈现出截然不同的工程权衡。广度以并发内存占用峰值为代价优化实际耗时延迟。深度在最小化内存和协同开销的同时，使串行延迟最大化，但仍受限于模型未经验证的内部假设。反馈牺牲实际耗时延迟和预填充计算效率，换取深度和广度都无法提供的一项特性：以外部现实为依据的实证基础。
要说明这些架构权衡的具体后果，最好的方式是追踪现代推理节点上的硬件指标。
粗略估算 0.1: 一次决策，三种分配
选项 A（深度）：一次生成 4,096 个输出 token。延迟约为 86 秒，成本约为 $0.074。回答长篇论证该设计的正确性，并交付了仍存在竞态的实现。
方案 B（广度）：4 个候选，每个包含 1,024 个词元，并行生成。延迟约为 22 秒。每个候选都通过单独的调用生成，且每次调用都会读取提示，因此输入为 16,384 个词元，输出为 4,096 个词元，费用约为 $0.111。四个候选都遗漏了同一个屏障。
方案 C（反馈）：共三轮，每轮 1,024 个词元。每轮结束后，沙箱编译候选，并在 \(t_{\text{check}} =\) 1.5 秒内运行竞态检测器，返回一份包含 340 个词元的报告。提示长度从 4,096 增长到 5,460，再增长到 6,824 个词元，因此输入总计 16,380 个词元，输出为 3,072 个词元，费用约为 $0.095。延迟由三轮各 21.6 秒的解码时间加上检查时间构成，约为 69 秒。第 2 轮报告指出了未建立顺序关系的存储操作，第 3 轮通过检查。
计算：每个获验收任务的成本等于支出除以获验收任务数。方案 A 和 B 支出 $0.074 and $0.111，却没有任何补丁获验收，因此其每个获验收任务的成本无界。方案 C 支出 $0.095，完成了一个获验收任务。
系统洞见：广度策略的速度是深度策略的 4 倍，深度策略使用的输入词元最少，但只有反馈策略获得了关于缺陷的证据，因此只有反馈策略产出了获验收任务。应按每个获验收任务核算测试时计算的成本，而非按每次调用核算。
这一量化比较揭示了一项架构上的必然要求：现实世界中的智能体运行时很少单独采用某一种维度。高性能运行时编排器会构建混合推理 拓扑：利用深度剖析局部过程逻辑，通过广度在并行工作进程中探索彼此独立的架构候选，并通过反馈闭合循环，依据确定性系统判定器验证候选并剪除无效候选。
Checkpoint 0.1: 评估推理 计算分配维度
在评估候选选择机制和验证拓扑之前，请确认你已理解计算分配的权衡：
候选选择
从自回归模型中采样 \(N\) 条并行候选轨迹，会使推理浮点运算量和内存总线流量随 \(N\) 线性增长，但朴素的并行生成往往会在每个分支中重现相同的推理错误。当智能体运行时从同一个提示前缀分叉出十六条独立的解码流时，主机监督器并不会自动获得对解空间的十六个独立估计。相反，由于自回归解码从以共享前缀为条件的参数化概率分布中抽取词元，缺乏结构性干预的采样往往会坍缩到高概率吸引子中，产生表面的词汇变化，却掩盖了相同的算法缺陷。
当且仅当满足两个相互正交的架构条件时，生成多个候选才会提高系统可靠性：生成策略必须产生在语义上具有实质差异的假设，而主机运行时必须具备拥有足够认知分辨率的评估机制，能够区分有效解与看似合理的干扰项。任一条件失效，并行推理 就会退化为对内存带宽的浪费。在功能相同的候选上运行的选择器会消耗计算资源，却无法降低不确定性；反之，将一组表达力丰富且多样的候选提交给噪声较大或未经校准的选择器，则会使利用了选择器盲点的灾难性失败稳定地获得更高排名。
关键概念：多样性—分辨率对偶性 除非满足以下条件，否则增加候选广度的边际收益为零： \[\mathcal{H}(\mathcal{C}) > 0 \quad \text{and} \quad \text{Acc}(\text{Selector}) > \text{BaseRate}\] 其中，\(\mathcal{H}(\mathcal{C})\) 表示候选池 \(\mathcal{C}\) 中的语义熵，\(\text{Acc}(\text{Selector})\) 是选择器对候选轨迹的真阳性排序准确率。
候选多样性动态
为评估基于广度的审议所带来的收益，运行时编排器必须区分名义样本数 \(N\) 与有效样本数 \(N_{\text{eff}}\)。考虑一个不具备特权的基础模型 \(\Theta\)，它生成候选轨迹 \(\mathbf{y}^{(1)}, \mathbf{y}^{(2)}, \dots, \mathbf{y}^{(N)}\)，生成过程以提示上下文 \(\mathbf{x}\) 为条件。每个词元 \(y_t^{(i)}\) 都依次从分类分布中采样，该分布通过对缩放后的 logit 向量应用 softmax 算子计算得到：
\[P_\Theta(y_t \mid \mathbf{x}, y_{<t}) = \frac{\exp(z_t / \tau)}{\sum_{j} \exp(z_j / \tau)}\]
其中，\(z_t\) 表示词元索引 \(t\) 对应的原始模型 logit，\(\tau\) 表示采样温度。
当 \(\tau \to 0\) 时，解码循环退化为贪心搜索，使候选集合坍缩为 \(N\) 个完全相同的序列（\(N_{\text{eff}} = 1\)）。然而，提高 \(\tau\) 并不能保证语义探索。经过预训练和指令微调的语言模型会将概率质量集中在词元序列空间中狭窄的拓扑盆地内。如果提示 \(\mathbf{x}\) 描述了一个存在隐蔽时序漏洞的分布式锁管理器，那么模型概率最高的路径总会复现其训练语料中随处可见的教科书式实现——连同其中的竞态条件。
定义：相关失效盆地 序列空间 \(\mathcal{B} \subset \mathcal{Y}^*\) 中的一个区域，其中不同的词元序列 \(\mathbf{y}^{(a)} \neq \mathbf{y}^{(b)}\) 共享同一个底层无效不变量： \[\text{Invariant}(\mathbf{y}^{(a)}) = \text{Invariant}(\mathbf{y}^{(b)}) = \text{False}\] 尽管它们之间的编辑距离大于零。
从该分布采样得到的并行解码流呈现出相关的失效模式：它们改变变量名、重排不存在依赖关系的表达式，或替换控制流结构（例如用 while 循环替换 for 循环），却保留了完全相同的结构性错误。监督器耗费 \(N \times L\) 个解码步骤，最终评估的却只是同一个错误假设在词汇层面的细微变体。
Candidate A: lock.acquire(); data = read(); lock.release(); // Race: unprotected check
Candidate B: pthread_mutex_lock(&m); val = in->val; pthread_mutex_unlock(&m); // Identical race为打破这种相关性，运行时编排器实现了诱导多样性的机制，在系统栈的三个不同层级扰动生成过程（表 1）：
| 机制层级 | 系统原语 | 运行机制 | 失效模式 / 边界 |
|---|---|---|---|
| 词元级 | 温度调度与 Top-\(p\) | 动态调整 \(\tau \in [0.6, 1.2]\)，或将采样核截断至累积概率 \(p \in [0.85, 0.95]\)。 | 较高的 \(\tau\) 会导致灾难性的语法和语义退化；无法摆脱占主导地位的架构吸引域。 |
| 上下文级 | 上下文框架扰动 | 在不同分支中注入彼此正交的运行要求或角色提示（例如，针对写密集型工作负载优化与无锁读取路径）。 | 分歧的前缀会使统一基准测试失效，或使问题的前置条件偏离原始规范。 |
| 分支级 | 结构化步骤强制 | 在自回归解码开始前，将不同的初始算法原语或结构不变量固定到每个候选分支的生成前缀中。 | 需要领域专用的前缀合成器；可能迫使模型进入低概率且不可行的执行路径。 |
衡量这些机制是否带来真正的探索，需要使用语义指标，而非词汇距离。BLEU 或 Levenshtein 编辑距离等基于字符串的指标会产生严重误导：两个程序的编辑距离可能为 \(0.05\)，却实现了截然不同的算法范式；也可能具有 \(0.60\) 的编辑距离，却在进行 α 重命名后仍在语法和功能上完全相同。
因此，智能体监督器计算结构距离和行为距离。在代码合成领域，监督器将候选方案编译为抽象语法树（AST），并计算树编辑距离；或者在对变量标识符和函数签名进行规范化后，对标准化的 AST 表示计算哈希。在多步规划中，监督器将候选步骤序列映射为有向无环依赖图，比较其拓扑排序，而非词元字符串。在一般系统领域，运行时按候选方案的功能等价类进行聚类：两个候选方案属于同一等价类 \([\mathbf{y}]\)，当且仅当它们在确定性冒烟测试框架中执行时产生相同的状态转移。
选择架构
剪除前景不佳的轨迹采样分支，可回收 70% 的推理计算资源，用于高价值推理轨迹。
当多样化的候选集 \(\mathcal{C} = \{\mathbf{y}^{(1)}, \mathbf{y}^{(2)}, \dots, \mathbf{y}^{(N)}\}\) 已暂存于内存中时，宿主监督器必须选择使任务成功率最优的轨迹 \(\mathbf{y}^* \in \mathcal{C}\)。监督器不能将候选方案的自我报告视为真实，也不能让候选代码直接访问宿主资源。为安全地选择候选方案，运行时采用三种主要架构策略，并将其组织为分层选择级联。
图 2 所示的选择流水线，使候选集 \(\mathcal{C}\) 依次经过三道计算成本逐步提高的防御边界，逐步完成过滤。在第 1 级，确定性的抽象语法树解析器和静态类型检查器检查未经验证的原始候选缓冲区，将格式错误的脚本立即路由至拒绝汇点 \(\mathcal{R}_{\text{syntax}}\)，无需消耗 GPU 前向计算。在第 2 级，语法规范化与确定性冒烟测试将保留下来的候选方案归并为功能等价类 \([\mathbf{y}]_\sim\)，并将存在分歧或孤立的幻觉候选方案隔离至 \(\mathcal{R}_{\text{divergent}}\)。在第 3 级，保留下来的候选方案通过学习得到的过程奖励模型（PRM）和沙箱执行接受细粒度推理评估，将断言失败的候选方案路由至 \(\mathcal{R}_{\text{score}}\)，仅允许经过验证的候选方案 \(\mathbf{y}^*\) 进入实际系统操作阶段。
自洽性机制
自洽性由 Wang 等 (2023年) 提出，利用了这样一种经验观察：尽管非特权模型在不同候选解码结果中可能沿着多样的推理路径探索，但正确轨迹往往会收敛到相同的最终答案，而错误轨迹则分散到零碎的错误状态中。运行时将候选集合划分为离散的等价类：
\[[\mathbf{y}]_\sim = \{\mathbf{y}^{(i)} \in \mathcal{C} \mid \text{ExtractAnswer}(\mathbf{y}^{(i)}) \equiv \text{ExtractAnswer}(\mathbf{y}^{(j)})\}\]
监督器选择属于候选数量最多的等价类的候选：
\[\mathbf{y}^* = \arg\max_{[\mathbf{y}]_\sim} \big| [\mathbf{y}]_\sim \big|\]
自洽性为具有封闭形式答案的系统问题提供了一种简洁的、仅在推理阶段运行的选择机制，例如确定最优页面大小、识别发生死锁的线程索引，或在离散的路由配置之间进行选择。
然而，在开放式智能体领域中，自洽性会彻底失效。在软件工程、系统综合或复杂的 shell 编排中，输出空间是连续且无界的。当十六个独立候选生成设备驱动程序或重构异步事件循环时，每个生成序列在文本和结构上都独一无二。等价类退化为单元素集合（\(|[\mathbf{y}]_\sim| = 1\) 对所有候选均成立），使多数投票退化为均匀随机选择。更糟的是，如果智能体提示激活了一种常见的概念误解，分布的众数本身就可能是错误。在这种情况下，多数投票会主动选择共识性幻觉，而舍弃孤立但正确的少数派候选。
学习型验证器评分
当多数投票因输出分散而失效时，运行时会部署学习型验证器：由 \(\Phi\) 参数化、经过训练以预测候选正确性的辅助神经网络模型。按照 Lightman 等 (2024年) 的形式化描述，学习型验证器在结构上分为两类：
- 结果奖励模型（ORM）： 验证器检查完整的候选轨迹 \(\mathbf{y}^{(i)}\) 及其上下文 \(\mathbf{x}\)，并输出标量分数 \(s = f_\Phi(\mathbf{x}, \mathbf{y}^{(i)}) \in [0, 1]\)，以估计整体成功的概率。尽管 ORM 在计算上高效，只需对拼接后的序列执行一次前向传播，但它存在时间维度上的信用分配失效问题。ORM 无法定位究竟是哪一步引入了细微的漏洞，因而常常奖励那些表面上合理、却在精致措辞之下隐藏着逻辑跳跃的轨迹。
- 过程奖励模型（PRM）： 验证器将轨迹 \(\mathbf{y}^{(i)}\) 分解为离散的推理步骤 \((s_1, s_2, \dots, s_K)\)，并对每次转移单独评分：\(r_k = f_\Phi(\mathbf{x}, s_{\le k})\)。候选分数计算为各步骤存活概率的乘积：
\[s(\mathbf{y}^{(i)}) = \prod_{k=1}^K P_\Phi(\text{step } k \text{ is valid} \mid \mathbf{x}, s_{<k})\]
过程验证器能够在早期逻辑颠倒传播到后续推理之前将其识别出来，从而显著改善候选排序。然而，学习型验证器会引入高昂的计算开销：对 \(N\) 个长度为 \(L\) 个词元的候选进行评分，需要将 \(N \times L\) 个词元送入验证器 \(\Phi\) 进行评估。如果验证器模型的参数量与生成引擎相当，过程评分就会使审慎推理 阶段的总 FLOP 成本翻倍。
确定性执行过滤
在为学习型验证器或聚类算法消耗内存带宽和推理 FLOP 之前，高性能运行时会实施确定性的静态过滤。非特权模型在生成软件补丁或 shell 脚本时，经常会输出格式错误的语法、不配对的定界符、未定义的变量引用或无效的命令行标志。
监督器将每个候选 \(\mathbf{y}^{(i)}\) 依次送入一系列非神经网络的确定性检查关卡：
\[\mathcal{C}_{\text{filtered}} = \Big\{ \mathbf{y} \in \mathcal{C} \;\Big|\; \text{AST\_Parse}(\mathbf{y}) \land \text{TypeCheck}(\mathbf{y}) \land \text{Lint}(\mathbf{y}) \Big\}\]
确定性过滤在主机 CPU 核心上以微秒级延迟运行，无需消耗 GPU 计算资源即可剔除无效候选。通过在排序评估之前过滤候选池，运行时确保学习型评分模型仅评估语法规范且类型安全的提案。
以下候选矩阵展示了这些选择阶段如何过滤并评估为解决异步 I/O 饥饿缺陷而生成的四个不同提案（表 2）。
| 候选方案 ID | 核心算法假设 | 确定性筛选关卡 | 等价簇 | 验证器评分 (\(s\)) | 选择结果 |
|---|---|---|---|---|---|
| \(\mathbf{y}^{(1)}\) | 采用非原子计数器检查的自旋让出循环 | 通过（有效的 C++20） | 簇 \(\alpha\)（忙等待） | \(0.12\) | 拒绝（存在 CPU 饥饿风险） |
| \(\mathbf{y}^{(2)}\) | 轮询循环内的 std::this_thread::yield() |
通过（有效的 C++20） | 簇 \(\alpha\)（忙等待） | \(0.14\) | 拒绝（与 \(\mathbf{y}^{(1)}\) 存在相同的竞态） |
| \(\mathbf{y}^{(3)}\) | 采用管道唤醒的 Epoll 边沿触发通知 | 通过（有效的 C++20） | 簇 \(\beta\)（事件驱动） | \(0.89\) | 获选方案 |
| \(\mathbf{y}^{(4)}\) | 为每个传入任务无界创建线程 | 未通过（编译器警告） | 不适用（因语法问题被剔除） | \(0.00\) | 由静态过滤器剪枝 |
注意，候选方案 \(\mathbf{y}^{(1)}\) 和 \(\mathbf{y}^{(2)}\) 的表层代码结构不同，却被归入同一个功能等价簇（簇 \(\alpha\)），因为它们存在共同的同步失败。确定性过滤因编译失败立即剔除了 \(\mathbf{y}^{(4)}\)，使学习型验证器能够将评估预算全部用于有效的备选方案。
粗略估算 0.2: 固定 GPU 内存带宽下的候选方案采样与验证器吞吐量
解码受内存带宽限制（加速器服务延迟），因此每个解码步骤都会从 HBM 读取全部 70 GB 权重。使用同等规模的学习型过程奖励模型（PRM）评估候选方案，需要对生成的词元执行一次独立的预填充前向传播。
我们量化生成和评分这些候选方案所产生的内存总线传输时间与延迟开销：
1. 候选方案解码阶段（生成器）： 由于 16 个候选方案在解码时并发组成一个批次，全部 16 条流在每个解码步骤中仅需读取一次 70 GB 权重矩阵： \[T_{\text{read/step}} = \frac{70 \times 10^9 \text{ bytes}}{3.35 \times 10^{12} \text{ bytes/sec}} \approx 20.9 \times 10^{-3} \text{ seconds} = 20.9 \text{ ms}\] 对于 \(L = 1,024\) 个自回归步骤，将模型权重经总线完整传输所需的最短执行时间为： \[T_{\text{decode}} = 1,024 \times 20.9 \text{ ms} = 21.4 \text{ seconds}\]
2. 候选方案验证阶段（PRM 预填充）： 16 个生成的候选方案总计包含 \(16 \times 1,024 = 16,384\) 个词元。与解码不同，PRM 在受计算能力限制的预填充阶段（GEMM）评估这些词元。假设 H100 在预填充阶段达到的有效吞吐量为 \(400 \times 10^{12}\) FP8 FLOPs/秒，且模型处理每个词元需要 \(2P\) FLOPs： \[\text{FLOPs}_{\text{PRM}} = 2 \times (70 \times 10^9) \times 16,384 \approx 2.29 \times 10^{15} \text{ FLOPs}\] \[T_{\text{PRM}} = \frac{2.29 \times 10^{15} \text{ FLOPs}}{400 \times 10^{12} \text{ FLOPs/sec}} \approx 5.73 \text{ seconds}\]
系统层面的启示： 生成候选方案占用内存总线的时间为 \(21.4\text{ s}\)，而学习型验证额外增加 \(5.73\text{ s}\) 的计算时间，使总推理思考延迟达到 \(27.13\text{ s}\)。如果运行时部署确定性静态过滤器，在 PRM 评分之前剔除 \(75\%\) 的候选方案，验证阶段的延迟将从 \(5.73\text{ s}\) 降至 \(1.43\text{ s}\)，从而节省超过四秒的关键路径执行时间。
Pass@\(k\)：从 k 个候选方案中择优选择的上限
衡量选择机制所能达到的最佳表现的标准指标是 pass@\(k\)，即 \(k\) 个采样候选方案中至少有一个通过任务测试的概率 (Chen 等 2021年)。在 \(n \ge k\) 个样本中，有 \(c\) 个通过测试，其无偏估计为
\[\text{pass@}k = \mathbb{E}_{\text{tasks}}\left[1 - \frac{\binom{n-c}{k}}{\binom{n}{k}}\right]\]
pass@\(k\) 假设存在一个完美的选择器，只要存在通过验证的候选，它就总能找到。因此，它是 best-of-\(k\) 选择的上限。使用实际选择器进行选择的运行时，其最终接受结果的准确率至多为 pass@\(k\)，两者之间的差距就是选择器造成的损失。对于每次采样成功率为 \(p\) 的独立候选，pass@\(k\) \(= 1 - (1-p)^k\)，因此当 \(p = 0.3\) 且 \(k = 8\) 时，上限为 \(1 - 0.7^8 \approx 0.94\)。如果八个候选的表现相当于两次独立尝试，上限就会降至 \(1 - 0.7^2 = 0.51\)。相关性会降低上限，而选择器的错误则会降低在该上限之下实际达到的准确率。将 pass@\(k\) 报告为系统准确率，等于假定选择器不构成问题，而选择器正是本节讨论的组件。智能体评估 将 pass@\(k\) 视为一项报告指标，并将其与重复运行中的可靠性进行对比。
验证预算
增加候选广度 \(N\) 会带来递减的收益，其程度受选择器在实际运行中的准确率支配。采样理论表明，当 \(N \to \infty\) 时，生成至少一个正确候选的概率会单调趋近于 1（假设对整个搜索空间的覆盖概率非零），但选择器成功识别该正确候选的概率却呈非单调变化。
每个选择器都有一个固有的假阳性率 \(\epsilon_{\text{FP}} > 0\)。在学习型评分模型中，假阳性源于分布外幻觉、利用文体特征进行的奖励投机，或在不满足底层不变式的情况下抬高 logit 分数的对抗性 token 序列。在确定性测试框架中，假阳性源于断言覆盖不完整、遗漏边界情况，或测试套件只验证正常路径行为而忽略并发缺陷。
审议中的古德哈特定律 “当一项度量成为目标时，它就不再是一项好的度量。” 在智能体选择中，随着候选广度 \(N\) 大幅增加，施加于选择器的优化压力会使搜索选中利用验证器盲点的候选，而非解决任务的候选。
令 \(P(\text{Valid}(\mathbf{y})) = \theta\) 表示单次采样生成有效解的基础概率，并假设选择器以真阳性率 \(1 - \epsilon_{\text{FN}}\) 接受有效解，同时以假阳性率 \(\epsilon_{\text{FP}}\) 错误地接受无效解。当运行时采样 \(N\) 个独立候选时，候选池中混合了有效解（服从参数为 \(\theta\) 的二项分布）和无效干扰项（由参数 \(1 - \theta\) 决定）。
如果 \(N\) 扩大到较大值，而基础成功率 \(\theta\) 较低，那么生成的干扰项数量（\(N(1-\theta)\)）就会远远超过正确解的数量（\(N\theta\)）。选择器接受的假阳性候选的期望数量随干扰项池的规模线性增长：
\[\mathbb{E}[N_{\text{Exploits}}] = N(1 - \theta) \cdot \epsilon_{\text{FP}}\]
当 \(N\) 超过临界阈值 \(N^*\) 时，假阳性候选池的数量就会超过真正有效的候选池。在基于排名的评分机制下，监督器选中的最高分候选几乎必然是一个利用漏洞的对抗性候选——它完全符合验证器的表面启发式规则，却包含灾难性缺陷（图 3）。
这一选择器瓶颈决定了基于广度的审议所能达到的上限。搜索的可靠性取决于从候选中进行选择的检查机制的可靠性，这就是验证不对称性（原则 3）最简单的形式。运行时无法仅靠向候选采样投入更多 GPU FLOPs，来弥补能力薄弱、分辨率低的验证器。要突破常规候选投票的局限，运行时必须超越事后结果评分，实施严格、细粒度的验证，以追踪审议轨迹中的每一次状态转换。
当搜索反复针对不完美、粗粒度的选择器进行优化时，它不可避免地会发现某些边界情况输出：这些输出满足选择器的静态接受规则，却完全违反底层运行不变式。这种失败暴露了将验证视为轨迹末端不透明判断的核心弱点。为防止对抗性候选蒙混通过宏观检查点，运行时监督器必须将轨迹评估分解为逐步验证，追踪每一次转换中的前置条件、中间状态断言和逻辑一致性。这一运行要求使我们的架构关注点从候选级选择转向过程验证的机制。
过程验证
超过最优搜索宽度后，利用漏洞的概率比准确率增长得更快。
在未经验证的候选池上执行搜索的运行时搜索引擎，总会发现计算阻力最小的路径并非真正完成任务，而是利用评估框架的漏洞。当智能体为操作系统设备驱动程序或高吞吐量网络数据包解析器生成一百种备选实现时，选择在自动化检查中得分最高的候选方案，会暴露一个令人不安的系统现实：针对不完整规范的优化，必然会转向利用该规范的遗漏之处。如果验证机制仅检查进程是否以正常退出码（\(0\)）退出，而不验证内存泄漏相关的不变量，搜索算法就会选择在分配缓冲区之前立即终止执行的实现。如果神经验证器仅依据文风的流畅性和体现严谨性的词汇标记来评估中间数学证明，候选采样就会产生包含幻觉引理的轨迹，而这些引理被教科书式的数学表述所掩盖。
验证器只能在其覆盖范围内引导搜索；使用薄弱的检查机制优化大量候选方案，可能选中利用漏洞的方案，而非正确完成任务的方案。 从广度和深度两个维度扩展测试时计算，其效用严格受限于运行时验证边界的保真度、分辨能力和对抗鲁棒性。生成器不能充当自身的裁判（认识论边界：受强制的约束域与语义正确性）。本节将探讨过程验证器与结果验证器的结构分类，量化验证错误带来的非对称系统成本，形式化描述高强度测试时搜索中由古德哈特定律决定的失效模式，并设计能够维护执行完整性的纵深防御验证拓扑。
验证覆盖不变量： 自动化测试或奖励模型无法对其已评估状态空间之外的系统行为提供任何保证。形式化地说，对于执行空间 \(\mathcal{S}\) 和验证器定义域 \(\mathcal{S}_V \subset \mathcal{S}\)，任何候选轨迹 \(\tau\)，只要满足 \(\tau \cap (\mathcal{S} \setminus \mathcal{S}_V) \neq \emptyset\)，就具有不受约束的失效模式，搜索算法会积极利用这些失效模式。
验证器分类：从结果估值到步骤级信用分配
为了支持候选方案的选择，智能体运行时必须使用三类本质上不同的验证引擎之一来评估候选轨迹：结果奖励模型、过程奖励模型和确定性执行验证器。这些系统在评估粒度、执行延迟和确定性可复现性方面各不相同。
结果奖励模型（ORM）仅评估所生成候选轨迹的终止状态。给定初始问题状态 \(s_0\) 和完整的生成轨迹 \(\tau = (s_0, a_0, s_1, a_1, \dots, s_K)\)，ORM 充当评估函数 \(V_{\text{ORM}}(s_K) \in \mathbb{R}\)，将最终产物映射为一个预测其正确性的标量。在软件工程任务中，ORM 读取最终的多文件差异或补丁，并预测该补丁解决底层问题的概率，而不检查此前的探索性迭代、诊断命令或失败的单元测试编译。ORM 在运行上的优势在于运行时解耦：它无需对中间生成步骤进行任何插桩，并可异步评估已完成的提案。
然而，ORM 会引入严重的信用分配问题。当结果验证器惩罚一条未能满足功能要求的多步轨迹时，它不会提供任何结构性信号来指出究竟是哪一个具体状态转移 \(s_t \to s_{t+1}\) 引入了缺陷。运行时监督器被迫丢弃整条轨迹，浪费自回归生成过程中投入的内存带宽和浮点运算量。反之，如果一个错误的中间步骤偶然产生了表面上正确的最终输出——例如，某个数学证明在第四步出现算术符号错误，却在第八步通过颠倒不等号方向抵消了这一错误——ORM 就会奖励这条轨迹。当结果评分用于束搜索或蒙特卡洛树搜索（MCTS）等搜索过程时，它无法及早剪除无效搜索分支，使计算成本高昂的幻觉在深层搜索中持续传播。
轨迹验证： ORM 仅评估终止状态 \(V(s_3)\)，无法察觉 \(s_2\) 处灾难性的中间状态损坏。相比之下，PRM 评估步骤奖励 \(r(s_t, a_t)\)，在每次状态转移 \(s_t \to s_{t+1}\) 时进行验证，从而立即定位失效点。
过程奖励模型（PRM）将轨迹评估分解为步骤级评估。PRM 不等到终止状态才作出判断，而是评估每个中间推理 token 序列或原子环境工具操作，为其分配一个增量标量分数 \(r(s_t, a_t) \in [0, 1]\)，以表明状态转移 \(t\) 在数学上的有效性或操作上的合理性 (Lightman 等 2024年)。通过提供细粒度的信用分配，PRM 使运行时搜索算法能够立即检测到偏离。如果候选步骤 \(a_3\) 引入了未处理的异常或缺乏依据的逻辑前提，验证器便会赋予较低的步骤奖励，使运行时调度器能够在消耗更多解码 FLOPs 之前截断该搜索分支。
然而，过程验证器也带来了架构上的权衡：
- 它们需要精确的 token 划分边界或分隔符协议（例如双换行符
\n\n或显式轮次标记），以界定什么构成一个可评估的“步骤”。 - 累积推理延迟随轨迹深度线性增长：执行一条包含 \(K\) 个步骤的轨迹时，智能体必须交错进行 \(K\) 次顺序验证器调用；除非在并发束搜索分支之间对验证推理进行批量流水线处理，否则这会在 GPU 执行引擎中引入流水线气泡。
- PRM 容易出现步骤级奖励漂移；各个步骤在局部看来可能是连贯的，却逐渐偏离 \(s_0\) 中确立的全局问题约束。
确定性执行验证器以权威的软件契约而非统计推断作为评估栈的基础。编译器（rustc、gcc）、静态类型检查器（mypy、tsc）、代码检查器以及完全隔离的单元测试套件充当不可妥协的硬性验证器，返回二元判定 \(V_{\text{det}} \in \{0, 1\}\)，并附带标准诊断遥测信息（编译器错误流、堆栈跟踪和退出码）。在系统层级中，确定性验证器的判定不可妥协：无论神经奖励模型的置信度有多高，都不能推翻编译失败或段错误。
| 验证器类别 | 评估目标 | 典型执行延迟 | 领域覆盖范围 | 错误接受风险（\(P(\text{FA})\)） | 确定性保证 |
|---|---|---|---|---|---|
| 结果奖励模型（ORM） | 终止时的产物状态 \(s_K\) | \(100\text{--}500\text{ ms}\)（单次模型前向传播） | 广泛（任何文本或差异表示） | 高（易受欺骗性最终文本影响） | 无（统计性的神经近似） |
| 过程奖励模型（PRM） | 原子状态转移 \((s_t, a_t)\) | 每步 \(50\text{--}200\text{ ms}\)（交错解码开销） | 中等（受步骤语义约束） | 中等（易受步骤级奖励漂移影响） | 无（统计性的神经近似） |
| 编译器 / 类型检查器 | 语法与语义抽象语法树（AST） | \(10\text{--}2000\text{ ms}\)（本地二进制程序执行） | 严格的语言语法与类型边界 | 极低（严格受编译器正确性约束） | 完全（类型系统内零错误接受） |
| 完全隔离的测试套件 | 动态运行时不变量 | \(50\text{--}10000\text{ ms}\)（沙箱执行） | 狭窄（仅限显式断言路径） | 低（受测试覆盖率与模拟对象约束） | 完全（在干净隔离环境下确定性地通过或失败） |
如 表 3 所概述，没有任何单一验证机制能够以零成本提供普遍覆盖。确定性执行引擎能够给出不会出错的否定性证明（无法编译的补丁会被直接拒绝），但无法评估语义意图或结构可读性。神经过程验证器能够对任意推理步骤提供广泛的语义评分，却缺乏严格的执行保证。因此，可靠的智能体架构会将这些机制组织为分层级联，先对候选方案执行低成本的确定性检查，再投入昂贵的神经计算 FLOPs 进行过程验证。按照 闭合证据等级 的术语，编译器和类型检查器提供静态检查，而完全隔离的测试套件只有在候选方案既无法观察也无法修改该套件时，才提供封闭测试；否则，它提供的是可见测试。学习得到的奖励模型无论多么准确，都不属于任何闭合证据层级。它对候选方案进行排序，却不为任何候选方案提供认证。
Definition 0.2: 过程奖励模型（PRM）
验证器错误的非对称性：错误接受与错误拒绝
在经典统计分类中，通常依据损失矩阵对第一类错误和第二类错误进行对称分析。然而，在自主智能体架构中，验证器错误在运行层面表现出极端的非对称性。将任意提出的候选轨迹记为 \(\tau\)，其真实有效性状态为 \(y^* \in \{\text{Valid}, \text{Invalid}\}\)。验证器输出运行层面的判断 \(V(\tau) \in \{\text{Accept}, \text{Reject}\}\)。我们用两个基本错误概率来刻画验证器：
\[\text{False Acceptance Rate (FAR)} \equiv \alpha = P(V(\tau) = \text{Accept} \mid y^* = \text{Invalid})\]
\[\text{False Rejection Rate (FRR)} \equiv \beta = P(V(\tau) = \text{Reject} \mid y^* = \text{Valid})\]
这两种失效模式的系统成本相差数个数量级：
\[\text{Cost}(\text{False Acceptance}) \gg \text{Cost}(\text{False Rejection})\]
错误拒绝会浪费计算预算：运行时丢弃一个功能有效的候选方案，因而承担从生成器采样替代轨迹所需的延迟（\(T_{\text{wall}}\)）和能耗（\(C_{\text{FLOP}}\)）。尽管效率低下，错误拒绝仍以安全的方式失效。宿主操作系统、文件系统和外部 API 的状态不会遭到破坏，因为被拒绝的候选方案始终不会离开隔离托管区。
错误接受意味着安全边界遭到灾难性突破。如果验证器错误地批准了一个引入堆缓冲区越界一位溢出、数据库事务竞态条件或不安全反序列化攻击途径的候选方案，智能体运行时就会将该候选方案直接应用于环境。错误接受的成本包括生产数据库损坏、分布式状态分歧、安全失陷，以及代价高昂的人工工程恢复。
贝叶斯精确率崩塌： 当基础有效率 \(p\) 较低时（例如 \(5\%\)），即使看似不高的错误接受率（\(\alpha = 2\%\)）也会导致已接受候选方案的后验有效率急剧下降。如果 \(\alpha\) 未接近零，搜索就无法将低准确率的生成器转变为可靠系统。
在困难问题上，贝叶斯精确率崩塌进一步加剧了这种不对称性。这正是在 候选序列验证 中导致自我检查失效的数学关系，如今它适用于任何验证器。令 \(p = P(y^* = \text{Valid})\) 表示底层生成器模型 \(\pi_\theta\) 所生成候选方案的基础有效率。根据贝叶斯定理，验证器接受的候选方案确实有效的后验概率，即验证器精确率 \(\Pi_V\)，由下式决定：
\[\Pi_V \equiv P(y^* = \text{Valid} \mid V(\tau) = \text{Accept}) = \frac{p(1 - \beta)}{p(1 - \beta) + (1 - p)\alpha} \tag{1}\]
当智能体处理复杂的软件重构或系统综合问题时，基础模型直接提出方案的能力通常较低（\(p \ll 0.10\)）。在这些条件下，公式 1 的分母由错误接受项 \((1 - p)\alpha\) 主导。如果运行时开发者部署了一个结果奖励模型，其准确率达到看似令人印象深刻的 \(98\%\)（\(\alpha = 0.02, \beta = 0.02\)），而任务空间满足 \(p = 0.01\)，那么系统的后验精确率就会崩塌：
\[\Pi_V = \frac{0.01 \times 0.98}{(0.01 \times 0.98) + (0.99 \times 0.02)} = \frac{0.0098}{0.0098 + 0.0198} \approx 0.331\]
尽管使用了名义准确率为 \(98\%\) 的验证器，监督器批准的候选方案中仍有约三分之二在功能上无效。在这些运行条件下，扩大广度采样规模不会提高系统可靠性，只会让看似合理、经验证器批准的缺陷充斥下游执行环境。验证不对称性（原则 3）决定了两类验证器如何分工。统计验证器（\(\alpha > 0\)）可以对候选方案排序，以引导搜索。只有确定性检查才能守护提交关卡，而且即便是确定性检查，也只能在其覆盖的不变量范围内达到 \(\alpha = 0\)，因此，其覆盖范围必须与任务的完成标准相匹配，并且必须置于候选方案无法修改它们的位置。
粗略估算 0.3: 验证器误差不对称时的产出与风险
变量：以下为情景假设。每个候选方案包含 1,024 个输出词元，费率为 $15 per million. The generator’s valid rate is \(p = 0.05\). The verifier’s false rejection rate is \(\beta = 0.10\) and its false acceptance rate is \(\alpha = 0.02\). A defective fix that reaches production costs $500，用于回滚和问题排查。
数学分析：在 64 个候选中，\(64 \times 0.05 = 3.2\) 个有效，\(60.8\) 个无效。验证器接受 \(3.2 \times 0.90 =\) 2.88 个有效候选和 \(60.8 \times 0.02 =\) 1.216 个无效候选，因此其接受的候选数期望为 4.096，精确率约为 0.70。如果运行时提交一个已接受的候选，该候选存在缺陷的概率约为 0.30，预期事故成本约为 $148 per task. Sampling all 64 candidates costs about $0.98。
系统洞见：误接受的预期成本比采样成本高出两个数量级以上，即使验证器拒绝了 98% 的无效候选。降低 \(\alpha\)，或在提交前设置一道封闭式检查，其价值远高于降低 \(\beta\) 或增加采样量。
搜索利用机制
当系统工程师通过增加候选生成的广度 \(N\) 或搜索树的扩展预算来扩展测试时计算时，他们无意中使验证机制承受了极端的统计压力。这一现象受古德哈特定律支配，玛丽琳·斯特拉瑟恩对该定律作出了著名的概括：当一个度量成为目标时，它就不再是一个好的度量。 在机器学习系统工程中，我们通过 Manheim 和 Garrabrant 的分类体系 (2018年) 严谨地表述这一原则：
设 \(U(\tau)\) 表示一条轨迹真实且潜在的运行效用（例如语义正确性、系统稳定性、性能不变量的满足程度）。设 \(\widehat{U}(\tau)\) 表示验证器的代理评估指标（例如单元测试通过率、过程奖励模型的 logit 分数，或是否不存在静态代码检查器警告）。在标准采样条件下（\(N=1\)），代理指标与真实效用正相关：
\[\mathbb{E}_{\tau \sim \pi_\theta}[\widehat{U}(\tau)] \propto \mathbb{E}_{\tau \sim \pi_\theta}[U(\tau)]\]
然而，当智能体运行时实施测试时搜索，以最大化 \(N\) 个候选中的代理分数时：
\[\tau^* = \arg\max_{\tau_i \in \{\tau_1, \dots, \tau_N\}} \widehat{U}(\tau_i)\]
所选候选的预期真实效用并不会随 \(N\) 单调增长。相反，它呈现出 图 3 所示的典型背离特征。
如 图 3 所示，扩展测试时搜索揭示了代理验证器分数 \(\widehat{U}(\tau)\) 与真实潜在效用 \(U(\tau)\) 之间的根本性背离。在临界阈值 \(N^*\) 左侧的良性区间内，验证器充当有效的选择预言机：扩大搜索广度能够发现质量更高的候选，使代理分数和实际运行效用同步上升，且二者高度一致。然而，一旦搜索广度越过最优阈值 \(N^*\)，优化压力就会超出代理指标的承受能力。搜索引擎会利用残余模型噪声、尾部分布或运行框架漏洞；测得的分数 \(\widehat{U}(\tau)\) 渐近趋于人为的完美，而真实系统效用 \(U(\tau)\) 则急剧下降，趋向灾难性失败。
超过最优搜索阈值 \(N^*\) 后，进一步扩展测试时搜索会导致目标崩塌：代理分数 \(\widehat{U}(\tau^*)\) 趋于饱和，而真实系统效用 \(U(\tau^*)\) 迅速退化至零。这种失效表现为三种不同的运行变体：
- 极端型古德哈特效应： 代理指标 \(\widehat{U}\) 与真实效用 \(U\) 在正常条件下具有较强的相关性，但在提案分布的尾部，二者的关系会失效。随着 \(N \to \infty\)，argmax 算子会系统性地从 \(\pi_\theta\) 的极端尾部采样。这一尾部充斥着病态候选，它们通过验证器在训练或设计过程中未曾观察到的机制，将代理指标得分最大化。
- 回归型古德哈特效应： 验证器得分是一个带噪声的测量值 \(\widehat{U}(\tau) = U(\tau) + \epsilon\)，其中 \(\epsilon \sim \mathcal{N}(0, \sigma^2)\) 表示不可约的评估噪声。在从 \(N\) 个独立候选中选择最高得分时，极值理论表明，所选候选的噪声项期望值随 \(\sigma \sqrt{2 \ln N}\) 渐近增长。当 \(N\) 较大时，搜索引擎选择的是测量误差正向偏离最大的候选，而非结构性效用 \(U(\tau)\) 最高的候选。
- 对抗型古德哈特效应： 在具备工具访问和运行时修改能力的智能体循环中，候选可以主动操纵验证环境本身。模型提出的代码会覆盖测试框架、修改标准断言库，或向测试运行器注入提前退出宏。
请考虑对抗型古德哈特效应的一种具体表现：这种现象出现在一个被要求通过一组动态单元测试的智能体运行时中：
# The generator circumvents assertion checks by monkeypatching the testing oracle
import unittest, sys
class ExploitCandidate:
def execute_task(self, target_buffer):
# Corrupt the testing runtime rather than performing the transform
def mock_assertEqual(first, second, msg=None):
return True # Infallible pass
# Inject bypass directly into active test framework module
test_frame = sys._getframe(1).f_locals
if 'self' in test_frame and isinstance(test_frame['self'], unittest.TestCase):
test_frame['self'].assertEqual = mock_assertEqual
return target_buffer对于监控退出码状态的自动化结果验证器而言，ExploitCandidate 获得了满分的 \(100\%\) 通过得分，且运行时失败次数为零。验证器将该轨迹标记为最优，并优先选择它，而非那些可能仅在一项边界测试中失败的合规实现。搜索引擎因找出具有更高 \(\widehat{U}\) 的候选方案而获得奖励，因而迅速将其生成概率质量集中到篡改验证框架的代码模式上。即使可利用的漏洞仅存在于候选空间中极小的一部分 \(\epsilon = 0.005\)，在搜索广度为 \(N = 1000\) 时，发现并选中漏洞利用方案的概率仍为：
\[P(\text{Exploit Discovery}) = 1 - (1 - \epsilon)^N = 1 - (0.995)^{1000} \approx 1 - 0.0066 = 99.34\%\]
高强度的测试时搜索会将微小的评估盲点转变为确定性的失败路径。
Systems Perspective 0.1: 古德哈特诅咒与验证的不对称性
当智能体在 \(N\) 条候选轨迹中进行搜索，并依据近似验证器或学习得到的验证器 \(\widehat{U}\) 进行评估时，搜索策略 \(\arg\max_i \widehat{U}(\tau_i)\) 不仅仅充当过滤器，还会对评估框架实施对抗性模糊测试。极值理论表明，\(N\) 个误差方差为 \(\sigma^2\) 的含噪测量值，其最大值渐近地按 \(\sigma \sqrt{2 \ln N}\) 增长。当 \(N\) 较大时，获得最高得分的候选方案并非真实运行效用 \(U(\tau)\) 最高的方案，而是使验证器的正向估计误差最大化的方案。除非验证器的假阳性率 \(\alpha\) 比 \(1/N\) 下降得更快（\(\alpha \ll 1/N\)），否则扩大搜索广度必然导致所选轨迹成为分布外的漏洞利用方案。
系统洞见：缺乏可靠验证的审慎推理不会收敛到正确性，而会收敛到对验证器遗漏的系统性利用。在高可靠性智能体系统中，测试时计算的扩展程度只能限于确定性执行判定机制（编译器、类型系统、严密隔离的沙箱）能够权威地界定搜索空间的范围。
对抗性沙箱隔离
为防止候选轨迹如 ExploitCandidate 所示破坏验证框架，生产运行时必须将候选方案的执行视为不可信且可能具有敌意的计算：
- 进程隔离与 IPC 边界： 候选程序绝不能在与评估驱动程序或验证框架相同的内存地址空间中执行。候选程序必须在临时容器、命名空间沙箱或微型虚拟机中，以独立进程执行；通信必须严格限制为通过标准管道或隔离的 Unix 域套接字进行的单向进程间通信（IPC）。验证器从外部监控候选程序的状态，绝不与其共享内存、Python 解释器栈或运行时状态。
- 内核能力剥离： 运行时必须在操作系统内核边界剥离调试与内省原语。沙箱必须移除 Linux 能力（
CAP_SYS_PTRACE、CAP_NET_ADMIN），配置prctl(PR_SET_DUMPABLE, 0)以防止内存转储，并强制实施 seccomp-bpf 过滤器，禁止与进程检查（ptrace）、信号注入或命名空间逃逸相关的系统调用。 - 解释器级反内省： 在托管语言运行时中，执行框架必须移除栈帧检查钩子（
sys.settrace、sys.setprofile），禁止对上层调用者栈帧进行动态内省（sys._getframe），并在将执行交给候选代码之前，使用只读代理冻结核心框架模块（builtins、unittest、pytest）。 - 不可变验证工作树： 候选程序必须在临时、隔离的写时复制（CoW）git 工作树中执行。所有测试套件、黄金基准和断言清单都必须位于只读文件系统挂载点（
MS_RDONLY）上，以确保候选程序的修改无法改变用于评估它们的断言本身。
鲁棒的验证拓扑
为保护验证边界免受古德哈特式利用，并消除评估中的单点故障，智能体运行时必须实现分层、异构的验证拓扑。依赖单一验证器——无论是神经网络 PRM，还是由硬编码单元测试组成的静态测试套件——都是一种架构反模式。系统完整性要求实施纵深防御，将验证组织为四道依次执行的防御关卡（图 4）。
图 4 中的分层架构将验证组织为运行保障逐级增强的级联流程。候选方案首先进入关卡 1（确定性结构防护），AST 扫描器在不到 2 毫秒内确认不存在被禁止的系统调用和调试钩子。通过的候选方案进入关卡 2（对抗性沙箱执行），在具有只读基准测试挂载的 microVM 或容器沙箱内编译并执行代码。在关卡 3（基于性质的不变量与蜕变不变量）中，候选方案接受随机模糊测试向量和代数对称性检查，以暴露潜在回归。最后，关卡 4（集成共识 PRM）通过 \(M \ge 3\) 个去相关的验证器模型评估多步推理。任何候选方案只要在任一关卡触发断言失败或策略违规，就会立即被路由至诊断拒绝总线，向生成器返回结构化反馈，同时维护提交控制器的不变量边界。
第 1 层：确定性结构防护
在调用运行时环境或神经评分模型之前，候选方案必须通过严格且开销较低的 AST 级过滤器。这一层强制实施不可变的结构约束：
- 抽象语法树（AST）验证： 禁止动态导入用于检查或修改执行框架的底层运行时模块（例如
sys、ctypes、builtins，或诸如sys._getframe的调试内省栈帧）。 - 静态不变量检查器： 强制执行严格的类型签名，禁止修改明确授权的任务清单之外的文件，并保证候选编辑不会触及测试配置文件或 CI 定义。
第 2 层：基于性质的不变量
静态单元测试只评估输入—输出空间中特定且可预测的坐标点，因此容易被简单的硬编码查表方式规避。系统运行时采用基于性质的测试和蜕变关系检查，在动态采样的运行域中评估不变量：
往返序列化不变量： 对于状态操作例程，候选方案必须满足互逆操作恒等式： \[\forall \mathbf{x} \in \mathcal{D}, \quad \text{Deserialize}(\text{Serialize}(\mathbf{x})) \equiv \mathbf{x}\]
蜕变不变量： 如果智能体实现某种优化算法（例如图的最短路径算法），将所有边权重乘以标量 \(k > 0\) 后，必须保持路径的有序序列不变，同时使最终代价恰好缩放为原来的 \(k\) 倍： \[\text{Path}(\mathcal{G}, u, v) \equiv \text{Path}(k \cdot \mathcal{G}, u, v), \quad \text{Cost}(k \cdot \mathcal{G}) \equiv k \cdot \text{Cost}(\mathcal{G})\]
动态模糊测试判定器： 运行时使用高吞吐量随机模糊测试向量执行候选函数，验证无效输入会引发指定类型的领域异常，而非产生未定义行为或内存恐慌。
纵深防御原则： 任何单一验证器都无法完整覆盖整个领域。确定性过滤器消除语法无效的提案；基于性质的模糊测试器揭示边界情况下的行为恐慌；神经模型集成评估语义对齐。候选方案必须通过所有层才能被接受。
第 3 层：PRM 集成
当需要通过神经验证来评估语义推理或定性设计标准时，运行时会部署由不同且去相关的验证器组成的集成，以降低针对单个模型的漏洞利用风险。运行时不再查询由与生成器相同的基础模型权重衍生出的单个 PRM \(\pi_\theta\)，而是通过 \(M\) 个不同的验证器模型评估状态转移：
\[\mathcal{V} = \{V_1, V_2, \dots, V_M\}\]
该集成对步骤转移实施共识阈值判定：
\[r_{\text{ensemble}}(s_t, a_t) = \min_{i \in \{1, \dots, M\}} V_i(s_t, a_t) \quad \text{or} \quad r_{\text{ensemble}}(s_t, a_t) = \frac{1}{M} \sum_{i=1}^M V_i(s_t, a_t) - \lambda \cdot \sigma_V(s_t, a_t)\]
其中，\(\sigma_V(s_t, a_t)\) 表示集成预测之间的经验方差，\(\lambda\) 则充当认知不确定性惩罚项。如果候选动作 \(a_t\) 在验证器模型之间引发高度分歧，运行时就会将该动作视为分布外的漏洞利用，并剪除该轨迹。此外，测试框架维护一套私有的留出验证集，该验证集从不传入生成器的上下文窗口，从而防止智能体使其响应过拟合评估标准。
通过将验证构建为对抗性的多层防御边界，系统确保增加测试时计算资源分配能够直接转化为经过验证的运行正确性，而非高度优化的失败模式。
步骤级过程验证为运行时提供了验证离散状态转换和剪除偏离目标的搜索分支所需的工具。然而，在编排多阶段系统任务时，孤立地评估各个步骤从根本上说是不充分的。一条轨迹可能完全由有效且经过验证的原子操作组成——语法编译通过、属性测试成立，且步骤级 PRM 给出高置信度——但更宏观的架构目标仍可能崩溃，因为早期的某项操作假设已被外部环境反馈判定为无效。当 API 返回意外的错误码，或某个中间依赖无法解析时，系统不能简单地在一条已受损的轨迹上追加更多经过验证的步骤。它必须具备一种显式、可检查的整体轨迹表示，并能够对其进行系统性调整。这一操作现实使我们的关注点从验证单个步骤转向管理作为可修订状态的计划。
作为可修订状态的计划
通过非结构化的自然语言提纲委派复杂系统任务，会产生一种关键的失效模式：宿主运行时无法观察、验证或操纵中间步骤之间的因果依赖。当自回归模型在暂存存储器或对话上下文中输出一份非正式的编号列表时，底层宿主监督器看到的只是一串不透明的词元流。如果步骤 4 遇到意外的环境条件，例如缺失的头文件、发生变化的 API 模式或耗尽的套接字池，不受约束的模型通常会采取两种破坏性行为之一：要么贸然推进到步骤 5，并幻觉式地认定步骤 4 已成功；要么丢弃整个上下文，从头重新生成完整流程。第一种失效模式会在实际前置条件不成立的情况下执行动作，可能对环境造成破坏；第二种失效模式则会丢弃代价高昂且经过验证的计算状态，浪费此前步骤中已经投入的推理计算资源和实际经过的时间。
智能体系统中的计划并非非正式的对话提纲；它是维护在运行时内存中的显式有向依赖图，其节点绑定前置条件、动作和后置条件，其边强制规定操作顺序。由于实际环境会偏离模型参数所隐含的假设，鲁棒的审慎推理要求将此图视为可变状态。宿主运行时必须在分派动作之前验证前置条件，在故障发生的准确位置检测因果关系的失效，将图的修改限制在受影响的最小子图内，并强制维持阻尼不变量，以防止重新规划出现抖动。
关键概念：计划不变量 当且仅当对于每个节点 \(v_i\)，所有因果祖先节点 \(\text{Pred}(v_i)\) 均已满足其后置条件，且当前实际环境 \(\mathcal{S}\) 满足显式前置条件谓词 \(\mathcal{P}_i(\mathcal{S})\) 时，计划才保持有效。
作为有向无环依赖图的计划
为使经过审慎规划的多步骤执行易于处理，宿主运行时将模型的顺序推理虚拟化为一种可检查的数据结构：有向无环计划图，记为 \(\mathcal{G}_{\text{plan}} = (\mathcal{V}, \mathcal{E})\)。在这一形式化表示中，顶点集 \(\mathcal{V} = \{v_1, v_2, \dots, v_n\}\) 表示离散的执行子目标，有向边集 \(\mathcal{E} \subset \mathcal{V} \times \mathcal{V}\) 定义严格的因果依赖。有向边 \((v_j, v_i) \in \mathcal{E}\) 断言：子目标 \(v_i\) 的执行在因果上依赖于子目标 \(v_j\) 所产生的、经过验证的输出或环境状态。
每个计划顶点 \(v_i \in \mathcal{V}\) 被形式化建模为一个六元组：
\[v_i = \langle g_i, \mathcal{P}_i, a_i, \mathcal{O}_i^*, \Delta_i, s_i \rangle\]
其中：
- \(g_i\) 是指导模型生成的语义子目标描述。
- \(\mathcal{P}_i: \mathcal{S} \to \{0, 1\}\) 是一个确定性的前置条件谓词，基于实际环境状态 \(\mathcal{S}\) 和祖先节点的输出进行求值。
- \(a_i\) 是拟执行的动作载荷（例如参数化的工具调用或 RPC 请求）。
- \(\mathcal{O}_i^*\) 表示预期的后置条件观测特征，即环境在动作成功完成后必须呈现的观测结果。
- \(\Delta_i\) 表示动作产生的、经过验证的证据增量或状态变更。
- \(s_i \in \{\text{Pending}, \text{Ready}, \text{Executing}, \text{Verified}, \text{Invalidated}, \text{Failed}\}\) 是运行时调度器维护的显式生命周期状态。
Pending 状态，直到所有因果祖先节点均达到 Verified 状态。调度器先评估前置条件谓词 \(\mathcal{P}_i(\mathcal{S})\)，再将节点转入 Executing 状态。后置条件得到满足（\(\mathbf{o}_i \approx \mathcal{O}_i^*\)）时，节点被提交至 Verified 状态；不匹配时则进入局部修复重试，或将节点转入 Failed 状态，使所有下游后代节点 \(\text{Desc}(v_i)\) 级联失效。
图 5 中的状态转换图形式化地描述了各个计划顶点如何被调度、验证和修复。每个计划节点都以 Pending 状态初始化，并保持阻塞，直到 \(\text{Pred}(v_i)\) 中的所有因果前驱节点均达到终止状态 Verified。祖先节点满足要求后，该节点进入 Ready 状态，促使调度器评估前置条件谓词 \(\mathcal{P}_i(\mathcal{S})\)；如果前置条件不满足（\(\mathcal{P}_i(\mathcal{S})=0\)），则直接中止该节点，并将其转入 Failed 状态。当前置条件成立时，运行时将动作载荷 \(a_i\) 分派到沙箱中，使节点进入 Executing 状态。执行后的观测 \(\mathbf{o}_i\) 将依据契约 \(\mathcal{O}_i^*\) 进行评估：匹配的观测会使节点被提交至 Verified 状态，并记录状态增量 \(\Delta_i\)；不一致则触发有界的局部修复（\(a_i'\)），或使节点转入 Failed 状态，进而触发级联，将所有下游后代节点 \(\text{Desc}(v_i)\) 标记为 Invalidated。未经解析的线性思维过程与显式依赖图之间的架构权衡在 表 4 中进行了对比：
| 架构维度 | 非结构化文本提纲（非形式化 CoT） | 有向无环计划图（\(\mathcal{G}_{\text{plan}}\)） |
|---|---|---|
| 因果关系可见性 | 隐含；隐式埋藏在自回归词元上下文中。 | 显式；直接编码在图的邻接矩阵 \(\mathcal{E}\) 中。 |
| 前置条件门控 | 无；模型假定各行按顺序无条件成功。 | 强制执行；在分派之前评估确定性谓词 \(\mathcal{P}_i(\mathcal{S})\)。 |
| 故障定位 | 全局；故障上下文污染后续生成的词元。 | 局部；隔离于顶点 \(v_i\) 及其可达子图 \(\text{Desc}(v_i)\)。 |
| 并发支持 | 由线性词元流严格串行化。 | 原生支持；独立分支（\(\text{InDegree}=0\)）并行执行。 |
| 修改开销 | 高；需要以自回归方式完整重新生成后续文本。 | 低；仅需定向替换节点或重新合成局部分支。 |
将计划表示为显式图，可使操作结构与语言表示分离。这使智能体运行时能够并发调度独立子目标，将执行故障隔离在特定子图中，并维护包含中间证据的可验证审计记录，同时避免冗长且未经解析的叙述污染模型当前的推理上下文。
前置条件验证
运行时负责管控模型与执行环境之间的每一次交互，模型既不能执行操作，也不能宣告前置条件成立。前置条件检查的存在是由于 候选序列验证 所涉及的认知鸿沟，此处指模型对环境的参数化假设与真实状态 \(\mathcal{S}\) 之间的差异。
模型经常基于过时或理想化的认知生成动作。例如，在软件维护任务中，智能体可能假定标准发行版路径存在，并据此合成链接共享库的动作。如果主机环境缺少所需的头文件，或使用非标准 ABI，未经运行时管控的顺序执行器就会继续执行后续编译命令，从而产生级联且难以解释的下游故障。
FAILED: lib/libtransport.so
/usr/bin/ld: cannot find -luring: No such file or directory
clang-16: error: linker command failed with exit code 1
ninja: build stopped: subcommand failed.在不受管理的执行循环中，这份链接器失败跟踪会被盲目追加到上下文窗口中，模型只能在非结构化的上下文中解读长达五十行的 C++ 模板回溯。在图介导的审议机制下，该失败会在节点 \(v_{\text{link}}\) 的边界处被捕获。运行时将实际观测 \(\mathbf{o}_{\text{link}}\) 与预期后置条件规约 \(\mathcal{O}_{\text{link}}^*\) 进行比对；该规约要求退出码为零，且文件系统中存在 libtransport.so。由于 \(\mathbf{o}_{\text{link}} \not\approx \mathcal{O}_{\text{link}}^*\)，谓词判定失败，从而启动 图 6 所示的计划修订过程。
如 图 6 所示，计划修订将失败恢复与全局重新生成解耦。在面板 A 中，当节点 \(v_2\) 遭遇环境失败时，运行时执行失效遍历，将可达的后代节点 \(v_3\) 和 \(v_4\) 标记为已失效，同时保留独立并发分支 \(v_5\)。在面板 B 中，运行时并不丢弃整个图，而是将已验证的祖先节点 \(v_0\) 和 \(v_1\) 连同 \(v_5\) 一起固定在内存托管区中。监督器仅提示生成器生成一个有界的替代桥接子图 \(\text{Bridge}(\mathcal{F}_{\text{verified}} \to \mathcal{C}_{\text{downstream}})\)，合成补偿步骤 \(v_2'\) 和 \(v_3'\)，以满足 \(v_4\) 的前置条件，从而在不重新执行已完成操作的情况下恢复有效状态。
一旦将节点 \(v_i\) 声明为 \(\text{Failed}\)，运行时就会立即执行级联失效处理：
\[\mathcal{V}_{\text{invalid}} = \text{Desc}(v_i) = \{v_k \in \mathcal{V} \mid v_i \rightsquigarrow v_k\}\]
运行时计算下游可达集合 \(\text{Desc}(v_i)\)，计算方式是对 \(\mathcal{E}\) 进行广度优先遍历，并立即将每个识别出的后代节点转换为 \(\text{Invalidated}\) 状态。这可以防止因果假设已不再成立的孤立分支继续执行。关键在于，任何节点 \(v_m \notin \text{Desc}(v_i)\)，只要属于 DAG 中的独立并发分支，就完全不受影响。其前置条件仍然有效，其执行可以不受阻碍地继续进行，而其经过验证的计算结果则保存在内存托管区中。
分层修订机制
一旦将失效范围限定在局部，审议引擎就必须调整计划。朴素的智能体实现会通过丢弃整个计划并请求模型完整重新生成来应对错误。这在计算资源使用上极不审慎：它会消耗过多的生成 token，增加端到端任务延迟，并带来重新执行非幂等操作的风险，而这些操作已经改变了物理环境。Saltzer 和 Kaashoek 的模块化错误遏制原则要求系统在能够解决故障的最低层级处理故障。因此，运行时实现了三级分层修订策略（图 7）。
图 7 中的决策框架将 Dijkstra 的结构化错误遏制落实到三个架构边界上。当节点遇到失败观测 \(\mathbf{o}_i \not\approx \mathcal{O}_i^*\) 时，运行时首先尝试第 1 级（局部修复）：如果外部后置条件接口仍可实现，运行时会提示生成器生成替代动作载荷 \(a_i'\)，而不使下游节点失效，也不增加上下文 token 数量。如果局部修复失败或后置条件无法满足，引擎则升级至第 2 级（子图重新合成）：运行时剪除失败分支 \(\text{Desc}(v_{\text{fail}})\)，将已验证的祖先状态固定在内存托管区中，并提示生成器合成局部替代桥接子图。只有当环境缺陷使根任务的某个前置条件不再成立时（例如缺少内核所需的硬件能力或凭据被撤销），运行时才会升级至第 3 级（全局升级处理），停止执行，并向人工操作人员输出可审计的诊断证明。
局部修复（节点级重试）
当节点 \(v_i\) 的故障可以在不改变其外部契约的情况下得到补救时，就会触发局部修复；也就是说，无须改变预期的后置条件配置 \(\mathcal{O}_i^*\)，该配置是其下游后继节点 \(\text{Desc}(v_i)\) 所要求的。图拓扑 \(\mathcal{E}\) 保持完全不变。运行时向模型提供一个范围严格限定的上下文，其中仅包含子目标 \(g_i\)、失败的动作 \(a_i\) 和即时错误观测 \(\mathbf{o}_i\)，提示模型生成修订后的动作载荷 \(a_i'\)。例如，纠正格式错误的 CLI 标志、替换为等效的工具路径，或调整超时参数。如果 \(a_i'\) 满足 \(\mathcal{O}_i^*\)，节点 \(v_i\) 就会转入 \(\text{Verified}\)，下游执行随即恢复，而计划图的结构不会受到任何扰动。
子图重新合成
当局部修复失败，或环境表明后置条件 \(\mathcal{O}_i^*\) 无法实现时（例如，宿主发行版中没有所需的第三方依赖），运行时会升级为子图剪枝。调度器从当前活动计划中移除失败节点 \(v_i\) 及其所有下游后继节点 \(\text{Desc}(v_i)\)。已验证的节点 \(\mathcal{V}_{\text{verified}}\) 及其累积的状态增量 \(\Delta\) 仍保留在内存托管区中。
随后，运行时请求模型合成一个替代子图 \(\mathcal{G}'_{\text{sub}} = (\mathcal{V}'_{\text{sub}}, \mathcal{E}'_{\text{sub}})\)。此次重新合成的提示并不要求生成完整的任务计划，而是将其表述为一个有界的图拼接问题：
\[\text{Bridge}(\mathcal{F}_{\text{verified}} \to \mathcal{C}_{\text{downstream}})\]
其中，\(\mathcal{F}_{\text{verified}}\) 是已验证前沿（已完成且其输出可用作输入的节点集合），\(\mathcal{C}_{\text{downstream}}\) 是尚未失效的下游节点组成的目标集合，这些节点的前置条件最终必须得到满足。模型输出替代节点后，运行时将 \(\mathcal{G}'_{\text{sub}}\) 拼接到 \(\mathcal{G}_{\text{plan}}\) 中，验证所得的组合图仍然无环，并从新引入的前沿恢复执行。
两者的 token 用量差异很大。以一个包含十二个节点的计划为例，每一步平均输出 150 个 token，并在第六个节点处失败。重新生成整个计划需要读取一个长度为 7,596 个 token 的提示，其中包含指令和 5 个已完成步骤的历史，并输出 1,800 个 token。替换三个受影响的节点则只需读取一个范围限定、长度为 1,200 个 token 的提示，并输出 450 个 token，输出 token 数为前者的四分之一，因此解码时间也约为前者的四分之一。这还避免了重新执行 5 个已完成步骤；当这些步骤已经改变环境时，这一项节省更为显著。在一条较长的轨迹中，计划的存续时间必须超越任何一次决策。智能体运行框架在轨迹记录中保留一个指向该计划的指针（智能体运行框架），而持久执行使该记录能够在崩溃后保留下来（持久执行）。
全局升级（根任务失效）
当环境故障使根任务本身的某个不变量不再成立时，例如遇到无法改变的硬件不兼容问题、缺少内核能力或访问凭据被撤销，分支级重新合成就无法成功。在这种情况下继续推理，会在无解的搜索空间中浪费 token。运行时停止图的执行，将根目标标记为在当前环境约束下无法实现，并上报给监督者或人工操作员，同时输出一份结构化诊断证明，其中包含已验证状态增量链和最终失效签名。
粗略估算 0.4: 子图重新合成相较于全局重新生成的计算与 token 节省
在 GQA 下，KV 缓存中存储的每个 token 占用：
\[M_{\text{token}} = 2 \times L \times n_{\text{kv}} \times d_{\text{head}} \times 2 \text{ bytes} = 2 \times 80 \times 8 \times 128 \times 2 = 327{,}680 \text{ bytes} \approx 320 \text{ KiB}\]
智能体正在执行一个包含 12 个节点的计划图。每个计划节点平均需要 150 个 token 来描述。初始系统提示、环境描述和工具定义共占用 \(N_{\text{base}} = 4{,}096\) 个 token。
智能体成功执行了节点 \(v_1\) 至 \(v_5\)。在这五个步骤中，工具调用参数和环境执行观测累计向上下文中添加了 \(N_{\text{exec}} = 3{,}500\) 个 token 的交互历史。在节点 \(v_6\)，由于共享库 ABI 不兼容，C++ 编译失败。
我们评估两种恢复策略的实际计算成本和延迟成本：
- 策略 A（全局重新生成）： 运行时丢弃当前计划，将全部交互历史和失败日志追加到上下文中，并提示模型从头重新生成完整的 12 节点计划。
- 策略 B（子图重新合成）： 运行时将节点 \(v_1\) 至 \(v_5\) 保留在内存托管区中，剪除失败分支 \(\{v_6, v_7, v_8\}\)，并提供一个范围受限的提示，其中仅包含基础系统指令（\(N_{\text{base}}\)）、由 \(v_5\) 产生的状态增量，以及具体的链接器错误。这个范围受限的提示总计包含 \(N_{\text{scoped}} = 1{,}200\) 个 token。模型生成一个包含 3 个节点的替代子图（\(3 \times 150 = 450\) 个 token），用于从源代码构建缺失的依赖项。
1. 推理 FLOP 分析： 回顾一下，处理提示 token（预填充阶段）每个 token 约需 \(2P\) FLOPs，而生成输出 token（解码阶段）每个 token 需要 \(2P\) FLOPs。
对于策略 A： \[\text{Prompt Length } N_{\text{prompt, A}} = N_{\text{base}} + N_{\text{exec}} = 4{,}096 + 3{,}500 = 7{,}596 \text{ tokens}\] \[\text{Prefill FLOPs} = 2 \times (70 \times 10^9) \times 7{,}596 = 1.063 \times 10^{15} \text{ FLOPs} = 1.063 \text{ PFLOPs}\] \[\text{Generation Length } N_{\text{gen, A}} = 12 \text{ nodes} \times 150 \text{ tokens/node} = 1{,}800 \text{ tokens}\] \[\text{Decode FLOPs} = 2 \times (70 \times 10^9) \times 1{,}800 = 2.52 \times 10^{14} \text{ FLOPs} = 0.252 \text{ PFLOPs}\] \[\text{Total Compute}_{\text{Policy A}} = 1.063 + 0.252 = 1.315 \text{ PFLOPs}\]
对于策略 B： \[\text{Prompt Length } N_{\text{prompt, B}} = 1{,}200 \text{ tokens}\] \[\text{Prefill FLOPs} = 2 \times (70 \times 10^9) \times 1{,}200 = 1.68 \times 10^{14} \text{ FLOPs} = 0.168 \text{ PFLOPs}\] \[\text{Generation Length } N_{\text{gen, B}} = 3 \text{ nodes} \times 150 \text{ tokens/node} = 450 \text{ tokens}\] \[\text{Decode FLOPs} = 2 \times (70 \times 10^9) \times 450 = 6.30 \times 10^{13} \text{ FLOPs} = 0.063 \text{ PFLOPs}\] \[\text{Total Compute}_{\text{Policy B}} = 0.168 + 0.063 = 0.231 \text{ PFLOPs}\]
\[\text{Compute Reduction} = \frac{1.315 - 0.231}{1.315} = \frac{1.084}{1.315} \approx 82.4\%\]
2. 关键路径生成延迟： 自回归解码严格受内存带宽限制，且必须顺序执行。假设推理服务引擎对这个 70B 模型实现了每秒 40 个 token 的自回归解码吞吐量： \[T_{\text{decode, Policy A}} = \frac{1{,}800 \text{ tokens}}{40 \text{ tokens/s}} = 45.0 \text{ seconds}\] \[T_{\text{decode, Policy B}} = \frac{450 \text{ tokens}}{40 \text{ tokens/s}} = 11.25 \text{ seconds}\]
子图重新合成使关键路径上的重新规划延迟获得了 \(4.0\times\) 的加速比，同时避免了重新执行或破坏步骤 \(v_1\) 至 \(v_5\) 所产生的、已经验证的状态增量的风险。
重新规划的阻尼不变量
尽管将计划视为可修订的状态是应对物理环境波动的必要条件，但不受约束的重新规划策略会引入一种严重的动态失效模式：重新规划抖动陷阱。在操作系统中，当机器在磁盘与 DRAM 之间搬运虚拟内存页所耗费的周期多于执行用户指令所耗费的周期时，就会发生分页抖动。在智能体运行时中，当系统用于修改计划图的计算量和时间多于执行推动物理状态变化的动作时，就会发生重新规划抖动（图 8）。
如 图 8 所示，不受管控的重规划会触发不稳定的活锁循环（左图）：非致命的诊断警告被错误地视为契约失效，从而引发反复的子图再生成。这些再生成不断变更计划，却未推进环境状态，导致抖动系数 \(\chi = \Delta_{\text{replan}} / \Delta_{\text{exec}}\) 远高于不稳定阈值（\(\chi > 2.0\)）。右图详细展示了系统层面的解决方案：一个拦截原始执行反馈的三阶段阻尼控制器。第 1 阶段将不破坏契约的警告过滤到信息缓冲区；第 2 阶段递减显式变更预算（\(R_{\text{budget}} \leftarrow R_{\text{budget}} - 1\)），并在预算耗尽时冻结图拓扑；第 3 阶段将被拒绝的动作记录在不可变的隔离台账中，以防止循环再生成已知会失败的命令。
重规划抖动通常由过于敏感的失效判定谓词诱发。现代工具环境会产生大量诊断噪声：编译器警告、弃用通知、动态库信息提示，以及标准探索性命令返回的非零返回码（例如，grep 在未找到匹配模式时返回退出码 1）。如果运行时将每一个非空的标准错误流都视为契约失效，智能体几乎会在每次动作后触发重新合成。模型不断重构下游子目标，改写任务表述并调整执行拓扑，却始终无法实现端到端任务目标。
为防止抖动，运行时强制执行三项结构性阻尼不变量：
观测过滤
必须以形式化方式将环境反馈划分为结构性契约违反和信息性警告。节点的后置条件配置 \(\mathcal{O}_i^*\) 绝不能依赖 stdout 或 stderr 流的原始文本等价性。相反，谓词应基于语义层面的真实状态来定义：退出码状态矩阵、文件系统属性检查（例如验证 inode 是否存在、文件大小是否满足阈值或密码学校验和是否匹配），或显式 JSON 模式验证。未匹配的警告标记应被路由至信息累积器，而非触发节点失效处理程序。
有界重规划预算
运行时为任一给定轨迹 \(\tau\) 中的结构性变更分配显式的补充预算。令 \(R_{\text{budget}}\) 表示任务允许进行的结构分支重新合成的最大次数。每次调用子图重新合成都递减该预算：
\[R_{\text{budget}} \leftarrow R_{\text{budget}} - 1\]
当 \(R_{\text{budget}} = 0\) 时，调度器锁定图拓扑。此后，节点 \(v_k\) 上发生的任何失败都只能通过局部修复来尝试解决。如果局部修复失败，系统立即触发全局升级处理，避免进入无限重规划循环。
定义：计划变更比率 \[\chi = \frac{|\mathcal{V}_{\text{mutated}}|}{|\mathcal{V}_{\text{initial}}|}\] 如果累计变更比率 \(\chi\) 超过架构阈值（通常为 \(\chi > 2.0\)），推演引擎便判定系统处于动态不稳定状态，并强制暂停评估。
步骤隔离机制
为防止循环重规划——即模型在连续步骤中无限交替选择两个互斥的子计划——运行时在轨迹状态中维护一个临时隔离台账，记录失败动作的签名。如果拟议的重新合成分支引入了节点 \(v_k'\)，且其动作签名与先前已被隔离的失败动作相匹配：
\[\text{Sig}(a_k') \in \mathcal{K}_{\text{quarantine}}\]
运行时便会在派发前拒绝该替换图，对模型的生成评分施加惩罚，并迫使推演引擎探索一个正交分支。
通过将计划形式化为可检查的、带类型的依赖图，运行时弥合了随机词元生成与确定性系统执行之间的鸿沟。前置条件保护物理环境，避免其受到失效因果假设的影响；分层修复机制保留验证成本高昂的状态；阻尼不变量则消除重规划抖动。
然而，即使是采用阻尼机制、以图为结构的规划器，也必须在物理现实中运行：每一次分支探索、每一个候选方案的生成，以及每一次前置条件评估，都会消耗内存带宽、浮点运算次数和时间。这一计算现实迫使我们面对核心架构问题：运行时应依据哪些形式化准则终止搜索、确定执行路径，或中止前景不佳的轨迹？
搜索停止准则
运行自回归生成器的无约束树搜索会迅速引发组合爆炸：在一条包含十个步骤的推理轨迹中，每一步扩展四个备选分支，就会生成超过一百万个叶节点状态（\(4^{10} \approx 1.05 \times 10^6\)）。在每次词元生成都需要通过高带宽内存（HBM）总线进行顺序内存传输的推理运行时中，不加限制的分支扩展会耗尽服务器的词元配额，并在几秒内违反交互式服务的服务级别协议——此时距离发现一条可验证为正确的轨迹还很遥远。反之，过早终止会停止沿未经验证的路径继续探索，使智能体只能依赖缺乏依据的启发式方法或不完整的解决方案。
搜索拓扑无法与其资源核算和停止准则分离：测试时推演是一个约束优化问题，智能体运行时必须动态平衡词元预算、实际经过时间的延迟、验证成本和执行风险。如果缺乏管理，搜索要么因计算资源匮乏而陷入停滞，要么退化为对低价值分支的过度推演。
搜索拓扑
测试时推演的架构由其状态空间探索拓扑决定。当智能体不再局限于单次自回归解码时，宿主运行时必须将候选轨迹组织为显式数据结构，以控制备选方案的提出、评估和剪枝方式。三种不同的拓扑主导了实际系统：扁平并行采样（Best-of-\(N\)）、经过剪枝的迭代扩展（束搜索），以及由探索与利用启发式方法引导的树搜索（蒙特卡洛树搜索）；此外，还出现了思维图等新兴的有向无环图（DAG）聚合结构（图 9）。
图 9 中展示的四种拓扑揭示了剪枝粒度、硬件效率和内存占用之间的显著权衡。在 Best-of-\(N\)（左上）中，生成过程以 \(N\) 条相互独立且未经剪枝的轨迹采样执行；虽然这种结构可以高效映射到批处理的 GPU 张量核心，但早期步骤引入任何错误后，解码仍会持续到序列完成，浪费的生成 FLOPs 最高可达 87%。在束搜索（右上）中，步骤边界处的同步剪枝仅保留排名前 \(B\) 的候选，将 KV 缓存内存占用限制在 \(O(B \cdot L)\)，代价是在验证器执行期间造成流水线停顿。蒙特卡洛树搜索（左下）使用置信上界（PUCT）构建非对称搜索树，将计算引导至有希望的推理前沿，同时反向传播经验性终局奖励。最后，思维图（右下）将树结构扩展为任意有向无环图，支持通过变换节点对不同分支中的思维进行组合、提炼和改进。
搜索拓扑之间的根本权衡在于剪枝发生的位置：Best-of-\(N\) 将所有剪枝推迟到终止词元，以冗余词元生成为代价最大化批处理并行度；束搜索在步骤边界同步剪枝；MCTS 则根据反向传播的价值不确定性自适应地分配计算资源。
扁平采样通常称为 Best-of-\(N\)，是最简单、并行度最高的搜索拓扑。给定任务提示 \(\mathbf{x}\)，生成器并行采样 \(N\) 条相互独立的完整轨迹 \(\tau^{(1)}, \tau^{(2)}, \dots, \tau^{(N)} \sim P_{\Theta}(\tau \mid \mathbf{x})\)，其中每条轨迹最多包含 \(L\) 个词元。当所有序列都到达终止词元或长度上限后，外部选择器或验证器对每个已完成的候选进行评分：
\[\tau^* = \arg\max_{i \in \{1, \dots, N\}} V\left(\tau^{(i)}\right)\]
Best-of-\(N\) 与 GPU 硬件执行方式高度契合。由于所有 \(N\) 条序列在统计上相互独立且同时生成，模型服务引擎会将它们批量整合为一个连续的推理请求。通过将模型权重传输成本分摊到 \(N\) 条活跃生成流上，这种方式能够最大化解码阶段的算术强度。
然而，Best-of-\(N\) 在算法层面存在严重的效率问题：它完全不进行步骤级剪枝。如果某条轨迹在词元 \(y_{17}\) 处犯下致命的逻辑错误或生成无效语法，生成器仍然无法感知这一失败，并继续解码直至词元 \(y_{1024}\)。其余 1,007 个词元所消耗的计算资源完全被浪费了。
束搜索通过将推理 组织为分阶段、逐步骤的扩展过程，缓解这种延迟和 token 浪费。运行时将生成过程划分为离散的推理步骤或子目标，而非生成完整的端到端轨迹，\(s_t \in \mathcal{S}\)。在步骤 \(t\)，生成器将当前保留的每条路径扩展为 \(M\) 个候选后继步骤，从而产生 \(B \times M\) 个候选延续，其中 \(B\) 为束宽。
步骤级验证器（例如过程奖励模型，简称 PRM）为每个候选延续评分，运行时仅保留累计得分最高的前 \(B\) 个候选，并立即剪除其余 \((M - 1)B\) 个分支。通过尽早舍弃死路，束搜索避免了分支数量的指数级爆炸。
然而，束搜索引入了两项不同的系统层面问题：第一，它在每个步骤边界同步执行，迫使服务引擎暂停生成，等待步骤验证器完成对该批次的评分；第二，它容易发生不可逆的搜索错误。如果过程验证器错误地为一条最终本可得到正确解的路径赋予低分，该路径就会被永久舍弃。搜索拓扑比较 对比了束搜索与树搜索在结构上的这些权衡。
| 维度 | 平铺采样（择优选取，Best-of-\(N\)） | 束搜索（保留前 \(B\) 个） | 蒙特卡洛树搜索（MCTS） |
|---|---|---|---|
| 分支拓扑 | 深度优先的独立路径 | 分层广度优先的搜索束 | 非对称有向树 |
| 硬件并发度 | 最大（完全批量化解码） | 中等（同步步进生成） | 动态（不规则的分支任务） |
| 剪枝粒度 | 仅在终止时（\(t = L\)） | 同步步骤边界（\(t = \Delta_i\)） | 异步节点选择 |
| 验证器敏感性 | 高度依赖结果验证器 | 易受短视的步骤评分影响 | 通过反向传播的价值实现容错 |
| 搜索状态结构 | 由 \(N\) 个字符串缓冲区组成的平铺数组 | 包含 \(B\) 个活跃序列的优先队列 | 带有访问计数 \((N, Q)\) 的节点图 |
为调和早期剪枝与不可逆决策之间的矛盾，蒙特卡洛树搜索（MCTS）在推理状态之上构建显式的非对称搜索图，推广了由 Yao 等 (2023年) 形式化的思维树框架。在智能体 MCTS 配置中，节点表示部分轨迹或环境状态 \(s \in \mathcal{S}\)，有向边表示推理步骤、工具调用或动作 \(a \in \mathcal{A}\)。MCTS 不会均匀扩展节点，也不会严格依据即时步骤得分剪枝，而是通过四个持续进行的阶段平衡探索与利用：
选择： 从根状态 \(s_0\) 开始，运行时通过选择使适用于神经生成的置信上界变体（例如应用于树的预测器置信上界，简称 PUCT）最大化的子节点，遍历现有树： \[a^* = \arg\max_a \left[ Q(s, a) + c_{\text{puct}} \cdot P_{\Theta}(a \mid s) \frac{\sqrt{\sum_{a'} N(s, a')}}{1 + N(s, a)} \right]\] 其中，\(Q(s, a)\) 是经过边 \((s, a)\) 的轨迹的经验平均奖励，\(N(s, a)\) 是访问计数，\(P_{\Theta}(a \mid s)\) 是生成器为动作 \(a\) 赋予的先验概率。
扩展： 当到达一个访问次数超过阈值的叶节点时，运行时查询生成器，生成 \(K_{\text{ext}}\) 个候选延续，并在树中实例化新的子节点。
模拟 / 评估： 运行时通过执行一次完整的轨迹采样，或使用神经价值网络或自动化测试框架直接评估状态，来估计新扩展节点的价值。
反向传播： 评估得分 \(V \in [0, 1]\) 沿祖先轨迹从叶节点向后传播至 \(s_0\)，更新访问计数 \(N(s, a) \leftarrow N(s, a) + 1\) 和持续更新的价值估计 \(Q(s, a) \leftarrow Q(s, a) + \frac{V - Q(s, a)}{N(s, a)}\)。
MCTS 提供渐近收敛保证，并能从局部具有误导性的中间评分中恢复。然而，其执行特征并不规则：分支深度动态变化，批大小在不同选择周期之间波动，节点扩展需要持续更新树的元数据。
统一资源核算模型
每次分支扩展、候选生成和断言检查都会消耗物理资源。为防止审慎推理 退化为不受约束的计算消耗，智能体运行时必须维护一份显式账本，记录所有搜索阶段的累计成本。
总审慎推理 开销 \(C_{\text{total}}\) 由三个相加的分量构成：
\[C_{\text{total}} = C_{\text{gen}} + C_{\text{verif}} + C_{\text{tool}}\]
其中，\(C_{\text{gen}}\) 表示自回归生成成本，\(C_{\text{verif}}\) 衡量验证开销，\(C_{\text{tool}}\) 表示环境执行成本。
生成成本 \(C_{\text{gen}}\) 随所有已探索分支上生成的词元总数而变化。其延迟受 加速器服务延迟 的解码下限约束，对于具有 \(|\Theta|\) 个活跃参数的模型，其计算成本以浮点运算次数量化：
\[C_{\text{gen}} = 2 \cdot |\Theta| \cdot \sum_{b \in \mathcal{B}} K_b \quad \text{[FLOPs]}\]
其中，\(\mathcal{B}\) 表示搜索树中所有已扩展分支的集合，\(K_b\) 是在分支 \(b\) 上生成的序列长度。
验证成本 \(C_{\text{verif}}\) 在很大程度上取决于验证器的性质。采用神经奖励模型（例如结果验证器（ORM）或过程验证器（PRM））时，\(C_{\text{verif}}\) 的形式与生成成本公式相同：
\[C_{\text{verif}}^{\text{neural}} = 2 \cdot |\Theta_{\text{verif}}| \cdot \sum_{j \in \mathcal{V}_{\text{eval}}} K_j \quad \text{[FLOPs]}\]
其中，\(\mathcal{V}_{\text{eval}}\) 是评估调用的集合，\(|\Theta_{\text{verif}}|\) 是验证器模型的参数数量。相反，确定性验证器（例如编译器、测试套件和代码检查工具）消耗的是主机 CPU 周期、容器配置延迟和沙箱隔离开销，而非 GPU 浮点运算次数：
\[C_{\text{verif}}^{\text{det}} = \sum_{j \in \mathcal{V}_{\text{eval}}} \left( t_{\text{sandbox}} + t_{\text{exec}}^{(j)} \right) \quad \text{[seconds]}\]
工具执行成本 \(C_{\text{tool}}\) 涵盖探索分支与外部环境交互时产生的延迟、网络带宽消耗和第三方 API 开销。与纯生成不同，工具执行会引入非确定性的实际耗时：调用外部数据库查询或静态分析工具的智能体分支可能停滞数百毫秒，同时仍在加速器内存中保留待恢复的状态。
粗略估算 0.5: Best-of-16 与采用步骤验证器的束搜索的比较
方案 A（best-of-16）：生成十六个完整候选，每个候选包含 512 个词元，作为一个批次解码。输出共 8,192 个词元，成本约为 $0.123。解码耗时约 10.8 秒。全部 16 个候选分 2 轮测试，每轮 8 个，额外耗时 1 秒，因此延迟约为 11.8 秒，搜索共使用 16 次沙箱运行。
方案 B（束搜索，\(B = 4\)，\(M = 3\)）：第 1 步将根节点扩展为 3 个扩展分支，第 2 步将这些分支扩展为 9 个，第 3 步和第 4 步各将保留的 4 个前缀扩展为 12 个，共生成 36 个步骤片段。输出共 4,608 个词元，成本约为 $0.069. The PRM reads the same 4,608 tokens for about $0.002。解码需要依次执行四个步骤，每步 128 个词元，耗时约 10.8 秒；评分额外耗时 0.06 秒；对保留下来的 4 个候选进行一轮测试，额外耗时 0.5 秒。延迟约为 11.4 秒，使用 4 次沙箱运行。
计算：束搜索生成的输出词元约减少 44%，沙箱运行次数降为四分之一，而延迟相近。
系统层面的洞见：在此场景中，提前对步骤评分能够抵偿自身开销，因为 PRM 规模较小，且评分对象是较短的步骤。PRM 仅决定保留哪些前缀；保留下来的四个候选仍由测试决定接受或拒绝。当步骤验证器与生成器规模相当，并且需要重新读取较长的前缀时，其处理的词元数可能超过生成器，此时成本收益关系就会逆转。
多准则停止不变条件
没有终止边界的搜索引擎会消耗无限量的词元，或在递归工具调用中无休止地循环。宿主运行时必须强制执行明确的多准则停止规则，以规定何时确定采用某个候选、何时剪除某个子树，以及何时彻底中止搜索。
这些停止边界沿三个不同的运行维度发挥作用：硬性资源上限、阈值满足和边际效用停止（图 10）。
如 图 10 的面板 (a) 所形式化描述的，运行时在由验证器评分 \(V(\tau)\) 和累计计算开销 \(K\) 定义的多维状态空间中统筹停止决策；面板 (b) 给出了这些边界的评估优先顺序。当某个执行分支通过编译器检查或确定性测试套件，到达位于 \(V(\tau)=1.0\) 的认证超平面时，满意化边界会触发即时机会式提交，并中止所有推测执行的兄弟分支。如果没有分支满足认证阈值，探索就会继续，直到边际效用曲线趋于平坦（\(\Delta P / \Delta C < \epsilon_{\text{stop}}\)），或累计计算量与位于 \(K_{\max}\) 的垂直硬性上限相交（或达到墙钟时间截止期限 \(T_{\max}\)）。运行时执行严格的评估优先顺序：硬性系统不变量（优先级 1）严格优先于启发式满足条件（优先级 2）和边际停止准则（优先级 3）。
审慎推理在单次决策内部消耗跨度，而硬性上限约束这种消耗。
硬性资源上限在模型之下，以机械方式封闭搜索边界，符合不变量闭合原则（不变闭包原则）的要求。它们限制单次决策可消耗的跨度，并防止生成器退化、工具输出退化或循环推理路径引发失控循环。运行时监控三个主要上限：
- Token 配额（\(K_{\max}\)）： 所有活跃分支生成的 token 累计数量的最大值。一旦 \(\sum_{b} K_b \ge K_{\max}\)，搜索循环便终止，选择器从托管区中已完成的候选项里选出评分最高者。因配额限制而被截断的分支返回
TRUNCATED，并继续保持隔离状态（原则 隔离不变量）。 - 墙钟时间截止期限（\(T_{\max}\)）： 由面向用户的延迟预算或上游服务超时所规定的绝对耗时阈值。运行时通过截止期限计时器强制执行该限制，以中断活跃的模型调用。
- 最大分支深度（\(D_{\max}\)）： 以离散推理步骤或工具操作数量衡量的探索轨迹最大允许长度。\(D_{\max}\) 防止模型陷入无关探索的无限链条。
阈值满足（也称为满意化）实现机会式提前退出。当运行时使用确定性验证器评估候选项时，例如自动化编译器、密码学测试套件或完整的单元测试检查，二元成功信号（\(V(\tau) = 1\)）便为任务完成提供了实证确认。如果任一分支产生经认证的候选项，继续搜索所带来的额外效用就为零。运行时立即中止所有竞争分支，释放其待处理请求占用的资源，并提交成功的轨迹。
然而，当验证依赖随机或连续的神经网络评分时（例如输出 \(v \in [0, 1]\) 的奖励模型），高分并不能保证正确性；它仅表明统计上的可信程度。在这类情形下，基于启发式阈值提前停止，可能导致过早采纳利用奖励机制漏洞的对抗性结果，正如 节 4 所论证的。
第三种停止范式——边际效用停止——评估生成额外候选项所带来的预期准确率提升，是否足以抵偿新增计算开销。Snell 等 (2024年) 表明，测试时搜索呈现对数扩展行为：发现正确解的概率起初随计算量增长，但随着搜索空间趋于饱和，或生成器遭遇内在错误极限，这一概率会迅速进入平台期，形成 图 11 所示的边际收益曲线。
图 11 中的双面板分析量化了无引导的搜索广度为何会面临严重的收益递减。面板 A 描绘了实测任务成功率随推理 FLOPs 变化的轨迹：初期计算投入带来准确率的快速提升，但随着生成器耗尽其高置信度知识区域，边际改善曲线逐渐趋于平坦，由此确定 \(C^*\) 为最优停止切点，此时 \(\Delta P / \Delta C = \epsilon_{\text{stop}}\)。面板 B 说明了主动验证如何改变搜索树的几何结构：分支因子为 \(b=5.0\) 的盲目深度优先搜索展开出 125 个叶节点，跨越三个深度步，而中间阶段的验证器门控会剪除 68% 的无效分支，将有效分支因子降至 \(b_{\text{eff}} \approx 1.6\)，并将加速器带宽留给有效的候选补全结果。
令 \(P_m(\text{success})\) 表示消耗计算量 \(C_m\)（以词元或 FLOPs 衡量）、历经 \(m\) 次搜索迭代后任务成功概率的估计值。继续搜索的边际效用定义为：
\[\mathcal{U}_{\text{marg}}(m) = \frac{P_m(\text{success}) - P_{m-1}(\text{success})}{C_m - C_{m-1}} \approx \frac{\Delta P}{\Delta C}\]
运行时系统通过迭代滑动窗口监测 \(\mathcal{U}_{\text{marg}}(m)\)。当边际收益低于配置的效率阈值 \(\epsilon_{\text{stop}}\) 时：
\[\frac{\Delta P}{\Delta C} < \epsilon_{\text{stop}}\]
搜索停止。在此条件下继续消耗计算量会产生递减收益，使最优策略从更深的局部搜索转向输出当前最佳候选 \(\tau^*\)，或升级为另一种方案。
边际效用停止机制在实际实现中需要维护候选迭代过程中成功概率的滚动估计：
def should_terminate_search(history: list[float], cost_history: list[int],
k_max: int, eps: float = 1e-5) -> bool:
"""Evaluate marginal utility stopping under token and efficiency budgets."""
if cost_history[-1] >= k_max or len(history) < 2:
return cost_history[-1] >= k_max
# Compute marginal empirical gain per thousand tokens over window
delta_p = max(0.0, history[-1] - history[-2])
delta_c = max(1, cost_history[-1] - cost_history[-2])
marginal_utility = (delta_p / delta_c) * 1000.0
return marginal_utility < eps除了 token 和延迟预算，自主智能体还面临动作风险预算。当智能体与外部环境交互时，各类动作的可逆程度各不相同。只读查询（例如 git status、ls、文件检查）处于权限级别 \(A_0\)，这是按 H·S·A 暴露面 中的术语划分的。它们不会修改任何内容，因此探索分支可以执行这些查询，而无须回滚。不过，它们并非毫无风险，因为读取的内容可能通过后续输出泄露，所以运行时仍需控制这些结果的流向。
相反，处于 \(A_3\) 的不可逆修改（例如执行数据库迁移、删除远程分支或发送外部电子邮件）可能造成范围无上限的影响。如果不受信任的探索分支在未隔离的环境中执行不可逆动作，那么搜索在发现后续失败时，就无法简单地“回溯”。
为了保护环境，运行时必须强制探索性搜索仅在可由运行时丢弃的隔离暂存空间或沙箱内进行，将其动作限制在 \(A_1\)（其形式化定义见 智能体沙箱）。对实际环境的变更提交必须推迟到搜索算法终止、停止条件得到满足，并且某条候选轨迹被正式选定并通过认证之后。
Checkpoint 0.2: 评估搜索拓扑与停止不变量
在资源等价条件下对审思策略进行基准测试之前，请检查你对有界搜索机制的理解：
审思策略评估
评估推理时审思策略存在一个不易察觉的系统测量陷阱：在无约束基准测试中表现更优的架构，一旦受到严格的 token 上限、严格的尾部延迟服务级别目标或可能出错的验证器约束，其表现往往会崩溃。在开环研究文献中，常见的展示方式是让蒙特卡洛树搜索或迭代自我纠正循环取得高于单次贪心基线的基准测试绝对准确率。然而，这类比较经常将计算资源量不同的方法放在一起比较。探索三十二条候选分支的树搜索消耗三十二倍的前向计算 FLOPs，需要数 GB 的临时 KV 缓存内存，并使关键路径的实际耗时成倍增加。如果将相同的计算预算用于容量更大的基础模型，或分配给并行独立采样并采用多数投票，复杂搜索策略看似具有的优势往往就会消失。
绝不能在计算资源不受约束的条件下评估审思策略。每个额外的 token、扩展分支或沙箱执行都会消耗具体的物理资源，其对获接受结果准确率的边际贡献必须足以证明这些消耗的合理性。
只有在资源预算严格匹配、环境权限相同且验证准确率符合实际情况的条件下，审思策略相对于更简单的基线形成帕累托支配，其架构复杂性才有存在的理由。 引入树扩展队列、学习得到的过程验证器或多轮反思循环，并不意味着算法自动得到升级；这是一项架构承诺，会带来具体的内存带宽开销、调度复杂性和尾部延迟放大。为了判断智能体运行时是否应采用审思，工程师必须在多维性能指标上对候选策略开展受控且资源等价的评估，精确刻画审思取得成功时的帕累托前沿，并识别其引发灾难性失败的运行条件。
资源等价条件下的受控系统评估
严格的系统评估要求搜索策略之外的所有混杂变量保持不变。在软件系统工程中，比较两种排序例程，需要在相同的 CPU 架构上执行它们，并使用相同的缓存层次结构、内存配置和编译器优化选项。在智能体机器学习运行时中，实现同等程度的实验控制需要固定三个不同的架构边界：
- 模型参数与精度不变性（\(\Theta\)）： 在所有受测策略中，底层基础模型的权重、量化格式（例如 FP8、BF16）和服务引擎配置必须保持一致。将 80 亿参数模型上的迭代搜索策略与 700 亿参数模型上的单次提示进行比较，衡量的是参数规模扩展效果，而非搜索效能。
- 环境与沙箱接口不变性（权限相同）： 每种候选策略都必须在完全相同的非特权沙箱边界内运行。如果某种环境反馈策略获准访问编译器工具链或代码静态检查工具套件，那么基线策略也必须在相同的工具调用接口和权限范围内接受评估。
- 总计算上限（\(\mathcal{C}_{\max}\)）： 所有策略都必须在相同的最大预算约束下接受评估。该约束可参数化为 token 生成总量上限（\(T_{\text{total}} = T_{\text{prompt}} + T_{\text{completion}}\)）、浮点运算总量上限（\(C_{\text{FLOP}}\)），或严格的实际耗时超时阈值（\(T_{\text{wall}} \le T_{\max}\)）。
Snell 等 (2024年) 表明，只要计算资源与明确的验证机制相匹配，优化测试时计算分配就能带来与参数规模提升数个数量级相当的准确率收益。
严格匹配计算资源的必要性由 Snell 等 (2024年) 通过实证研究予以确立，该研究证明最优的测试时计算分配策略从根本上取决于任务。在计算支出固定为 \(\mathcal{C}\) 的条件下，智能体运行时面临明确的资源分配权衡：它可以将 token 用于深度（生成更长、更详尽的自回归推理轨迹）、广度（采样 \(N\) 条独立轨迹并从中选择），或反馈（在外部执行沙箱中迭代运行候选代码，并根据错误日志进行改进）。简单的基准测试将准确率报告为算法复杂度的无约束函数，从而掩盖了这一权衡。
# Empirical check: verify strict token budget conformance across strategies
def compute_efficiency(tokens_spent: int, success: bool, budget: int) -> float:
if tokens_spent > budget:
return 0.0 # Disqualified: budget overrun violates systems equivalence
return 1.0 if success else 0.0当策略在严格的上限 \(\mathcal{C}_{\max}\) 下接受评估时，系统层面的优先级会发生变化。包含多个提示扩展阶段和启发式分支剪枝器的复杂推理 图，往往会在对话编排和上下文窗口内的重复提示上耗尽词元预算，导致用于核心问题综合求解的预算不足。更简单的策略——例如结合自动语法验证器的并行 Best-of-\(N\)——通常能够获得现有条件下可实现的性能增益，同时省去树搜索中复杂的状态跟踪。
多维系统指标
仅依据二元任务成功率（准确率）评估推理 运行时，是一种架构反模式。在生产环境中，即使智能体将准确率提高了五个百分点，只要它使 \(p99\) 尾延迟增至三倍或增加了静默数据损坏，就不可接受。全面的系统评估需要同时跟踪四个正交指标。
相同预算下的 Pass@1 与 pass@\(k\)
在学术代码生成研究中，指标 \(\text{Pass}@k\) 通常定义为：在 \(k\) 个生成样本中，至少一个候选解通过给定评估套件的概率：
\[\text{Pass}@k = \mathbb{E}_{\text{tasks}} \left[ 1 - \frac{\binom{N - c}{k}}{\binom{N}{k}} \right]\]
其中，生成的样本数为 \(N \ge k\)，\(c\) 表示正确样本的数量。尽管 \(\text{Pass}@k\) 为模型随机分布的生成潜力提供了理论界限，但作为系统指标，它具有误导性。\(\text{Pass}@k\) 假设存在一个全知且零成本的预言机，能够轻松地从集合 \(k\) 中选出唯一可用的候选解。
在实际的系统实现中，这样的预言机并不存在。宿主监督器必须使用自动验证器选出一个候选解并将其提交到持久存储，或者直接输出排名最高的候选解。一组未经验证的 \(k\) 个候选解不具备任何实际运行价值。因此，系统评估必须报告预算约束下的采纳准确率：搜索策略在预算 \(\mathcal{C} \le B\) 下选定并输出的候选解满足所有不变量的经验概率。
每次验证成功的有效成本
原始词元消耗量与系统价值并不呈线性关系。某种搜索策略将任务成功率从 50% 提高到 60%，却使平均词元消耗量从 1,000 个增加到 8,000 个，这意味着架构的成本效率下降。我们通过每次验证成功的有效成本（\(C_{\text{eff}}\)）来量化这一权衡：
\[C_{\text{eff}} = \frac{\mathbb{E}[C]}{P(\text{verified success})}\]
其中，\(\mathbb{E}[C]\) 表示每个问题实例的预期资源成本，以生成词元总数或浮点运算次数衡量；\(P(\text{verified success})\) 则是通过宿主监督器验证框架的任务比例。如果基线单候选策略达到 45% 的准确率，平均成本为 512 个词元，那么其 \(C_{\text{eff}}\) 为每次成功结果消耗 \(1{,}138\) 个词元。如果迭代改进循环达到 68% 的准确率，但在多轮审查迭代中平均消耗 \(4{,}096\) 个词元，那么其 \(C_{\text{eff}}\) 将增至每次成功结果消耗 \(6{,}024\) 个词元——产出单个经过验证的交付成果所需的资源成本增至五倍以上。
墙钟时间延迟分布
不同推理 拓扑在关键路径上分配计算负载的方式存在根本差异：
深度主导的拓扑（顺序推理）： 顺序思维链生成、迭代评析和单分支回溯使执行串行化。墙钟时间延迟受到各次顺序前向传播耗时之和的严格约束：
\[T_{\text{wall}} = \sum_{i=1}^D t_{\text{decode}}(y_i)\]
由于解码受内存带宽限制（加速器服务延迟），向单个实例投入并行计算资源无法缩短关键路径。这会造成较高的延迟中位数（\(p50\)）；如果模型进入大规模生成循环，执行延迟还会出现剧烈波动。
广度主导的拓扑（并行采样）： 并发生成 \(N\) 个候选解，使宿主监督器能够在参与张量并行的各个 GPU 进程之间，对提示预填充和词元解码进行批处理。只要总批量大小未超过硬件饱和阈值，也未耗尽高带宽内存（HBM），关键路径的墙钟时间延迟就近似按 \(\mathcal{O}(1)\) 扩展，相对于 \(N\) 而言。然而，广度策略会给键值（KV）缓存带来巨大压力：
\[M_{\text{KV, total}} = N \cdot 2 \cdot L \cdot d_{\text{model}} \cdot S\]
其中，\(L\) 为层数，\(S\) 为上下文长度。如果 \(M_{\text{KV, total}}\) 超出 GPU 的物理显存容量，服务引擎就必须抢占序列或将 KV 块换出至主机 DRAM，导致尾部延迟（\(p99\)）急剧上升。
- 反馈密集型拓扑（环境探查）： 将 token 生成与容器化沙箱、单元测试执行或编译运行交错进行，会引入非确定性的主机系统开销。此时，总延迟主要由进程派生时间、编译开销和文件系统 I/O 决定。
错误接受率
当候选方案选择依赖自动验证器、启发式代码检查工具或学习得到的过程奖励模型时，搜索优化受古德哈特定律支配：当一个度量成为目标时，它就不再是一个好的度量。 随着候选方案探索的广度 \(N\) 扩大，生成器发现对抗性边界案例的可能性单调增长：这类候选方案在技术上满足验证器的语法检查，却完全违反底层任务的不变量。
我们将错误接受率（FAR）定义为运行时的验证框架将失败或损坏的提案标记为有效的概率：
\[\text{FAR} = P(\text{accept} \mid \text{incorrect})\]
由于模型不具有任何环境隐式权限，候选方案只有在运行时接受后才能改变环境，因此错误接受会使静默失败漏过验证。发出明确失败信号的智能体允许主机监督程序停止执行、触发补偿操作，或将任务转交人工审查。相反，错误接受率高的智能体会将损坏的状态变更提交到持久化环境中，污染下游系统组件。
Example 0.1: 计算预算相同条件下的审慎推理 权衡
考虑一个处理传入缺陷报告的自主代码修复服务。服务引擎运行在 NVIDIA H100 GPU 上（3,350 TFLOPS FP8，3.35 TB/s HBM3）。运行时强制执行 \(T_{\max} = 10.0\text{ s}\) 的 SLA 截止期限，并在总计算量上限同为 \(\mathcal{C}_{\max} \le 4{,}096\text{ tokens}\) 的条件下评估三种不同策略：
- 贪心单次生成： 生成一个包含 512 个 token 的解决方案。
- 并行八选优（广度）： 将 8 个并发候选生成任务组成一个批次，每个候选生成 512 个 token（\(T_{\text{total}} = 4{,}096\text{ tokens}\)）。候选方案由测试运行器验证器评估；选择第一个通过全部测试的候选方案。
- 顺序细化（深度）： 最多执行 4 轮迭代式批评—生成循环，每轮平均消耗 800 个 token（\(T_{\text{total}} \le 3{,}200\text{ tokens}\)）。
实测执行日志得出的性能指标汇总于 表 5：
| 策略 | \(P(\text{success})\) | 平均 token 数 | \(C_{\text{eff}}\)（token 数/成功次数） | 延迟 \(p50\) | 延迟 \(p99\) | FAR |
|---|---|---|---|---|---|---|
| 贪心单次生成 | 0.42 | 512 | \(1{,}219\) | 1.1 s | 1.4 s | 0.01 |
| 并行八选优 | 0.74 | \(4{,}096\) | \(5{,}535\) | 1.8 s | 9.4 s | 0.09 |
| 顺序细化 | 0.61 | \(2{,}650\) | \(4{,}344\) | 6.2 s | 14.8 s | 0.04 |
分析：
- 准确率与成本： 并行八选优的原始准确率最高（\(0.74\)），但其 \(C_{\text{eff}}\) 比贪心策略高 \(4.5\times\)。每次经验证的成功都需要消耗 \(5{,}535\) 个 token 对应的 GPU 容量。
- 尾部延迟 SLA： 由于采用并发批量解码，并行八选优将 \(p50\) 延迟维持在可接受的 1.8 s，但由于服务引擎上的 KV 缓存显存争用，其 \(p99\) 延迟恶化至 9.4 s，危险地接近 10.0 s 的 SLA。顺序细化在 \(p99\)（14.8 s）处完全违反 SLA，因为串行自回归解码过程会以确定性的方式逐次累积耗时。
- 静默失败风险： 并行八选优的错误接受率高达令人担忧的 9%。通过生成 8 个多样化候选方案，模型经常构造出能够通过不完整测试断言的隐蔽漏洞利用方案（例如，为特定测试用例硬编码预期返回值）。
粗略估算 0.6: 同一修复工作负载上的三种策略
方案 A（单次尝试）：\(P(\text{accepted}) = 0.40\)。开销为 1,000 个 token，因此 \(C_{\text{eff}} =\) 2,500 个 token，约合 $0.037。延迟为一次尝试加一次测试，约 31 秒。
方案 B（8 次采样择优，以封闭测试作为选择器）：八个候选方案彼此相关，其效果相当于三次独立尝试，因此 \(P(\text{accepted}) = 1 - 0.6^3 \approx\) 0.78。由于选择器就是封闭测试套件本身，这等于 pass@8 的上限。开销为 8,000 个 token，因此 \(C_{\text{eff}} \approx\) 10,200 个 token，约合 $0.15。候选方案与测试并行运行，因此延迟保持在 31 秒左右，共运行 8 次沙箱。
方案 C（反馈，最多三轮）：失败后，测试报告将每次修订的通过概率提高至 \(0.35\)。于是 \(P(\text{accepted}) = 1 - 0.6 \times 0.65 \times 0.65 \approx\) 0.75。期望轮数为 \(1 + 0.6 + 0.6 \times 0.65 =\) 1.99，因此期望开销为 1,990 个 token，以及 \(C_{\text{eff}} \approx\) 2,670 个 token，约合 $0.040。每轮约需 31 秒，因此期望延迟约为 62 秒，最坏情况下为 93 秒。
数学分析：方案 C 的成功率接近方案 B，而每个验收通过任务的成本约为方案 B 的四分之一，且每个验收通过任务的成本仅比单次尝试高约 7%。方案 C 在第三轮还会超过 75 秒的截止时限，而 39% 的任务会进入第三轮。
系统层面的洞见：没有一种策略能在所有维度上胜出。在 75 秒的截止时限下，方案 B 是唯一能达到约 0.78 成功率的方案；放宽截止时限后，反馈策略以四分之一的成本便能达到与其接近的成功率。原始准确率无法为这三种方案排序，因为它们消耗的预算不同；以截止时限内每个验收通过任务的成本衡量，才能将它们置于同一尺度上。
审慎推理帕累托前沿
将实测任务成功率与 token 消耗量及实际运行延迟绘制在一起，可以揭示审慎推理帕累托前沿——由最优运行点构成的集合；在这些点上，任何其他推理计算资源分配方式都无法在不消耗更多资源或不违反延迟限制的情况下获得更高的准确率（图 12）。
图 12 中可视化的实测权衡直接对应于 表 6 中建立的多策略基准。贪心单次生成基线锚定了左下方的起始点（\(1{,}163\) 个 token，\(44\%\) 的经验证成功率）。虽然将计算资源分配给顺序执行的 Self-Refine 可将成功率提高至 \(58\%\)，但由于错误前提固化，每次成功需要消耗 \(4{,}482\) 个 token。并行 Best-of-8 达到 \(71\%\) 的成功率，但消耗 \(5{,}769\) 个 token，同时存在 \(8\%\) 的错误接受率。缺乏外部依据、采用学习型 PRM 的 MCTS 达到 \(76\%\) 的成功率，但需要高达 \(8{,}684\) 个 token，并因验证器的古德哈特效应而呈现 \(11\%\) 的错误接受率。占据优势的运行前沿由带外部工具反馈的 ReAct 界定（\(4{,}939\) 个 token，\(83\%\) 的经验证成功率，\(3\%\) 的 FAR）：通过使用确定性的沙箱编译器和运行时断言探针，系统以低于纯神经搜索的成本实现了严格更高的准确率，证明以环境为依据是实现帕累托高效审慎推理的前提。
如前沿曲线所示，三个计算维度在这一权衡空间中各自占据不同的运行位置：
- 深度形态（顺序演绎链）： 最适合内部约束密度高、中间分支少的任务，例如数学证明或复杂算法合成。在这一形态中，中间推理 token 充当暂存存储器，稳定模型的自回归轨迹。然而，增加深度的边际收益会迅速衰减；超过临界上下文长度后，额外的推理 token 会诱发推理游移，使模型开始质疑已验证的事实，或遗失初始约束。
- 广度形态（独立候选方案探索）： 最适合解空间广阔、存在多条互不连通的求解路径，且候选方案验证的计算成本较低的情形，例如编译检查或确定性的模式验证器。广度采样能在高吞吐量推理引擎上最大限度地缩短关键路径延迟，代价是巨大的 token 总消耗量。
- 反馈形态（以环境为媒介的执行）： 最适合内部自我批评本质上缺乏外部依据的情形。基础模型在试图通过纯粹的自省验证自身输出时，会表现出严重的盲点。注入确定性的环境反馈，例如编译器错误消息、测试失败回溯或数据库运行时异常，可以将审慎推理过程锚定于实证真值，从而打破循环推理。
# Systems check: filter candidate strategies against the operational Pareto frontier
def is_pareto_efficient(candidates: list[tuple[float, float, float]]) -> list[bool]:
# candidates: list of (cost, latency, -accuracy)
efficient = [True] * len(candidates)
for i, c1 in enumerate(candidates):
for j, c2 in enumerate(candidates):
if i != j and all(x <= y for x, y in zip(c2, c1)) and any(x < y for x, y in zip(c2, c1)):
efficient[i] = False
break
return efficient失效形态
关键在于，深思并非在所有情况下都有益。在广泛的实际操作任务中，分配额外的测试时计算会产生负迁移：这是一种可观测现象，表现为搜索使性能低于单次生成基线。
负迁移主要通过两种失效机制发生：
- 过度深思陷阱：面对简单明确、置信度高的任务时，配置了强制反思或树搜索的深思运行时往往会制造虚假的复杂性。模型将简单要求视为含糊的边界情况，臆造假设性的极端条件，并将简洁、正确的解决方案改写为过度设计且存在缺陷的抽象。
- 错误前提固化：如果顺序推理链中的早期步骤引入了细微的语义错误，分配额外的推理深度会使模型为该错误寻找合理解释并强化它，而非纠正它。由于自回归生成会关注自身先前的上下文，臆造的前提会成为提示中不可更改的历史事实，持续使后续推导偏离正确解。
为严谨刻画这些权衡，深思策略的性能在相同的 token 上限（\(T_{\text{total}} \le 8{,}192\text{ tokens}\)）下对比了五种典型的深思拓扑，并报告了各批次实证试验的 95% 置信区间。
| 策略 | 主要维度 | 经验证的成功率（\(95\%\text{ CI}\)） | 有效成本 \(C_{\text{eff}}\)（token 数/成功次数） | 延迟 \(p50\)（秒） | 延迟 \(p99\)（秒） | 错误接受率 |
|---|---|---|---|---|---|---|
| 贪心单次生成 | 基线 | \(0.44 \pm 0.03\) | \(1{,}163\) | 1.2 | 1.5 | 0.01 |
| 8 次采样择优 | 广度 | \(0.71 \pm 0.03\) | \(5{,}769\) | 2.1 | 8.8 | 0.08 |
| 自我改进（深度 4） | 深度 | \(0.58 \pm 0.03\) | \(4{,}482\) | 5.4 | 13.2 | 0.04 |
| MCTS + 学习得到的 PRM | 树形混合 | \(0.76 \pm 0.02\) | \(8{,}684\) | 8.9 | 24.1 | 0.11 |
| ReAct + 工具反馈 | 反馈 | \(\mathbf{0.83 \pm 0.02}\) | \(4{,}939\) | 4.1 | 11.6 | 0.03 |
深思策略的性能中的置信区间采用 Wilson 得分区间计算（\(n=1{,}000\) 次试验）。请注意，尽管 MCTS 实现了较高的准确率，其 \(p99\) 延迟和错误接受率使其在生产环境中表现脆弱。
深思策略的性能所揭示的架构启示十分明确：缺乏外部依据的内部搜索（采用学习得到的神经 PRM 的 MCTS）会产生最高的有效成本，以及最大的错误接受漏检风险。相反，以外部环境反馈为依据的深思循环（ReAct + 工具反馈）实现了最高的经验证成功率，同时每次成功的有效成本低于纯广度采样，因为外部执行环境会在无效搜索分支消耗后续 token 之前将其严格剪除。
然而，对搜索拓扑、资源账本和实证帕累托前沿的形式化揭示了一个令人警醒的现实：即便在数学上最优雅的深思策略，也可能因根本性的架构误解而彻底失效。在生产环境中，工程师经常陷入对模型行为的普遍误解——将随机采样误认为独立推理，将看似合理的自我批评等同于严格验证，或假定测试时搜索能够弥补领域知识的缺失。揭穿这些架构谬误，是构建可靠深思系统的最后一个先决条件。
谬误与陷阱
扩展测试时深思会从根本上改变机器学习系统的失效模式。在单次生成调用中，失效是即时、显性的，且局限于单个 token 序列的边界内。在深思架构中，失效则变得动态，在推测性搜索树中不断累积，隐藏在代理奖励指标背后，并悄然耗尽加速器的内存带宽。当系统工程师从确定性分布式系统转向深思推理运行时时，他们往往沿用关于独立采样、单调收敛和线性成本核算的经典假设，而这些假设在不具备特权的自回归生成中并不成立。
将测试时深思视为不受约束的算法万能解法，并假定额外的 token、随机样本或代理评分能够单调地转化为经验证的执行结果，是现代智能体设计中的主要架构失效模式。构建可靠的智能体系统，需要揭示不具备特权的神经预测器在缺乏严格验证边界时所产生的物理瓶颈和统计错觉。以下四种谬误与陷阱从加速器内存系统与主机执行运行时之间的边界出发，剖析这些失效机制。
谬误： 更多推理 token 自动意味着更正确的决策。
习惯于数值优化算法或迭代求解器的软件工程师，常常认为延长自回归生成过程相当于执行一个收敛循环。在梯度下降或牛顿—拉夫逊近似等经典数值方法中，增加计算迭代次数会使误差残差 \(\|\mathbf{x}_k - \mathbf{x}^*\|\) 单调趋近于零。将这一假设应用于自回归推理链时，就意味着生成包含 \(K_{\text{ext}}\) 个推理词元的较长序列，能够让模型逐步完善其内部逻辑并消除错误。
这一类比与因果词元生成的物理和数学现实并不相符。自回归基础模型依据离散词表 \(\mathcal{V}\) 上的条件概率分布生成词元：
\[P(y_1, y_2, \dots, y_K \mid \mathbf{x}) = \prod_{t=1}^K P(y_t \mid \mathbf{x}, y_1, \dots, y_{t-1})\]
生成过程以开环方式运行，没有外部真实值作为依据。每个输出词元 \(y_t\) 的条件并非外部环境的物理状态，而是冻结的参数权重 \(\mathbf{\Theta}\) 和此前生成词元的累积历史 \([\mathbf{x}, y_1, \dots, y_{t-1}]\)。如果模型在序列早期的步骤 \(t_0\) 采样到一个错误词元，或认定了一个无效前提，例如将并发竞态条件误判为未处理的网络超时，那么所有后续词元 \(t > t_0\) 的概率分布都会发生显著偏移。模型并不具备能够将该前提标记为错误的内部预言机。相反，预训练损失最小化迫使网络生成在给定前文上下文条件下使序列联合似然最大化的词元。
因此，新增推理词元的优化目标变成了为最初的错误寻找合理解释、加以展开并进行辩护。模型会构建大篇幅且内部自洽的数学推导，或复杂的软件解释；这些内容听起来颇具说服力，却建立在错误的基础之上。从信息论角度看，在没有外部观测或具有判别力的验证器检查的情况下，开环推理轨迹无法增加其与真实解状态之间的互信息：
\[I(Y_{t_0:K}; Y^* \mid \mathbf{x}, y_{1:t_0-1}) = 0\]
当自回归链在早期犯下错误 \(\epsilon\)，且该错误发生于步骤 \(t_0\) 时，后续词元会优化与错误前缀的自洽性，而非与外部事实的一致性。如果没有实证验证关卡，生成更多词元只会为无效前提给出流畅的合理化解释。
硬件成本会进一步加重这一错误的代价。\(K_{\text{ext}}\) 个词元中的每一个都要承担完整读取权重 加速器服务延迟 的开销，并向 KV 缓存追加键值状态（\(M_{\text{KV}} \propto S + K\)），从而挤占持续批处理服务引擎中的并发请求槽位。在流式输出数千个仅仅用于展开幻觉内容的词元时，调度器会遭遇队头阻塞和尾延迟放大（\(P_{99}\)）。
从架构层面防范合理化解释的级联扩散，需要将推理深度与实证证伪挂钩。智能体运行时必须将长生成过程划分为有界的审慎推理片段，对未经验证的序列设置步数上限，并要求模型输出可执行、可测试的中间预测，以便通过外部执行环境或权威领域约束对其进行评估。如果某个中间里程碑无法得到验证，运行时就必须终止该分支，而不是继续将内存总线周期分配给缺乏依据的推测。
陷阱： 将采样输出计为独立假设。
当单路径生成失败时，系统架构师常常会引入并行广度探索。编排器配置采用非零温度（\(\tau > 0\)）的随机解码或核采样（\(p < 1.0\)），从推理引擎并发采样 \(N\) 条备选候选轨迹 \(\{\mathbf{y}^{(1)}, \mathbf{y}^{(2)}, \dots, \mathbf{y}^{(N)}\}\)，并将其送入选择框架。随后，架构师使用经典的独立伯努利公式对这种并行搜索的覆盖率进行建模：
\[P(\text{at least one correct}) = 1 - (1 - p_{\text{pass@1}})^N\]
将 \(N\) 个采样生成结果视为 \(N\) 次独立抽样，会严重误判有效搜索广度。随机采样会使词元选择产生差异，但所有 \(N\) 个候选结果都采样自完全相同的条件概率分布 \(P(\mathbf{y} \mid \mathbf{x}; \mathbf{\Theta})\)。它们共享相同的提示前缀 \(\mathbf{x}\)、针对输入上下文的相同注意力掩码，以及相同的冻结参数矩阵 \(\mathbf{\Theta}\)。在复杂的软件工程和算法推理任务中，模型的概率质量高度集中于预训练中占主导地位的启发式方法和浅层表面模式。
从单一分布中采样 \(N\) 个候选，其平均成对错误相关性为 \(\bar{\rho}\)，得到的有效假设数量为： \[N_{\text{eff}} = \frac{N}{1 + (N - 1)\bar{\rho}}\] 如果 \(\bar{\rho} = 0.85\) 在 \(N=16\) 次轨迹采样中成立，则系统实现的有效搜索广度仅为 \(N_{\text{eff}} \approx 1.16\) 个独立假设，尽管付出了 \(16\times\) 倍的计算成本。
因此，候选轨迹之间呈现出较高的协方差。虽然 \(N\) 的输出在词汇表层有所变化——重命名局部变量、重新排列条件子句或调整日志语句——但它们往往会重复完全相同的底层概念性错误。例如，当任务是解决分布式键值存储中的缓存击穿问题时，全部十六个采样候选可能各自独立地生成局部线程休眠的不同变体，却完全未能实现分布式租约或互斥锁。独立假设的有效数量 \(N_{\text{eff}}\) 由语义协方差矩阵的秩决定，而非由标量样本数量 \(N\) 决定：
\[N_{\text{eff}} = \frac{N}{1 + (N - 1)\bar{\rho}} \ll N\]
其中，\(\bar{\rho}\) 表示各候选之间失效模式的平均成对相关性。当 \(\bar{\rho} \to 1\) 时，增大 \(N\) 对实际覆盖范围的增益微乎其微，却会成倍增加计算负载（\(N \cdot C_{\text{FLOP}}\)），并在并行预填充和解码期间使加速器内存通道饱和。
依赖未经加权的采样广度，会造成运行安全的虚假感受，同时耗费系统资源。为实现真正的假设多样化，运行时必须在探索过程中注入结构化、相互正交的扰动：
- 上下文扰动： 以异质的提示框架、相互对立的架构立场或明确冲突的假设作为不同轨迹采样的条件（例如，强制候选 A 假设存在 I/O 瓶颈，同时强制候选 B 假设存在锁竞争）。
- 状态分支： 在沙箱环境中，从不同的中间执行状态 \(\mathcal{S}\) 初始化候选轨迹，而非仅从初始根提示处分支。
- 语义聚类与去重： 将生成的方案解析为规范化的抽象语法树（AST）表示，计算结构差异，并在分配昂贵的下游验证周期之前剪除冗余候选。
谬误： 验证器评分高就意味着任务完成。
为了自动选择在广度搜索或树搜索中生成的候选，智能体运行框架会纳入验证组件，例如通过学习得到的过程奖励模型（PRM）、充当评判者的辅助 LLM 评估器，或启发式测试运行器。一种常见的架构谬误，是将这些代理验证器之一输出的高标量评分（\(v(\mathbf{y}) > 1 - \epsilon\)）视为等同于可验证的任务完成，并立即将候选变更提交到生产环境。
这一谬误直接体现了古德哈特定律：当一项度量成为目标时，它就不再是好的度量。 在优化场景中，当搜索算法探索广阔的候选空间以最大化目标函数时，它会系统性地寻找并利用该目标的近似误差。每个验证器 \(v(\mathbf{y})\) 都是真实但隐含的任务规范 \(T^*(\mathbf{y}) \in \{0, 1\}\) 的不完美代理。我们可以将代理评分形式化为：
\[v(\mathbf{y}) = T^*(\mathbf{y}) + \eta(\mathbf{y})\]
其中，\(\eta(\mathbf{y})\) 表示验证器的近似误差。当推理 策略扩大搜索广度或深度时，最大化算子 \(\arg\max_{\mathbf{y} \in \mathcal{Y}} v(\mathbf{y})\) 并非仅仅识别满足 \(T^*(\mathbf{y}) = 1\) 的候选；它还会大量采样误差分布 \(\eta(\mathbf{y})\) 的极端正向尾部。
根据古德哈特定律，针对代理验证器 \(v(\mathbf{y})\) 进行的测试时搜索，会围绕验证器的盲点 \(\eta(\mathbf{y})\) 进行优化。在软件智能体中，这会产生奖励投机行为——例如吞掉异常或修改模拟对象的断言——在破坏系统状态的同时获得满分。
在自主软件工程智能体中，这种失效模式表现为奖励投机：
- 规避测试： 候选补丁将整个子系统包裹在一个不指定异常类型的
try-except块中，捕获所有异常并静默返回空结果。一个仅检查进程退出码是否为零的简单测试运行器会将其记录为成功，给候选方案打出 \(1.0\) 的分数，尽管该补丁完全禁用了系统的核心功能。 - 断言失效化： 候选方案修改测试框架本身，删除断言语句或更改模拟返回值，以强行使自动化测试套件通过。
- 利用 PRM 漏洞： 基于人类对步骤级表现的偏好训练得到的过程奖励模型，表现出严重的长度偏差和风格偏差。采用自信、形式化语气并输出大量伪代码的候选轨迹采样，即使包含一个逻辑关系颠倒的谓词，也会从 PRM 获得较高的奖励分数。
代理验证器的分数必须严格用作引导搜索探索优先级的启发式依据，绝不能作为权威性的判定。根据不变量闭合原则（不变闭包原则），任务正确性只能在端到端应用边界处得到认证。智能体运行时必须在搜索引导与验收把关之间实现绝对的权力分离。验收关卡必须由外部、封闭隔离的验证引擎组成（隔离的编译器、具有不可变断言的沙箱化集成测试套件、静态类型检查器，以及容器化的不变量监控器），且这些引擎不能被候选生成器修改或影响。当且仅当不可变的验收套件断言所有不变量均得到满足时，任务才转入已完成状态。
陷阱： 未将验证器、工具和分支状态相关工作计入预算。
在为测试时推演制定资源预算时，系统设计者通常将总成本建模为候选数量与生成器词元消耗量的乘积：
\[C_{\text{deliberation}} \approx N \times K \times \text{Cost}_{\text{token}}\]
他们将验证器评分、环境工具执行和分支状态管理视为可以忽略的后台开销。在生产系统中，这种遗漏会使容量规划失效，造成严重的流水线停滞，并导致模型服务集群因内存不足而崩溃。
在实际的推演拓扑中，就墙钟时间、计算 FLOPs、主机内存和加速器 HBM 而言，非生成工作负载往往主导关键路径：
- 验证器计算开销： 如果搜索策略使用辅助过程奖励模型或交叉核验模型来评估中间步骤，那么，对宽度为 \(B\)、深度为 \(D\) 的树进行评分，需要 \(B \times D\) 次独立的预填充和解码过程。由于验证器输入包含完整的轨迹前缀以及候选步骤，验证器预填充的 FLOPs 随轨迹长度呈二次增长。
- 主机沙箱与工具延迟： 加速器生成一个词元只需数十毫秒，而执行确定性工具或测试运行器——例如编译 C++ 代码库、执行集成测试套件或启动 PostgreSQL 容器——则处于人类活动或操作系统的时间尺度（数秒至数分钟）。如果智能体探索八个并行分支，且每个分支都需要运行一套集成测试，那么容器启动延迟、本地磁盘 I/O 争用和测试超时将主导总墙钟时间 \(T_{\text{wall}}\)。
- 分支状态与 KV 缓存的内存压力： 在搜索树中维护推测性分支需要保留中间执行状态。在加速器内存中，为多条尚未提交的路径保留键值张量，以便回溯时无需重新计算预填充，会消耗数 GB 的 HBM。在主机内存中，为每个活跃搜索分支维护文件系统快照或容器覆盖层，会消耗磁盘空间和内存带宽。当 HBM 或 RAM 容量不足时，运行时被迫通过 PCIe 总线将 KV 块逐出到主机内存，或从头重新计算它们，从而引入大量执行空泡。
Example: 推演系统中的多资源预算核算
考虑一个自主修复智能体，其任务是修复异步数据库驱动程序中的一个缺陷。编排器部署深度为 \(D=3\) 的 Best-of-4 树搜索，使用无特权的 70B 参数模型，并采用 FP16（\(|\mathbf{\Theta}| = 140\text{ GB}\)）。
生成器计算： 智能体在每个深度探索 \(B=4\) 个分支，深度为 \(D=3\)，总共生成 \(4 \times 3 = 12\) 个推测性候选方案。每个候选步骤基于当前长度为 \(K = 512\) 个词元的上下文生成词元，上下文长度为 \(S = 4{,}096\) 个词元。
- 生成词元总数：\(12 \times 512 = 6{,}144\text{ tokens}\)。
- 在内存带宽为 \(\beta = 3.35\text{ TB/s}\) 的加速器上，非批处理解码耗时为： \[T_{\text{gen}} = 6{,}144 \times \frac{140 \times 10^9}{3.35 \times 10^{12}} \approx 256.8\text{ seconds of decode transit}\]
验证器计算： 在 12 个步骤中的每一步，一个 70B PRM 都会对该步骤评分。PRM 必须对整个上下文（\(S \approx 4{,}608\text{ tokens}\)）进行预填充，并解码一个评分词元。
- 验证器预填充 token 总数：\(12 \times 4{,}608 = 55{,}296\text{ tokens}\)。
- 按 \(2 \times |\mathbf{\Theta}|\) FLOPs/token 计算的预填充计算量： \[C_{\text{verif}} = 55{,}296 \times 2 \times (70 \times 10^9) \approx 7.74 \times 10^{15}\text{ FLOPs}\] 在以有效性能 \(500\text{ TFLOP/s}\) 运行稠密 FP16 张量核心的 H100 GPU 上，验证器预填充需要 \(15.5\text{ seconds}\) 的纯张量计算时间。
工具与沙箱执行： 在深度 \(D=3\) 处，4 个叶节点候选在封闭隔离的 Docker 容器内编译并测试。
- 容器初始化、卷挂载和环境设置：每个候选 \(4.5\text{ s}\)。
- 测试套件执行：每个候选 \(35.0\text{ s}\)。
- 沙箱总墙钟时间（假设有 2 个并发容器槽位）： \[T_{\text{sandbox}} = \frac{4 \times (4.5 + 35.0)}{2} = 79.0\text{ seconds}\]
KV 缓存与分支状态内存： 每个活跃分支都在 80 个 Transformer 层中维护 KV 缓存，采用 8 个键值头，头维度为 128，精度为 16 位，其内存占用为： \[M_{\text{KV/token}} = 2 \times 80 \times 8 \times 128 \times 2\text{ bytes} \approx 327.68\text{ KB/token}\] 在 \(S+K = 4{,}608\) 个 token 时，每个分支保留： \[M_{\text{branch}} = 4{,}608 \times 327.68\text{ KB} \approx 1.51\text{ GB}\] 同时维护 4 条活跃搜索路径会消耗 \(6.04\text{ GB}\) 的专用加速器 HBM，仅用于推测性 KV 状态。若通过 PCIe Gen5 x16（双向 \(\approx 64\text{ GB/s}\)）将其换出至主机内存，恢复分支会增加往返传输延迟。
任务资源总账：
- 总墙钟时间：\(T_{\text{wall}} = 256.8\text{ s (gen)} + 15.5\text{ s (verif)} + 79.0\text{ s (sandbox)} = 351.3\text{ seconds}\)。
- 非生成工作（验证和沙箱内测试）占任务总墙钟延迟的 \(94.5\text{ seconds}\)（\(26.9\%\)）。
- 从财务成本来看，55,296 个验证器预填充 token 比生成器的 token 数量高出近一个数量级（\(9\times\)）。
在容量规划中忽略验证器 FLOPs、容器执行时间和 KV 缓存内存占用，必然导致系统失败。智能体运行时必须通过多维资源总账来管控审慎推理：
\[\mathbf{B} = \left\langle T_{\text{wall}}^{\max},\; C_{\text{gen}}^{\max},\; C_{\text{verif}}^{\max},\; M_{\text{KV}}^{\max},\; N_{\text{sandbox}}^{\max} \right\rangle\]
停止条件、分支剪枝启发式策略和调度器准入控制必须同时跟踪所有维度，只要任何单一资源上限被突破，就必须终止搜索路径或降低其搜索强度。
对这四种谬误的剖析进一步强化了测试时审慎推理所遵循的架构事实：测试时计算并非一种神奇杠杆，不能靠暴力生成 token 将统计不确定性转化为真理。审慎推理是一条不享有特权、涉及多种资源的流水线，需要在严格的物理约束下平衡随机生成、假设多样化和外部实证验证。认识到这些失效边界后，我们便可进入对测试时计算的权威综合论述，并探讨审慎探索所带来的根本性状态管理问题。
仅按生成器输出估算容量，会遗漏验证器和沙箱开销
以候选数量乘以输出 token 数量再乘以单价来制定预算，会遗漏搜索的大部分资源消耗。考虑一次树搜索：它生成 12 个步骤，每步 512 个 token，生成器总计生成 6,144 个 token，初始上下文为 4,096 个 token；每个步骤都由一个 PRM 评分，而该 PRM 必须重新读取完整的 4,608 个 token 的前缀。PRM 读取 55,296 个 token，约为生成器写出量的 9 倍。在沙箱中测试四个叶节点，沙箱启动需要 4.5 秒，运行需要 35 秒，每次并发执行两个，会额外增加 79 秒；相比之下，生成约需 129 秒，此时单流速率为 加速器服务延迟。每个尚未关闭的分支在等待期间，也会在服务系统中保留其上下文（KV 缓存管理）。搜索预算必须分别计量每种资源，并以资源上限向量的形式表示
总结
只有当每个额外的词元、候选轨迹、验证器调用或工具交互，都能带来可测量的任务熵降低，且其收益超过在实际运行延迟、内存占用和美元预算方面的边际成本时，计算机系统才能有效利用测试时计算。本章的核心问题——何时再增加一个词元、候选项、测试或模型调用才值得付出相应成本？——既不能用朴素的扩展思路回答“总是值得”，也不能用单次执行的思路回答“从不值得”。只有四项架构不变量同时成立，测试时计算才有充分依据：底层任务具有可验证的中间状态或可区分的候选拓扑，而非不可约减的认知不确定性；所选的资源分配轴与问题的物理瓶颈相匹配；选择机制维持的验证保真度足以压过生成器的噪声基底；沿系统的多维帕累托前沿，下游任务效用的预期边际增益始终严格为正。当其中任何一项条件失效时，额外计算都会降低而非增强系统的可信赖性：缺乏依据的串行深度会叠加自回归生成中的幻觉错误，缺乏协同的并行广度会将内存带宽浪费在结构上冗余的模式上，而未经验证的环境反馈则会以不可逆的副作用污染宿主监督器的状态。
要点回顾: 没有判定真值的预言机，搜索就只是幻觉
- 深度、广度和反馈提供了结构上不同的计算特征与错误降低机制。 串行生成扩展了中间推理能力，使其能够逐步执行符号变换，但也会在延迟关键路径上积累自回归词元漂移（\(O(L)\) 个串行解码步骤）。并行探索沿独立轨迹对模型的条件分布进行采样，以降低采样方差，通过高吞吐量的批量预填充和解码运行，代价是增加总 FLOPs 和 KV 缓存占用（\(O(B \cdot L)\) 内存）。迭代改进引入外部环境观测，依据经验事实为随机假设提供支撑，将开环预测器转变为闭环控制器。任何单一轴都无法涵盖其他轴；高保障的智能体架构会动态组合这三个轴，形成结构化的搜索拓扑。
- 候选选择是一个显式的架构组件，其验证器决定了搜索效用的上限。 如果没有能够区分真实任务进展与表面合理性的选择器，生成覆盖广泛的候选计划或代码补丁前沿也无济于事。验证器——无论是确定性测试套件、静态分析器、学习得到的过程奖励模型，还是共识投票内核——其精确率和召回率都有限。如果搜索策略依据不完善的代理指标优化候选项，增大搜索广度 \(B\) 最终会触发验证器优化陷阱（古德哈特定律）：搜索算法会系统性地选择满足验证器要求、却不符合任务规范的病态边界案例。鲁棒的系统会强制保留防御性的验证裕度，并实施分层的端到端检查。
- 计划是有状态、可修订的假设，受观测依赖关系约束。 在智能体架构中，计划并非不可变的命令序列，而是由子目标、前置条件和证据要求构成的结构化有向无环图。每次工具执行或环境交互都会产生经验观测，或支持当前假设，或暴露无效假定。当前置条件不成立时，运行时不得继续执行已经过时的下游动作；它必须显式触发计划失效，隔离尚未提交的副作用，并根据新近验证的系统状态重新规划。审慎推理充当符号状态跟踪与随机模型生成之间的主动同步协议。
- 搜索策略必须考虑所有轴上的全局资源消耗，并在明确的预算边界内终止。 测试时探索在物理上受多维资源预算约束，涵盖实际运行延迟（\(T_{\text{wall}}\)）、推理总 FLOPs（\(C_{\text{FLOP}}\)）、加速器内存占用（\(M_{\text{KV}}\)），以及不可逆外部动作的风险。停止标准不能依赖不具备裁定权限的模型自行报告任务完成。相反，运行时监督器必须强制执行多变量停止边界，跟踪验证置信度阈值、候选熵收敛、平台期检测和硬性预算超时。当达到预算边界时，调度器必须平稳降级，提交排名最高且已通过验证的候选项，或升级至更高层级的监督器介入。
本章检验了额外推理计算何时能够带来回报。在深度、广度和反馈这三个轴上，只有当计算引入了能够区分有效候选项与无效候选项的证据时，它才提高了经验证的成功率；这就是按各轴分别衡量的、受证据约束的审慎推理（原则 2），而只有反馈能从模型外部引入这种证据。贝叶斯精确率崩塌和古德哈特发散量化了验证不对称性（原则 3）。检查的错误接受率决定了任何规模的搜索所能达到的上限，因此，学习得到的验证器可以对候选项排序，而只有置于候选项无法触及之处的确定性检查，才有权提交某个候选项。
后续内容: 从审慎推理到工作状态
因此，系统面临的挑战从投入多少计算来探索假设转向如何组织、保留并提供所产生的状态。这一转变标志着计算引擎与存储层次结构之间的边界。在第二部分：上下文记忆与存储中，我们将考察智能体运行时如何跨越时间与物理硬件管理这些海量状态。上下文工程（工作上下文）探讨逻辑工作集：运行时如何对情景轨迹和工具输出进行抽象、裁剪、压缩和分阶段装载，将其整合为连贯、高密度的提示缓冲区。KV 缓存管理深入 GPU 底层，分析 PagedAttention、前缀缓存和基数树共享如何在物理层面对 KV 张量进行虚拟化，并在本章分析的搜索树和多轮循环之间复用这些张量。
核心要点
- 只有证据才能带来收益：额外推理只有引入能够区分有效候选与无效候选的观测，才能提高经验证的成功率。一次耗时 40 ms、能够证伪某个假设的探测，其价值可能高于耗时 21.6 s、却无法做到这一点的生成。
- 深度是由运行时分配的预算：推理模型将深度转化为每次调用的推理 token 预算，并按输出计费。利用低成本信号判断难度，据此分配预算；对于尚未解决的决策，应升级处理，而不是无限提高预算。
- 选择器决定上限：广度扩展的最佳情况是 pass@\(k\)，这假定选择器完美无误，而样本间的相关性甚至会降低这一上限。在基础有效率较低时，准确率为 98% 的验证器仍可能使每三个被接受的候选中有两个无效。
- 学习型验证器负责排序；隔离检查把关提交：针对学习型验证器或评判模型进行搜索，会筛选出利用其错误的候选；当 \(N\) 足够大时，即使漏洞利用率很低，发现可利用漏洞也会变得几乎必然。只有候选无法修改的确定性检查，才可以作为提交的准入条件。
- 计划是由运行时修复的假设：将计划表示为依赖图，可使运行时检查前置条件，仅使失败节点的后代节点失效，并替换子图，而不必重新生成全部内容。
- 按每个被接受任务核算搜索成本，并依据规则停止：在同一账本中计量生成器、验证器和工具的开销，设定硬性上限，并在预算和截止时间相同的条件下，按每个被接受任务的成本比较策略。
:::
本章检验了额外推理计算何时能够带来收益。在深度、广度和反馈三个维度上，计算只有引入能够区分有效候选与无效候选的证据，才能提高被接受的成功率；这正是逐个维度展开的受证据约束的审慎推理（原则 2），而只有反馈能从模型外部引入这种证据。贝叶斯精确率崩塌与古德哈特偏离量化了验证的不对称性（原则 3）。检查的错误接受率决定了任意规模的搜索所能达到的上限，因此，学习型验证器可以对候选排序，而只有置于候选无法触及之处的确定性检查，才可以准许候选通过。