← Agents From First Principles

轨迹搜索

让几个部分成形的未来活得足够久,久到证据能把它们区分开,把扩展、评估、分配、剪枝与终止当作五个独立的策略,施加在有界的测试时计算之上。

一个智能体可以让每个局部决定看起来合理,却仍然输掉任务。

一个编码智能体看到 test_checkout_redirect 在失败,断定 checkout.py 里有个实现 bug,然后接下来的二十步表现得无可挑剔:读文件、编辑、跑测试、修复编辑引入的新失败、重写补丁、再跑测试。其中每一步相对前一步都是站得住脚的。

运行仍然失败,因为那个夹具是过期的。

到目前为止构建的机器能让这次运行更安全、更清晰,而不解决根问题。候选生成采样若干完整提案并挑一个,这只在完整替代方案负担得起时才有用。批评与修订改善一个候选,这救不了一条初始假设就错了的路径。规划表示一条打算走的路线,而进度追踪可以正确报告这条路线在前进,即使它是朝着错误解释前进。

缺失的能力比这些都更窄:

把几条部分轨迹保留得足够久,久到证据能把它们区分开。

这就是这里使用的「搜索」的意思。不是网络搜索,也不是数据库搜索。是对智能体自身可能未来的搜索。

在那里干活的词是部分。运行时不会等每个分支都产出一个完成答案,再决定哪些分支配得上另一单位的计算。

在预算之下反复地做那个决定,就是本章的全部主题。


1. 前缀级扩展,以及它为何是一个不同的机制

2026 年一篇测试时扩展综述把推理分成三种结构机制,这个区分给了本章一个精确的立足点。[6]

机制 什么得到更多计算 在何处分支 由什么覆盖
顺序 一条轨迹,被延长 从不 批评、规划、进度
叶级 若干完整输出,然后被约简 完成之后 候选生成与选择
前缀级 若干不完整状态,被选择性地 完成之前 本章
    flowchart LR
    subgraph S[顺序]
        s0[s0] --> s1[s1] --> s2[s2] --> s3[s3]
    end
    subgraph L[叶级]
        r1((root)) --> a[答案 A]
        r1 --> b[答案 B]
        r1 --> c[答案 C]
        a & b & c --> sel[选择]
    end
    subgraph P[前缀级]
        r2((root)) --> A1[A1] --> A2[A2]
        A1 --> A3[A3]
        r2 --> B1[B1]
        r2 --> C1[C1] --> C2[C2]
    end
  

叶级扩展与前缀级扩展常被当作同一个把戏在不同尺寸上讨论。它们不是。Best-of-N 在之前把计算承诺给 N 条完整轨迹,当一条轨迹只是一次模型调用时这可能负担得起,当它是对着真实环境的四十次工具调用时就贵得令人望而却步。前缀级扩展改为评估部分轨迹,可以停止把进一步计算分配给不再证明自己配得上继续的分支。

这能在长轨迹上产生好得多的成本曲线,代价是需要 Best-of-N 不需要的某种东西:一种评估未完成工作的方法。

轨迹搜索是施加在部分智能体状态之上的前缀级测试时扩展。


2. 分支什么时候被证明合理,以及它不是什么

搜索不自动比单个跑得好的循环更好;把它加进一个不需要它的系统,买到的是延迟与一个新的失败面。四个条件应当大致成立:确实存在若干看似合理的路径、早期选择强烈约束后期结果、部分路径能被某个东西评估,以及额外的推理或环境工作是负担得起的。

失掉其中任何一个,更简单的机制就赢。如果下一步是确定性的,搜索增加机器而不增加能力。如果完整答案采样起来便宜,叶级选择就足够,而且推理起来容易得多。如果第一次尝试通常就差不多对,有针对性的修订胜过广度。

当若干未来必须同时保持活着时,搜索才挣得自己的位置。

值得精确说明它与之重叠与不重叠的是什么,因为三个邻居机制一直与它混淆。

机制 问题 与搜索的关系
记忆 过去什么应该影响这个决定? 可以给分支播种、打分或剪掉;不创造分支
规划 什么未来工作被打算? 拥有那个表示;搜索在路线之间竞争
批评与修订 这一个候选如何被改善? 运行在分支内部;若在它们之间运行就会坍缩广度

最后一行是让团队翻车的那行。一个生成三个分支然后把它们全部朝同一个答案修订的系统,为广度付了钱,一点也没留下。


3. 节点是可恢复的状态,不是一句话

一个标着“这个方法看起来有希望”的分支不是搜索节点。

那是一条笔记。一个节点必须携带足够的状态,能不靠从散文重建而继续这个分支。

from dataclasses import dataclass, field
from typing import Any

@dataclass
class SearchNode:
    id: str
    parent_id: str | None
    depth: int
    state: dict[str, Any]
    env_checkpoint: str | None = None
    action: dict[str, Any] | None = None
    observation: dict[str, Any] | None = None
    score: "NodeScore | None" = None
    terminal: bool = False
    pruned_by: "SearchStage | None" = None
    prune_reason: str | None = None
    cost: float = 0.0
    metadata: dict[str, Any] = field(default_factory=dict)

state 对象通常携带目标、当前假设、已确立的事实、约束、产物、剩余预算以及任何在场的记忆 ID。

检验是钝的:

如果一个分支不能从它的节点恢复,那棵树就是一幅图,而不是一个数据结构。

env_checkpoint 刻意与 state 分开,而它是最常缺席的字段。

搜索假定相互竞争的未来可以被独立考虑。那个假定对纯推理是免费的,对会改变东西的智能体是昂贵的。假设分支 A 编辑了 parser.py,分支 B 随后读 parser.py。分支 B 悄悄继承了分支 A 的世界,两者不再是备选项,而每个下游分数度量的都是一个没有任何搜索策略选择过的状态。

这棵树是虚构的,而轨迹里什么也没这么说。

前一章恢复已经确立了更强的契约:一个可恢复的点需要一个智能体侧状态和一个对齐的环境状态。搜索把那个要求从一条被放弃的轨迹推广到若干条活着的轨迹。隔离可以用 copy-on-write 状态、Git worktree、容器、数据库事务、独立的浏览器会话或检查点—恢复,但不变量是同一个:

分支 A 状态 + 分支 A 环境
绝不能泄漏进
分支 B 状态 + 分支 B 环境

因此检查点标识符属于节点,而不是属于一个全局。

还有一个陷阱。两个节点等价,只有当每个可能影响它们未来的差异都被刻意排除。一个记得事实却忘记已修改文件、浏览器会话、权限或剩余预算的指纹,能把不同的未来合并成一个。第 10 节把状态等价变成应用提供的策略,而不是假装一个通用元组能知道什么要紧。


4. 在提案上自由分支,在副作用上只分支一次

有些分支根本不能被投机地执行。不能发三笔退款、不能发三封邮件、不能做三次生产部署,然后把最好的那个留下来。

因此重要的边界不在校验之前。校验、授权与前置条件检查是无副作用的运行时决定,可以施加给每个候选。单值的边界是真实执行。

    flowchart TD
    P[提议候选延续] --> A{"准备每个提案:<br/>解析、校验、授权、<br/>检查前置条件"}
    A -->|Rejected| R[记录拒绝阶段]
    A -->|Accepted| S["检查 / 模拟 / 预览<br/>在隔离中"]
    S --> E[给候选未来打分]
    E --> C[排序并坍缩前沿]
    C --> K{"重新检查当前<br/>授权 + 前置条件"}
    K -->|Rejected| N[尝试下一个排名靠前的候选]
    N --> K
    K -->|Accepted| X[执行一次]
    X --> O[观察]
    style X fill:#f6c8c8,stroke:#b04a4a
  

唯一那个红框是设计约束。

它之上的一切必须无副作用,或者与真实环境隔离。它不一定便宜:一个沙箱化的测试套件可能花几分钟,一次仿真可能消耗可观的计算。可逆才是重要的性质,不是廉价。

即使真实世界必须保持单值,搜索也可以在已提议的、已校验的或已仿真的效果上分支。

因此动作边界必要时运行两次。它在投机评估之前过滤不可能或被禁止的提案,而胜出提案在承诺之前立刻再被检查,因为权限、预算或环境前置条件可能在搜索运行期间变了。

搜索在候选未来之间选择。它从不授予执行其中一个的权威。


5. 五个策略,不是一个算法

关于智能体搜索的大多数混乱,来自给一个算法命名并继承它的假设。束搜索、最佳优先搜索与 MCTS 确实是不同的算法,但每一个都把对相同底层策略问题的回答捆在一起。

对智能体工程来说,把这些问题分开往往比从算法名字开始更有用。

策略 问题 出错时它造成的失败
扩展 应该存在哪些替代的延续? 正确的路径从未被生成
评估 什么证据估计前景与进度? 好分支得分差
分配 哪些节点得到更多计算? 预算花在已定的决定上
剪枝 哪些节点停止消耗计算? 胜出的分支在深度 2 被丢掉
终止 前沿何时坍缩? 永久探索,或过早承诺
    flowchart LR
    F[前沿] --> EX[扩展]
    EX --> EV[评估]
    EV --> AL[分配]
    AL --> PR[剪枝]
    PR --> TE{"终止?"}
    TE -->|no| F
    TE -->|yes| CM[承诺]
  

固定宽度的束是一种特定的分配—剪枝策略。最佳优先搜索是另一种。MCTS 加上一个特定的树策略、价值更新规则与探索机制。本章不主张那些算法可互换;它主张这五种责任在所选的那一个内部保持可检视。

这个拆解要紧,因为这些策略可以分别被度量和消融。接下来五节每一节取一个。


6. 扩展:不同的未来,不是不同的字符串

如果五个全是转述,名义上的分支因子五毫无意义。考虑一次扩展,返回检查 parser.py、打开 parser.py、查看 parser 实现、仔细阅读 parser.py 和检查 parser.py 里的分隔符代码。生成了五个分支。搜索空间只被探索了一个区域,预算却花了五遍。

当扩展被给予语义角色而不是温度时,多样性会改善。对调试:当前最强的假设、一个竞争假设、一个信息收集动作、一个保守的兜底,以及对当前假设的挑战。对事故响应,角色变成层次——应用、基础设施、数据、最近变更。对研究,它们变成对证据的立场:支持当前解释、寻找否证证据、调查竞争解释、检验某个前提是否为假。

没有数字附上来,这些都不值得争论。

from collections import Counter
from typing import Callable, Sequence

def unique_branch_ratio(
    children: Sequence[SearchNode],
    signature: Callable[[SearchNode], object],
) -> float:
    if not children:
        return 0.0
    return len({signature(c) for c in children}) / len(children)

def effective_branch_factor(
    children: Sequence[SearchNode],
    signature: Callable[[SearchNode], object],
) -> float:
    return unique_branch_ratio(children, signature) * len(children)

签名是判断住的地方:一个动作种类加它的目标、一个假设标签,或结果状态的一个指纹。要紧的是它是一个你能改变并重新度量的函数。

一个在唯一分支比 0.25 下运行 branch_factor = 8 的配置,其有效分支因子接近二。

把 N 提到十六会大致让账单翻倍,而有效宽度恰好原地不动。


7. 评估:前景与进度是不同的信号

终止状态允许直接的问题。测试过了吗、交易完成了吗、产物满足规格吗。部分状态通常一个都不允许,因为它此刻既不算对、也不算错。

它多多少少值得继续。

所以评估器估计的是更接近这样的东西:如果我在这个分支上花更多计算,它多有前景,它已经做出了什么可度量的进度? AgentPRM 对智能体决定做了本质相同的区分,把前景与进度分开,而不是把中间动作当作简单的对或错。[4]

两个分支让这个区分变具体。分支 A 有一个能强解释已观察失败的假设,并且没有尝试任何补丁。分支 B 把一个失败测试变绿,把三个无关测试变红。一个未分化的单一分数藏住了这个事实:A 有前景无进度,而 B 有进度带回归。

from enum import IntEnum

class EvidenceTier(IntEnum):
    JUDGE = 0            # model judgement
    PROCESS_MODEL = 1   # learned value / process model
    DOMAIN_SIGNAL = 2   # task-specific deterministic signal
    ENVIRONMENT = 3     # direct observation from the task environment

@dataclass(frozen=True)
class NodeScore:
    promise: float
    progress: float
    regressions: int = 0
    violations: int = 0
    tier: EvidenceTier = EvidenceTier.JUDGE
    uncertainty: float = 0.0
    cost: float = 0.0

    @property
    def blocked(self) -> bool:
        return self.violations > 0

    @property
    def rank_key(self) -> tuple:
        return (
            not self.blocked,
            self.progress - 0.5 * self.regressions,
            self.promise,
            int(self.tier),
            -self.cost,
        )

那个 rank_key 是一个示意性策略,不是一把通用标尺。模型置信 0.9、测试通过率 0.9 与学习到的价值 0.9 不自动可比,只因为它们共享一个小数表示。生产系统应当在留出轨迹上校准它们组合的信号。

硬规则更简单:硬约束违反不是稍差一点的分数;直接观察应当更新它们实际确立的状态变量,而不是只给评估器加分。

因此证据层级既是排序信息,也是归因。当两个分支在其他方面接近时,更强的外部证据是一个合理的打破平局者;不应被用来假装不可比的测量有一个通用的全序。

宁可要环境生成的证据,也不要模型生成的置信,同时不假装每种证据源都与另一种校准过。

这也防御最安静的搜索失败:自我确认。当一个模型生成分支、给分支打分并解释赢家时,运行时在共享偏见之上生产了多样性的外观。三个只被自己的作者评估的分支仍是一个证据源。使证据多样化——确定性检查、独立工具、环境状态、独立的验证器或权威来源——比使措辞多样化更要紧。


8. 分配:花在决定未解决之处

固定束在每个深度保留 k 个分支,这很好解释、很少是最优的。没有理由有用的宽度应当恒定。bug 诊断可能在深度零想要六个假设、在深度三想要一个;另一个任务可能需要相反的。

深度只是实际变化之处的粗略代理:决定有多未解决。

考虑对下一个动作的两种投票分布。八票给 read_file、各一票给 search_code 与 run_tests,看起来已定。四、三和三看起来有争议。

from math import log

def uncertainty(votes: Counter[str]) -> float:
    """Normalised vote entropy in [0, 1]. 0 = unanimous."""
    total = sum(votes.values())
    if total == 0 or len(votes) < 2:
        return 0.0
    entropy = -sum(
        (n / total) * log(n / total)
        for n in votes.values()
        if n
    )
    return entropy / log(len(votes))

def top_two_margin(votes: Counter[str]) -> float:
    ranked = [n for _, n in votes.most_common(2)]
    if len(ranked) < 2:
        return 1.0
    return (ranked[0] - ranked[1]) / sum(votes.values())

投票熵与前二差距是不一致信号,不是真相仪表。十个相同的错误样本熵为零。九个其他候选未过动作边界之后剩下的一个候选也没有可度量的不一致,但这不是那个幸存提案独特好的证据。

因此搜索策略应区分充分替代之间的一致与替代的缺席。把其中任何一个等同于正确性,能自信地饿死那个本会含有修复的分支。

有用的主张更窄:当这些统计在任务分布上被经验地预测时,它们能告诉运行时在哪里额外采样更可能买到信息。CATTS 为 Web 智能体报告了正好这个模式,用投票导出的不确定性选择性地分配额外推理,并在其被评设置里用更少的 token 胜过均匀扩展。[5]

这引出两条护栏:

  1. 针对下游结果校准不确定性。 不要因为熵有正确的形状就假设它预测难度。
  2. 保留一个最低探索下限。 低不确定的决定仍然可能是错的,尤其是在运行早期,当所有样本共享同一份缺失证据时。
    flowchart LR
    E["探索<br/>宽、廉价、信息性"] --> D["区分<br/>证据把各分支分开"]
    D --> X["利用<br/>窄、深、转换性"]
  

广度与深度回答不同的不确定性,而有用的机制可以在任务期间改变,而不是为它固定。广度问哪个假设配得上存活。深度问那个幸存者是否真能被贯彻到底。

机制转移也改变哪些动作值得做。动作大致分成信息性的——读文件、跑一个聚焦测试、检视指标、查询状态——和转换性的——编辑文件、重启服务、提交表单、写入数据库。如果智能体在缓存 bug 与数据库锁之间纠结,一次立即编辑让一个分支前进一步,而一条把两者分开的诊断查询可能坍缩半个前沿。

当转换昂贵或不可逆时,便宜的判别性信息往往是更好的购买。一个只给即时任务进度打分的搜索策略会错过那个价值。


9. 剪枝:好的搜索去死的地方

生成器产出成功的分支。评估器给它打分。运行时把它剪掉。搜索失败。

生成成功了。搜索策略后来失败了。

这些需要不同的修法,而端到端成功无法把它们区分开。与候选选择、记忆召回相同的拆解应用到树上,但各阶段的含义必须是显式的。

from enum import StrEnum

class SearchStage(StrEnum):
    REACHABLE = "reachable"      # a successful route is expressible
    GENERATED = "generated"      # expansion produced that route/prefix
    DISTINCT = "distinct"        # survived deduplication
    EVALUATED = "evaluated"      # received a usable partial-state score
    SURVIVED = "survived"        # was not pruned while still viable
    COMPLETED = "completed"      # received enough depth to terminate
    VERIFIED = "verified"        # terminal result passed external verification

@dataclass(frozen=True)
class SearchTrial:
    """One labelled task with a known successful trajectory or prefix."""

    task_id: str
    reachable: bool = False
    generated: bool = False
    distinct: bool = False
    evaluated: bool = False
    survived: bool = False
    completed: bool = False
    verified: bool = False

    @property
    def flags(self) -> tuple[tuple[SearchStage, bool], ...]:
        return (
            (SearchStage.REACHABLE, self.reachable),
            (SearchStage.GENERATED, self.generated),
            (SearchStage.DISTINCT, self.distinct),
            (SearchStage.EVALUATED, self.evaluated),
            (SearchStage.SURVIVED, self.survived),
            (SearchStage.COMPLETED, self.completed),
            (SearchStage.VERIFIED, self.verified),
        )

    def validate(self) -> None:
        reached_false = False
        for stage, reached in self.flags:
            if reached_false and reached:
                raise ValueError(
                    f"{self.task_id}: {stage} cannot be reached after an earlier loss"
                )
            reached_false |= not reached

    @property
    def lost_at(self) -> SearchStage | None:
        self.validate()
        for stage, reached in self.flags:
            if not reached:
                return stage
        return None

def _fraction(numerator: int, denominator: int) -> float:
    if denominator == 0:
        return float("nan")

    return numerator / denominator


def oracle_generated_success(trials: Sequence[SearchTrial]) -> float:
    """Fraction of reachable tasks where search generated the known-good route."""
    reachable = [t for t in trials if t.reachable]

    return _fraction(
        sum(1 for t in reachable if t.generated),
        len(reachable),
    )


def selected_success(trials: Sequence[SearchTrial]) -> float:
    """Fraction of reachable tasks converted into externally verified success."""
    reachable = [t for t in trials if t.reachable]

    return _fraction(
        sum(1 for t in reachable if t.verified),
        len(reachable),
    )


def search_gap(trials: Sequence[SearchTrial]) -> float:
    """Generated opportunity that the remainder of search failed to convert."""
    generated = oracle_generated_success(trials)
    selected = selected_success(trials)

    if generated != generated or selected != selected:
        return float("nan")

    return generated - selected


def pruning_regret(trials: Sequence[SearchTrial]) -> float:
    """Known-good generated routes pruned before completion."""
    generated = [t for t in trials if t.reachable and t.generated]

    return _fraction(
        sum(
            1
            for t in generated
            if t.lost_at is SearchStage.SURVIVED
        ),
        len(generated),
    )


def allocation_regret(trials: Sequence[SearchTrial]) -> float:
    """Known-good generated routes kept alive but starved before completion."""
    generated = [t for t in trials if t.reachable and t.generated]

    return _fraction(
        sum(
            1
            for t in generated
            if t.lost_at is SearchStage.COMPLETED
        ),
        len(generated),
    )

加上 COMPLETED 很重要。没有它,「分支在预算耗尽时还活着」和「分支完成了但没通过验证」坍缩成同一个布尔值。

各阶段指向不同的子系统:

丢失在 失败的是什么 在哪里下手
REACHABLE 动作空间无法表达解法 能力设计
GENERATED 扩展从未提案可行路径 扩展角色、采样
DISTINCT 一条可行路径被当作等价重复合并掉 状态键、去重策略
EVALUATED 产生不出可用的分数 评估器 / 仪表化
SURVIVED 一条可行的分支被剪掉 剪枝规则、评估器排序
COMPLETED 它活下来了,但深度或预算被饿死 分配、节点预算
VERIFIED 分支完成了,但没通过外部成功检查 那条分支其实并不成功;检视把它标为可行的路线或假设

oracle_generated_success 是 oracle@N 在前缀搜索里的对应物:搜索到底创没创造出机会?selected_success 问的是系统是否把那个机会转化成了已验证的结果。

在线上,pruning_regret 与 allocation_regret 是反事实的,因此不可直接观察。在基准环境里,对一个受控样本的已剪掉或已饿死的分支,在生产搜索本应停住它们的那一点之后继续下去。那个实验估计该策略多常杀掉一个本会成功的未来。

在决定的那一刻填充 SearchNode.pruned_by 与 prune_reason,正是让诊断事后可被重建的东西。


10. 终止:坍缩前沿

过早承诺是本章要修的那件事。永久探索是它的镜像:另一个假设、另一个分支、另一个诊断、没有承诺。轨迹看起来很勤奋。

什么都发布不出去。

终止策略需要可检视的条件:除一个分支外全部违反硬约束;一个终止分支通过了验证器;排序差距在又一次有区分力的扩展中保持稳定;估计的边际收益低于边际成本;或搜索预算耗尽、运行时必须交还控制权。

单独的模型置信不是这些条件之一。

去重属于终止旁边,因为它改变前沿是否真正多样。两条轨迹可以经不同路径到达同一个有效状态。继续两者是为一个未来付两次代价——但只在它们确实等价时。

from collections.abc import Hashable, Mapping
from typing import Callable

StateKey = Callable[[Mapping[str, object]], Hashable]

def coding_state_key(state: Mapping[str, object]) -> Hashable:
    """Example only: include every field that can change future behaviour."""
    return (
        tuple(sorted(state.get("facts", ()))),
        tuple(sorted(state.get("completed", ()))),
        tuple(sorted(state.get("artifacts", ()))),
        state.get("workspace_revision"),
        state.get("environment_version"),
        state.get("goal_phase"),
        state.get("remaining_budget"),
    )

对智能体而言不存在通用的 state_fingerprint()。

如果一个键漏掉一个与未来相关的变量,去重就变成腐化。两个认证会话不同的浏览器节点不等价,因为它们的可见文本碰巧一致。两个工作树改动不同的编码节点不等价,因为它们的事实集合一致。两个剩余预算不同的节点可能不等价,即使其他每个字段都相同。

因此状态键是搜索协议的一部分,配得上自己的一套测试。

即使键正确,先被看到的也不自动最好。如果两条路径到达同一个有效状态,保留证据调整后得分更好或累计成本更低的代表,而不是碰巧先生成的那个。

一旦等价路径能合并,结构就不再是严格意义上的树。Graph of Thoughts 把更宽的图结构化推理视角形式化,包括中间状态的聚合与复用。[2] 生产智能体不需要那个框架也能接受这条有用的工程教训:

不要为探索同一个有效未来付两次代价;在等价性被实际证明之前,不要合并未来。


11. 循环,组装起来

这五个策略组装成一个仍然很小的搜索运行时,但一个生产安全的骨架比玩具束循环需要多一些保证:节点预算必须是硬的,空前沿必须可表示,终止节点不得被扩展,等价状态必须竞争而不是服从先见序。

from enum import StrEnum
from typing import Hashable, Protocol

class SearchEnd(StrEnum):
    POLICY_STOP = "policy_stop"
    FRONTIER_EXHAUSTED = "frontier_exhausted"
    MAX_DEPTH = "max_depth"
    MAX_NODES = "max_nodes"

@dataclass(frozen=True)
class SearchResult:
    best: SearchNode | None
    nodes: tuple[SearchNode, ...]
    reason: SearchEnd

class SearchPolicies(Protocol):
    def expand(self, node: SearchNode, width: int) -> list[SearchNode]: ...
    def evaluate(self, node: SearchNode) -> NodeScore: ...
    def width_for(self, node: SearchNode) -> int: ...
    def keep(self, scored: list[SearchNode]) -> list[SearchNode]: ...
    def should_stop(self, frontier: list[SearchNode]) -> bool: ...
    def state_key(self, node: SearchNode) -> Hashable: ...

    def prefer_equivalent(
        self,
        new: SearchNode,
        old: SearchNode,
    ) -> bool: ...

def search(
    root: SearchNode,
    policies: SearchPolicies,
    *,
    max_depth: int = 5,
    max_nodes: int = 50,
) -> SearchResult:
    if max_nodes < 1:
        raise ValueError("max_nodes must be at least 1")

    if root.score is None:
        root.score = policies.evaluate(root)

    if root.parent_id is not None:
        raise ValueError("root node must not have a parent")

    frontier = [root]
    nodes = [root]
    known_ids = {root.id}

    best_by_state: dict[Hashable, SearchNode] = {
        policies.state_key(root): root
    }

    for _ in range(max_depth):
        if policies.should_stop(frontier):
            best = max(frontier, key=lambda n: n.score.rank_key)
            return SearchResult(best, tuple(nodes), SearchEnd.POLICY_STOP)

        candidates = [node for node in frontier if node.terminal]
        expandable = [node for node in frontier if not node.terminal]

        remaining = max_nodes - len(nodes)
        if remaining <= 0:
            best = max(frontier, key=lambda n: n.score.rank_key)
            return SearchResult(best, tuple(nodes), SearchEnd.MAX_NODES)

        for node in expandable:
            width = max(0, policies.width_for(node))
            width = min(width, remaining)
            if width == 0:
                continue

            proposed = policies.expand(node, width)[:width]

            for child in proposed:
                if len(nodes) >= max_nodes:
                    break

                if child.id in known_ids:
                    raise ValueError(f"duplicate search node id: {child.id}")

                if child.parent_id != node.id:
                    raise ValueError(
                        f"{child.id}: parent_id does not match expanded node {node.id}"
                    )

                if child.depth != node.depth + 1:
                    raise ValueError(
                        f"{child.id}: child depth does not follow parent"
                    )

                known_ids.add(child.id)
                child.score = policies.evaluate(child)
                nodes.append(child)

                key = policies.state_key(child)
                incumbent = best_by_state.get(key)

                if incumbent is not None:
                    if not policies.prefer_equivalent(child, incumbent):
                        child.pruned_by = SearchStage.DISTINCT
                        child.prune_reason = "equivalent state, weaker representative"
                        continue

                    incumbent.pruned_by = SearchStage.DISTINCT
                    incumbent.prune_reason = "replaced by better equivalent state"

                best_by_state[key] = child
                candidates.append(child)

            remaining = max_nodes - len(nodes)
            if remaining <= 0:
                break

        candidates = [
            node
            for node in candidates
            if node.pruned_by is None
        ]

        if not candidates:
            scored = [n for n in nodes if n.score is not None]
            best = max(scored, key=lambda n: n.score.rank_key) if scored else None

            return SearchResult(
                best,
                tuple(nodes),
                SearchEnd.FRONTIER_EXHAUSTED,
            )

        kept = policies.keep(candidates)
        kept_ids = {node.id for node in kept}

        for child in candidates:
            if child.id not in kept_ids and child.pruned_by is None:
                child.pruned_by = SearchStage.SURVIVED
                child.prune_reason = "removed by pruning policy"

        frontier = kept

        if not frontier:
            scored = [n for n in nodes if n.score is not None]
            best = max(scored, key=lambda n: n.score.rank_key) if scored else None
            return SearchResult(
                best,
                tuple(nodes),
                SearchEnd.FRONTIER_EXHAUSTED,
            )

        if len(nodes) >= max_nodes:
            best = max(frontier, key=lambda n: n.score.rank_key)
            return SearchResult(best, tuple(nodes), SearchEnd.MAX_NODES)

    best = max(frontier, key=lambda n: n.score.rank_key) if frontier else None
    return SearchResult(best, tuple(nodes), SearchEnd.MAX_DEPTH)

运行时刻意对为什么一个好节点知之甚少。那属于策略。运行时拥有的是不变量:预算是真实的,终止节点不扩展,每个节点都被交代,等价状态显式竞争,每次退出都有一个名字。

分支隔离仍然是 expand 的一项契约。对会改变环境的智能体,expand 必须在产出每个子节点之前,把父检查点恢复进一个隔离环境。如果它无法保证这一点,搜索只在提案或模拟上有效,且必须在真实执行之前坍缩。

更复杂的实现可以用优先队列、异步工作器、MCTS 统计或学习型分配。这些改变调度。它们不移除这些不变量。


12. 只在边界承诺一次

通用循环对纯推理与隔离环境是安全的。对不可逆的真实动作,生产代码搜索的是准备好的提案与预览,然后只执行一个动作一次。

动作边界应当在预览前过滤候选,而胜出者应当在承诺时刻再被检查一次。

from collections.abc import Callable

def search_then_commit(
    state,
    propose: Callable[[object, int], list[object]],
    prepare: Callable[[object], "Decision"],
    preview: Callable[[object, "Action"], object],
    evaluate: Callable[[object, "Action", object], NodeScore],
    execute: Callable[["Action"], object],
    vote_key: Callable[["Action"], str],
    *,
    base_width: int = 2,
    extra_width: int = 3,
    threshold: float = 0.35,
):
    def consider(width: int):
        accepted = []
        for raw in propose(state, width):
            decision = prepare(raw)
            if not isinstance(decision, Accepted):
                continue

            simulated = preview(state, decision.action)
            score = evaluate(state, decision.action, simulated)
            accepted.append((raw, decision.action, score))
        return accepted

    candidates = consider(base_width)

    votes = Counter(
        vote_key(action)
        for _, action, _ in candidates
    )

    insufficient_candidates = len(candidates) < base_width
    unresolved_choice = uncertainty(votes) > threshold

    if extra_width > 0 and (insufficient_candidates or unresolved_choice):
        candidates += consider(extra_width)

    candidates.sort(
        key=lambda item: item[2].rank_key,
        reverse=True,
    )

    for raw, _prepared_action, _score in candidates:
        # Re-run the boundary immediately before the real side effect.
        current = prepare(raw)
        if isinstance(current, Accepted):
            return execute(current.action)

    return None

preview 被要求是无副作用的或隔离的。如果一个能力没有安全的预览,就略去投机执行,用任何不承诺的证据给准备好的提案打分。

第二次 prepare 不是冗余的。搜索可能花上足够久,久到授权、预算或环境前置条件发生变化。生成时可采纳的那个候选,在承诺时刻只是个候选。

搜索选择下一步提案什么。动作边界决定那个提案是否仍然被允许。执行只发生一次。


13. 树的代价

一个 0.82 的分支分数,在不知道确立它花了什么代价时,是不可解释的。一个分支只需要一次只读调用。另一个需要四次模型调用、三次工具调用和一次沙箱执行。节点核算应当覆盖模型词元与调用、工具调用、挂钟时间、沙箱成本,以及对不可逆风险预算的任何消耗。

附上成本之后,有用的问题变成边际的:

下一个单位的搜索买到了什么?

天真的期望是束 2 < 束 4 < 束 8。若干效应打破那个单调性。搜索空间变大时,弱的评估器有更多被骗的机会。分支变得冗余。搜索预算可能从最终验证偷走计算。更长的轨迹制造更多普通执行错误的机会。而候选选择章的代理过度优化问题在树里重现:更大的候选空间给有缺陷的评估器更多机会,去找那些因错误理由而得高分的东西。

一条值得度量的形状示意曲线:

策略 已验证成功 调用 token 延迟
单条轨迹 68% 8 1.0× 1.0×
Best-of-3 74% 18 2.1× 1.8×
束-2 81% 24 2.8× 2.2×
束-4 83% 41 4.9× 3.7×
束-8 82% 73 8.4× 6.2×
自适应 82% 29 3.1× 2.5×

这些数字是示意性的。实验才是要点,要追求的对象是质量—计算前沿,而不是最大的树。

在那个例子里,束-8 在每一个报告列上都严格劣于束-4。

原始成功率也谄媚昂贵的系统,所以要把账单归一化:

def cost_per_verified_success(
    cost_per_run: float,
    verified_success_rate: float,
) -> float:
    if verified_success_rate <= 0:
        return float("inf")
    return cost_per_run / verified_success_rate

一个 80% 成功、每次运行 1 个单位的系统,每次已验证成功花 1.25 个单位。一个 90%、每次 4 个单位的系统花大约 4.44 个单位。后者对一次高价值事故可能是对的系统,对数百万次低价值请求则是错的系统。

验证频率值得同样的处理。在每个小步骤后给每个分支打分可能主导账单;很少打分则让坏分支在没人注意到之前消耗计算。过程奖励与智能体搜索工作越来越把中间评估当作一种资源,放在它能改变分配的地方,而不是当作一个免费常数。[3][4] 合理的触发器包括有意义的状态变化、不确定性尖峰、一次昂贵变换之前的那一点,或各分支开始实质性分岔的那一点。

那是一条要度量的分配策略,不是一张通用时间表。


14. 协议是系统的一部分

单路径的智能体轨迹记录发生了什么。

搜索轨迹还必须记录差点发生什么,否则搜索在结束的那一刻就变得不可审计。每个节点至少保留:标识符与父节点、深度、状态键、环境检查点、被提议的动作、观察或预览结果、分数分量、证据层级、不确定性、累积的投机成本、是否被扩展过,以及若被剪掉,阶段与理由。有了这些,四个问题变得可回答:胜出分支在哪里分岔、一个有望的分支为什么被剪掉、哪个信号主导了它的分数,以及多少计算花在了从未被承诺的未来上。

配置需要同样的处理。搜索的自由度足够大:两个都被描述为“束搜索”的运行,成本与行为可以相差数倍。

from dataclasses import asdict
import hashlib
import json

@dataclass(frozen=True)
class SearchProtocol:
    model_id: str
    evaluator_id: str
    temperature: float
    branch_factor: int
    beam_width: int
    scoring_frequency: str
    prune_threshold: float
    uncertainty_threshold: float
    max_nodes: int
    max_depth: int
    tool_budget: int
    state_key_version: str
    isolation_mode: str
    seed: int | None

    def fingerprint(self) -> str:
        payload = json.dumps(asdict(self), sort_keys=True)
        return hashlib.sha256(payload.encode()).hexdigest()[:12]

state_key_version 与 isolation_mode 应当与温度和束宽并列,因为它们能同样剧烈地改变结果。一个把浏览器会话在同一键下合并的运行,与一个把它们分开的运行,不是同一个推理系统。

2026 年那篇测试时扩展综述明确说出了这个更宽的观点:被评估的对象是整个推理协议,而不只是基座模型,当计算核算与搜索程序被省略时,比较是不可解释的。[6]

一个没有产生它的协议的基准数字,不是一个可复现的结果。


15. 分开测试每个策略

端到端成功无法告诉你五个策略里哪一个在失败,所以为每一个构建受控夹具。

策略 夹具 指标
扩展 已知可行策略的任务 expansion_recall@k、unique_branch_ratio
评估 已知好与已知坏的部分状态 成对排序准确率、校准
分配 标注了歧义的决定 花费的计算对测得的不确定性、分配遗憾
剪枝 有已知可行分支的任务 pruning_regret、存活到深度
终止 一个已知赢家加干扰分支 误停率、过度搜索成本
端到端 完整任务集 已验证成功、搜索差距、每次已验证成功的成本

终止那一行很要紧。一个搜索可以有出色的扩展、评估与剪枝,却仍然在决定早已定下之后浪费一半预算,或者在证据本可以把赢家区分出来之前就停下一次扩展。那些是策略错误,不是围绕最终分数的噪声。

然后跑消融,固定基座模型、工具集、任务集、最终验证器、上下文与成本包络:

单条轨迹
→ Best-of-N 完整轨迹
→ 对部分状态的固定宽度搜索
→ + 客观的部分状态证据
→ + 自适应分配
→ + 等价感知的去重

每一级都必须挣来它相对下一级的复杂度。

最有信息量的任务集围绕搜索本该修的那个失败来构建:第一条看似合理的路径刻意是误导的。在编码里,那个显而易见的文件不是原因。在研究中,那个显著假设与原始证据相矛盾。在浏览器里,第一个可见按钮不是有效的下一步。在运维里,最近的部署与事故相关、但不是事故的原因。

如果前缀级搜索在围绕过早承诺设计出来的任务上打不过单轨迹智能体,那实现就还没挣来那份额外机器。


16. 搜索买到了什么

运行时现在能保持几个可能的未来敞开,用显式证据给它们打分,在决定仍未解决之处分配额外计算,只在声明的等价关系下合并未来,并在一个仍然校验它的边界处坍缩到一个动作。

本章开场所说的那个失败——二十个能干步骤走在一条由第一个错误假设选出的路上——现在可以被拆解。扩展曾生成那条可行路径吗?去重擦掉它了吗?评估器让它失去竞争力了吗?剪枝杀掉了它吗?分配饿死了它吗?还是它完成了却没通过验证?

「搜索失败了」已经变成若干可测试的陈述。

这些全都不是在主张分支让一个智能体本质上更聪明。它是一个更窄的工程主张:前缀级搜索能在以下情形改善决定:有用的替代确实存在、分支状态是隔离的、部分成形的未来能用增添信息的信号评估,以及额外的计算跟随证据而不是习惯。分支多样性、评估器质量、状态等价性、隔离与经济性,各自独立地给收益封顶。

还有一条搜索移除不了的极限。

一个分支可以在每一层深度都得高分。前沿可以干净地坍缩。评估器可以被校准、差距可以稳定、协议可以复现,模型可以报告任务完成。

这些事实没有一条确立用户的目标达成了。

搜索回答了:

我们该承诺哪个未来?

它没回答:

什么证据配得上让运行时把结果世界称为成功?

那道剩余的边界是下一章的主题。


研究渊源

本章是一次工程综合而非综述,引用是选择性的。这些工作锚定了机制,以及更重要的——那些告诫。

  1. Yao et al. — Tree of Thoughts: Deliberate Problem Solving with Large Language Models (NeurIPS 2023). 用前瞻与回溯探索中间推理状态;引用它,是因为它是「完成之前分支」最早的规范案例。 https://arxiv.org/abs/2305.10601

  2. Besta et al. — Graph of Thoughts: Solving Elaborate Problems with Large Language Models (AAAI 2024; preprint 2023). 把树结构推理推广为图操作,包括中间状态的聚合与复用;引用它,是因为第 10 节的状态合并讨论。 https://arxiv.org/abs/2308.09687

  3. Choudhury — Process Reward Models for LLM Agents: Practical Framework and Directions (2025 preprint). 研究智能体过程奖励、探索、奖励塑形、测试时扩展与奖励作弊;引用它,是因为这个更宽的主张:中间评估是智能体搜索的一部分,而不只是终端打分。 https://arxiv.org/abs/2502.10325

  4. Xi et al. — AgentPRM: Process Reward Models for LLM Agents via Step-Wise Promise and Progress (2025 preprint). 通过目标邻近度与进度评估中间的智能体决定,并把得到的过程模型应用到逐步搜索;引用它,是因为第 7 节的 promise/progress 拆分。 https://arxiv.org/abs/2511.08325

  5. Lee et al. — Agentic Test-Time Scaling for WebAgents (2026 preprint). 发现均匀逐步采样的回报递减,并引入用投票熵与前二差距的置信感知分配;引用它,是因为第 8 节的自适应分配讨论。 https://arxiv.org/abs/2602.12276

  6. Hariri et al. — Test-Time Scaling in Reasoning LLMs: Inference Regimes, Evaluation, and Reproducibility (2026 preprint). 区分顺序、叶级与前缀级推理,并主张完整的推理协议才是被评估的系统;引用它,是因为那张机制表与协议记录。 https://arxiv.org/abs/2608.04001


下一章:证据与验证

搜索产出一条偏好的轨迹。偏好不是验证。

用来给那条轨迹排序的信号,可能已经包含有价值的外部信息:测试结果、环境观察、确定性检查、独立工具或权威来源。这些信号能证明在一个分支上比另一个分支花更多计算是合理的,也能证明一旦一个未来明显压过其备选项就停止搜索是合理的。

它们不自动确立用户的目标。部分状态评估器回答的是哪个未来当前值得继续或承诺。最终验证问的是一个不同的问题:什么证据足以把结果世界记录为确实满足目标?

混淆这些问题代价高昂,因为评估器可以相对其竞争者正确排序一个分支,而每个分支仍然失败于任务。

下一章让那道最终边界显式。它分开完成提案、评估器分数、运行时观察与面向目标的证据,然后问:在运行时配得上有权记录成功之前,必须先确立什么——包括当验证机制本身不完整、过期或遭到攻击时会发生什么。