← Agents From First Principles

运行时状态、进度与终止

给智能体运行时一份显式记录,记录执行已经确立了什么:观察被归约为结构化状态,进度被度量为状态之间的关系,循环与停滞被机械地检测,终止报告一个具名理由而不是耗尽一个计数器。

计划是关于未来的断言。它说:复现失败,然后诊断,然后打补丁,然后测试,是一条从这里通往一个可工作系统的路线。把这个断言显式化,使那套机器物有所值。但它写在任何工作发生之前,执行可能几乎立刻就作废它的某个假设。

执行产出的是完全不同的东西:一条轨迹。动作出去,观察回来,而回来的东西里有些可能与预期路线矛盾。补丁步骤因为缺少依赖而失败。测试步骤不只是迟到;它根本无法到达。

无法表示这个区别的运行时,没有途径注意到它规划的未来与它实际到达的状态已经分叉,因而也没有原则性的方式决定接下来该发生什么。

本章要关闭的就是这个缺口。

只有当运行时能判断轨迹是否在取得进展、并能以一个具名的理由停下时,智能体循环才是可靠的。

动作边界问的是:在那一刻存在的策略与上下文之下,一个被提案的动作是否可以跨入执行。

这里的问题是时间性的、累积性的:给定到目前为止的轨迹、它已产生的进度、以及已经花掉的资源,运行时还应该允许再尝试一次吗?


1. 停不下来的循环

几乎每个智能体一开始都是这个形状:

while True:
    action = decide(observation)
    observation = execute(action)

它是一个循环,但它还不是一个运行时。

这里没有对以下东西的表示:当前什么是真的、已经试过什么、有没有任何改善、还剩什么、已经花掉了什么,以及这次运行为什么应该结束。最后一行的含义是永远重复下去,除非模型碰巧另有决定,这把对该决定的权威交给了模型,而模型并不适合做这个决定。

想一想,当模型被要求继续时,一台恰当地装了仪表的软件能知道什么:十七个动作已经执行,其中四个是完全相同地被提案的;没有任何必需的产物发生改变;三次工具调用以同一个错误码失败;四十二秒和 $1.37 已经消失了。

这些都不需要语言判断。它们是运行时能直接记录、并与显式阈值比较的执行测量。

让模型从一段对话记录重建它们,是把核算变成解释。

这是一笔坏交易,本章余下的部分讲的就是不做这笔交易。


2. 运行时状态不是对话记录

状态的第一个实现几乎总是消息列表:

messages = [
    {"role": "user", "content": task},
    {"role": "assistant", "content": response},
]

这是有用的模型上下文,却是一份糟糕的记录系统。

除非重新阅读散文并指望答案就在里面,运行时无法询问它失败的测试是否已被复现、目标文件是否已改变。运行时需要的是一份可以直接查询的结构化工作记录,其键对应于它正在执行的计划:

from dataclasses import dataclass, field

@dataclass
class RunState:
    goal: str
    requirements: "Requirements"
    completed: set[str] = field(default_factory=set)   # PlanStep ids
    failed: set[str] = field(default_factory=set)
    facts: dict[str, object] = field(default_factory=dict)
    artifacts: set[str] = field(default_factory=set)
    trace: list["Transition"] = field(default_factory=list)
    blocked_attempts: set[str] = field(default_factory=set)
    model_calls: int = 0
    cost: float = 0.0
    recoveries: int = 0
    stop_reason: "StopReason | None" = None

    @property
    def step(self) -> int:
        return len(self.trace)

    @property
    def steps_after_last_progress(self) -> int:
        for i, transition in enumerate(reversed(self.trace), start=1):
            if transition.progress.productive:
                return i - 1
        return len(self.trace)

completed 与 failed 保存的是 PlanStep 标识符,因此上一章构建的计划与本章构建的状态指向同一批对象。

这就是两个能互相组合的机制与两个只是共存的机制之间的差别。

状态这个词还需要一个提醒。RunState 不是现实本身。它是运行时对执行到目前为止已经确立了什么的显式工作表示。它的质量取决于更新它的观察与归约器。这个优势不是全知;而是与控制相关的事实不再需要每一轮都从散文里重建。

已发表于 ICLR 2025 的 ActionReasoningBench 版本,在八个规划域上评估关于动作与变化的推理,动作序列最长十九步。尽管把相关的动作序列给了模型,它报告状态追踪的平均准确率 65.63%、动作可执行性的 58.73%。[2] 它还发现:序列变长时的退化、对动作并不改变的属性的持续困难,以及否定 fluents 上的系统性劣势。

这些发现并不证明某一个特定的 RunState 设计是正确的。它们确实确立了那个工程问题:让模型从不断增长的历史里反复重建演化的与不演化的事实,本身就是一次可错的计算。

运行时确立过一次的事实,可以保持显式,直到某个观察改变或撤回它。

同样,"dependency_install_failed" 可以继续被表示为一条否定的执行事实,而不是指望模型记住某句说早先尝试没成功的话。

什么应该在这次运行之外幸存——一个系统跨任务、跨星期、跨用户记住什么——这个更大的问题属于记忆那一章。

这里我们只需要一次执行的工作状态。


3. 状态来自观察,不是叙述

假设智能体运行一个聚焦的测试套件,环境返回 3 failed, 12 passed。一个弱的运行时会让模型去总结它,然后把总结当作真相。

更强的运行时先记录观察,再通过一个显式的归约器从中导出状态。

动作边界已经给了我们观察类型 Observation(ok, kind, data)。本章添加的是把一个被接受的动作及其观察关联到当前状态的归约器,以及保留这个序列的轨迹:

@dataclass(frozen=True)
class Transition:
    step: int
    fingerprint: str          # action identity, used for cycle detection
    attempt_key: str          # state + action identity, used for recovery
    action: dict
    observation: Observation
    progress: "Progress"

动作与观察交错的轨迹不是新想法;ReAct 让这个模式成为现代 LLM 智能体交互的中心。[1] 这里改变的是:它不再只是一个提示模式,而变成运行时所拥有的数据,带着一个显式类型、一个索引和一条仅追加的纪律。

快照与轨迹回答不同的问题。快照回答现在什么被表示为真:三个测试正在失败。轨迹回答我们是怎么到这里的:第 4 步七次失败,第 8 步三次,第 12 步三次,第 16 步三次。只有快照无法区分一个难问题和一个卡住的问题;序列可以。

    flowchart LR
    A[动作] --> E[环境]
    E --> O["Observation<br/>ok, kind, data"]
    O --> R["归约<br/>state + action + observation"]
    R --> S["RunState<br/>facts, artifacts, completed"]
    R --> T["轨迹<br/>仅追加的 Transition"]
    S --> V["model_view<br/>投影"]
    T --> V
  

模型仍可能帮助解释一个含糊的观察,比如一段陌生的堆栈跟踪,或一个意义取决于上下文的警告。

它不可以是执行事实唯一存在的地方。如果一个事实重要到能决定另一个动作能否运行,它就应该有一个显式的运行时表示。


4. 进度是状态之间的关系,不是活动

一个智能体可以搜索、阅读、编辑、运行、再搜索、再编辑二十步而没有任何移动。每一步都产出输出、消耗预算、在日志里显得有目的。这些都不必然是进度,因为进度不是动作的属性。

它是动作所处的那对状态的属性。

什么算移动是领域特定的,把它说得具体比抽象地定义它更有用:

任务 进度 与之相似的活动
代码修复 失败测试 8 → 3 打开了另一个文件,又写了一个 diff
研究 获支持的主张 4/9 → 7/9 又访问了一个 URL,草稿更长了
浏览器任务 必填字段 2/6 → 5/6 又加载了一个页面,又点了一下

诱人的实现是一个浮点数:after.score - before.score。有时那足够了。更多时候任务有好几个互相权衡的维度,过早把它们坍缩掉,恰恰毁掉决定下一步所需的信息。修好两个测试同时引入一个回归的运行,与干净地修好两个测试的运行不是一回事。

@dataclass(frozen=True)
class Progress:
    task_delta: float
    evidence_delta: float = 0.0
    regression_delta: float = 0.0
    integrity_ok: bool = True
    measurement_ok: bool = True

    @property
    def productive(self) -> bool:
        if not self.measurement_ok or not self.integrity_ok:
            return False

        no_tracked_dimension_worsened = (
            self.task_delta >= 0
            and self.evidence_delta >= 0
            and self.regression_delta <= 0
        )
        something_improved = (
            self.task_delta > 0
            or self.evidence_delta > 0
        )

        return no_tracked_dimension_worsened and something_improved

evidence_delta 指收窄不确定性或解锁一个有正当理由的下一步的任务相关证据,而不只是更多日志或更多文本。保守的 productive 规则要求至少一个被追踪维度改善,且没有另一个被追踪维度恶化。regression_delta 单独让显式损害保持可见,而不是允许别处的表面收益把它藏起来。

真正允许权衡的领域,可以在同样的结构化增量之上定义不同的策略。要点是:权衡保持显式,而不是消失在一个标量分数里面。

measurement_ok 同样重要。如果运行时缺少度量进度所需的事实,那与度量出零进度不是一回事。控制器应该保留这个区别,而不是把缺失的仪表变成一次停滞。

如果真有东西需要标量,稍后仍可以导出一个。对循环控制来说,结构化信号更有用。


5. 没有完整性约束的进度信号就是一个靶子

把进度定义为失败测试数减少,那么下面这样看起来极好:

8 个失败 → 0 个失败

直到你发现智能体删掉了测试文件。

把它定义为访问过的 URL,一个研究智能体就可以无限改进却什么也没有回答。这就是古德哈特定律如约而至:当策略能在不保全我们真正在乎的性质的情况下优化代理时,一个有用的代理就变得危险。

解法不只是一个更好的指标。它是指标加上让指标保持有意义的约束,并且被放在一起评估。

def measure_repair(before: RunState, after: RunState, obs: Observation) -> Progress:
    failing_before = before.facts.get("tests_failing")
    failing_after = after.facts.get("tests_failing")
    required = after.facts.get("required_tests")
    present = after.facts.get("tests_present")
    new_failures = after.facts.get("new_failures")

    if any(
        value is None
        for value in (
            failing_before,
            failing_after,
            required,
            present,
            new_failures,
        )
    ):
        return Progress(task_delta=0.0, measurement_ok=False)

    return Progress(
        task_delta=float(failing_before) - float(failing_after),
        regression_delta=float(new_failures),
        integrity_ok=set(required) <= set(present),
    )

把缺失的测试计数默认为零、把缺失的必需测试集默认为空,是方便的代码、危险的测量:仪表的缺席可以伪装成成功。在这里,缺失的输入让进度测量被显式地判定为不可用。

当必需测试确实不存在时,integrity_ok 阻止一次表面的 8 → 0 改进变成有成效的进度。

同样的形状适用于别处:主张的覆盖率可以上升而引用支持在下降;完成的字段可以变多而一个先前有效的字段被覆盖;延迟可以下降,因为一个必需的检查被跳过了。

确立成功真的发生了是个更大的问题,它有自己的一章。本章需要的是从这个结构推出的警告:

每一次继续与停止的决定,都继承它所消费的那个进度信号的可信度。


6. 重复、循环与停滞

相同的动作容易识别。对结构化提案取指纹:

import hashlib
import json

def fingerprint(action: dict) -> str:
    payload = json.dumps(action, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(payload.encode()).hexdigest()[:16]

def attempt_key(state_key: str, action: dict) -> str:
    payload = f"{state_key}:{fingerprint(action)}"
    return hashlib.sha256(payload.encode()).hexdigest()[:16]

两个指纹刻意回答不同的问题。

fingerprint(action) 问的是同一个动作形状是否在反复出现,这对循环检测有用。

attempt_key(state_key, action) 问的是运行时是否从实质上相同的状态尝试同一个动作。这个区别在恢复期间变得重要:RUN_TESTS 在代码修改之前可能是无用的重复,在修改之后却恰好是正确的动作。

应用提供 state_key,因为什么让两个状态实质等价是领域特定的。对编码任务来说,它可能包含当前 diff 哈希、失败测试集与相关的计划位置。它应该排除那些改变了却不改变问题的记账项——模型调用计数、已花成本、恢复次数——否则每次重试都会显得新颖。一个忽略控制相关状态的键,会让恢复过度阻止或阻止不足。

抓住重复不等于因为重复而停下。很多工具本来就该被反复调用,比如 poll_build_status、scroll_down 和 read_next_page。

只有与缺乏进度配对时,重复才是循环的证据。

更难的情形是:真实的循环很少是 A → A → A。它们是 A → B → A → B,或者 edit → test → inspect 连做三遍——而这恰恰也可能是有成效的迭代工作看起来的样子。

    flowchart TD
    C["edit → test → edit → test"] --> Q{"循环里是否有<br/>有成效的转换?"}
    Q -- yes --> W["迭代工作<br/>继续"]
    Q -- no --> L["无成效循环<br/>停止或恢复"]
  

这个区别可以直接实现:

def repeating_cycle(trace: list[Transition], max_period: int = 2) -> int | None:
    """Period of a repeating action pattern in the tail of the trace, if any."""
    marks = [t.fingerprint for t in trace]

    for period in range(1, max_period + 1):
        window = period * 2
        if len(marks) < window:
            return None

        tail = marks[-window:]
        if all(tail[i] == tail[i % period] for i in range(window)):
            return period

    return None

def nonproductive_cycle(state: RunState, max_period: int = 2) -> bool:
    period = repeating_cycle(state.trace, max_period)
    if period is None:
        return False

    repeated_tail = state.trace[-period * 2:]
    return not any(t.progress.productive for t in repeated_tail)

周期 1 恢复相同动作的情形。周期 2 抓住朴素检查漏掉的 A → B → A → B 振荡。

停滞需要不同的测量,因为停滞根本不涉及重复:每个动作都可以是独一无二且无关的。RunState.steps_after_last_progress 属性回溯到最后一次有成效的转换。

def stalled(state: RunState, patience: int) -> bool:
    return state.steps_after_last_progress >= patience

这把智能体似乎卡住了变成五次连续执行的转换没有产出任务进度、也没有产出有用的新证据。这是一句运行时可以记录、可以测试、可以用作策略的陈述。


7. 继续策略

状态与进度让继续成为一个有归属的显式决策。模型可以提案继续、结束、重试或重新规划。

运行时来决定,用的是动作章建立的同一道边界:一边是提案,另一边是权威。

    flowchart TD
    P["模型提案"] --> V{"要求完成<br/>且经外部确认?"}
    V -- yes --> S["停止:SUCCESS"]
    V -- no --> M{"进度信号<br/>可用?"}
    M -- no --> U["停止:PROGRESS_UNAVAILABLE"]
    M -- yes --> B{"预算剩余?"}
    B -- no --> X["停止:预算理由"]
    B -- yes --> C{"无成效循环<br/>或停滞?"}
    C -- no --> G["继续"]
    C -- yes --> R{"有安全恢复<br/>可用?"}
    R -- yes --> RW["恢复并换一种方式重试"]
    R -- no --> E["停止:RECOVERY_EXHAUSTED"]

    classDef model fill:#e8f0fe,stroke:#4285f4
    classDef runtime fill:#fef7e0,stroke:#f9ab00
    class P model
    class V,M,B,C,R,S,U,X,G,RW,E runtime
  

每个有界的片段都需要一个外部上限,而一个计数器不够,因为一步不是任何东西的单位。这一步读一个文件;下一步跑一个二十分钟的集成测试套件。

约束真正会耗尽的资源:

@dataclass(frozen=True)
class Budget:
    max_steps: int = 12
    max_model_calls: int = 20
    max_seconds: float = 90.0
    max_cost: float = 1.00
    max_recoveries: int = 2
    no_progress_patience: int = 5
    max_cycle_period: int = 2

    def __post_init__(self) -> None:
        if self.max_cycle_period < 1:
            raise ValueError("max_cycle_period must be at least 1")

        if self.no_progress_patience < 2 * self.max_cycle_period:
            raise ValueError(
                "no_progress_patience must be at least twice max_cycle_period "
                "so the requested cycle can become observable before a plateau stop"
            )

最后两个值是耦合的。检测周期 2 的循环需要四次转换;如果耐心值是 3,停滞检查可能在振荡变得可观察之前就触发。耐心值取 4 是充分的,因为 _stop_reason() 在同一次转换上先检查无成效循环、再检查停滞。

这个关系由策略对象强制执行,而不是作为建议留下。

预算不是质量度量。它定义控制器愿意在一个片段之内授权的资源。控制器可以在操作之间精确地执行某些上限,但一个操作内部的硬上限需要执行它的组件配合。九十秒的运行时预算不会打断一个无视取消二十分钟的工具,一次调用后的成本报告也无法撤销已经发生的花费。provider 超时、token 上限、工具截止期限等更低层的控制,因而是执行同一策略的一部分。

General AgentBench 提供了有用的当代证据,说明应该对序列化视野保持审视:性能起初会随额外交互改善,但一旦累积历史越过一个取决于模型与领域的上下文天花板,就会停滞或退化。[3]

更多步并不可靠地换来更多能力,因此宽松的步数预算并不自动更安全。

当一次运行结束时,理由是数据:

from enum import StrEnum

class StopReason(StrEnum):
    SUCCESS = "success"
    MAX_STEPS = "max_steps"
    MAX_MODEL_CALLS = "max_model_calls"
    TIME_BUDGET = "time_budget"
    COST_BUDGET = "cost_budget"
    NO_PROGRESS = "no_progress"
    NONPRODUCTIVE_CYCLE = "nonproductive_cycle"
    PROGRESS_UNAVAILABLE = "progress_unavailable"
    RECOVERY_EXHAUSTED = "recovery_exhausted"
    USER_INPUT_REQUIRED = "user_input_required"
    UNRECOVERABLE_ERROR = "unrecoverable_error"

把它们坍缩成智能体失败了,扔掉的是这次运行产出的最有行动价值的东西:

类别 理由 它是什么意思 典型的下一个归属方
成功 SUCCESS 经外部确认的完成 无人
输入或环境受阻 USER_INPUT_REQUIRED, UNRECOVERABLE_ERROR 继续需要当前运行时无法安全提供的东西 用户、操作者或环境
策略受限 MAX_STEPS, TIME_BUDGET, COST_BUDGET, MAX_MODEL_CALLS 运行撞上了我们选择的上限 操作者
测量失败 PROGRESS_UNAVAILABLE 继续策略失去了可信的进度信号 运行时或仪表
停滞 NO_PROGRESS, NONPRODUCTIVE_CYCLE, RECOVERY_EXHAUSTED 当前策略没有产生足够的改变 智能体设计或恢复策略

有一个提案值得特别怀疑。当模型发出 {"action": "finish"} 时,那是一个关于世界的断言,由输出正被评估的那个组件做出。仅凭那个断言就设置 status = SUCCEEDED,会让生产者成为自己产品的唯一裁判。

运行时改为检查自己的完成要求,并调用一道外部确认接缝。被拒绝的 finish 仍然消耗产生它的模型用量,因此反复的过早 finish 提案最终会撞上策略上限,而不是免费空转。


8. 恢复必须改变点什么

重试是在实质相同的条件下重复一次尝试。

恢复改变的是一个有可能改变结果的条件:不同的参数、一个不同的工具、一份修订过的计划、一个被恢复的环境、一段全新的模型上下文,或者升级给用户。这个区别重要,因为一个检测到无进度、却以重新规划进同一份计划作响应的运行时——那份计划提案同一个动作、以同样的方式失败——只是把循环上移了一层。

重试还取决于运行时是否知道发生了什么。一次超时的响应不能证明那个被尝试的副作用从未发生。真正幂等的操作可以在其能力契约所声明的条件下重复。一次模糊的执行结果之后,非幂等的变更不应该被盲目重试;运行时应先通过回执、事务标识、幂等键或直接状态检查与环境核对。能力章会把幂等性变成显式的。眼下这条规则就够了:未能观察到成功,不是执行没有发生的证据。

对长运行还有第二个问题。一个糟糕的早期动作既改变模型的上下文也改变环境,而之后的前进动作可能无法重建那个错误发生前才存在的状态。

作为 2026 年预印本发布的 AgentRewind 正是围绕这个恢复问题构建的。它记录智能体上下文与受控环境状态的对齐检查点,使执行可以回到一个更早的状态,并带着从被放弃的尝试中学到的信息继续下去。[5] 对齐这个词是实质所在。

恢复运行时状态却不恢复相应的环境,或恢复环境却不恢复描述它的运行时状态,会创造出一个从未存在过的组合。

因此检查点接口必须同时表示两侧:

from copy import deepcopy
from typing import Callable

@dataclass(frozen=True)
class Checkpoint:
    label: str
    step: int
    state: RunState
    environment_token: object

class RecoveryError(RuntimeError):
    pass

def rewind(
    cp: Checkpoint,
    current: RunState,
    restore_environment: Callable[[object], bool],
) -> RunState:
    if not restore_environment(cp.environment_token):
        raise RecoveryError("environment checkpoint could not be restored safely")

    revived = deepcopy(cp.state)

    # Usage and recovery counters describe the whole episode, not the branch.
    revived.model_calls = current.model_calls
    revived.cost = current.cost
    revived.recoveries = current.recoveries + 1

    # Block only the exact state+action attempts abandoned on this branch.
    revived.blocked_attempts = current.blocked_attempts | {
        transition.attempt_key
        for transition in current.trace[cp.step:]
    }

    return revived

检查点对象必须包含一份快照,而不是对 RunState 的活引用;take_checkpoint 实现在截取相应的环境令牌时应该深拷贝该状态。

三个计数器刻意不回退。模型调用、成本与恢复尝试,即使分支后来被放弃也已经花掉了。恢复它们会让恢复变成抹掉自己预算消耗的手段。

被阻止的集合现在是状态感知的。早先的实现把原始动作指纹向前携带,这太粗了:补丁之前无用的测试命令,补丁之后可能恰好是正确的命令。改为阻止 attempt_key,就只拒绝来自实质相同运行时状态的动作。

这种安全取决于应用定义的状态键是有意义的。如果键漏掉了那个让动作值得重试的状态变化,运行时会过度阻止。如果它因为无关的理由变化,它会阻止不足。

不可逆的副作用仍是一道硬边界。检查点不能撤回一封已经发出的邮件、撤销一笔已经扣掉的款,或者撤销一次已经合并的分支,除非周围环境提供真正的补偿或恢复机制。restore_environment 必须拒绝,而不是假装可以。

    flowchart LR
    CP["对齐的检查点<br/>运行时 + 环境"] --> S1["尝试 A"]
    S1 --> S2["尝试 B"]
    S2 -.->|无进度| R["恢复检查点"]
    S1 -.-> K["被阻止的尝试键"]
    S2 -.-> K
    K -.-> R
    R --> ALT["不同的尝试"]
  

在有意义、可安全恢复的进展时刻截取检查点,而不是在盲目的步数计数器上截取。

在停滞中截取的检查点,会把运行时恢复到一个已经停滞的状态。无法恢复相应环境的检查点,不是控制器可以安全使用的检查点。


9. 表示尚未走完的距离

对长任务来说,二值成功太粗了。

一个十项要求的工程任务,满足八项然后失败,会被记为“失败”,丢掉了工作已完成百分之八十、以及具体哪百分之二十没有完成这个事实。

@dataclass(frozen=True)
class Requirements:
    ids: frozenset[str]
    satisfied: frozenset[str] = frozenset()

    @property
    def remaining(self) -> int:
        return len(self.ids - self.satisfied)

    @property
    def complete(self) -> bool:
        return self.ids <= self.satisfied

Requirements.satisfied 记录的是运行时确立的完成,不是模型的声明。更新它需要一次确立相应要求的观察或检查,通常通过替换 RunState 中那个不可变的 Requirements 值来完成。模型说完成,并不能自己把一个条目从剩余移到已满足。

长视野基准已经收敛到保留部分完成的价值,而不只是一个终止位。Odysseys 评估 200 个真实的长视野 Web 任务,为每个任务标注平均 6.1 条分级评分细则,报告其与人类判断的一致性优于轨迹级 LLM 评审。[4] 与 AgentRewind 一同推出的 MettleBench,同样在任务完成之外,对长工程作业上的部分清单进度打分。[5]

Odysseys 还加了一个值得直接借用的度量。轨迹效率是每一步的评分细则分数,即进度除以取得它的成本;前沿智能体在这上面只达到 1.15%,而成功率为 44.5%。[4]

这两个数字之间的差距,用一次比较抓住了本章的论点:终点成功可以与非常低效的轨迹共存。只度量任务最终是否成功的运行时,看不见为了取得那次成功花了多少交互。


10. 模型看到的是一个投影

运行时可以保留一条大轨迹和一个丰富的状态对象。模型两者都不需要全部,而关于序列化智能体的当代证据,让我们有理由对把累积历史无限地喂回去保持谨慎。[3]

在运行时状态与模型上下文之间,坐着一个投影:

def model_view(
    state: RunState,
    fact_keys: frozenset[str],
    window: int = 4,
) -> dict:
    return {
        "goal": state.goal,
        "step": state.step,
        "remaining": state.requirements.remaining,
        "completed": sorted(state.completed),
        "failed": sorted(state.failed),
        "facts": {
            key: state.facts[key]
            for key in fact_keys
            if key in state.facts
        },
        "recent": [
            {
                "action": t.action,
                "ok": t.observation.ok,
                "kind": t.observation.kind,
                "productive": t.progress.productive,
            }
            for t in state.trace[-window:]
        ],
    }

重要的改变是:连 facts 都是投影的。一个字典可以是结构化的,同时仍然巨大、无关,或者不适合发给模型。应用显式地点出与控制相关的事实键。

completed 与 failed 保留执行事实,模型不必从一段长对话记录里重新发现它们。productive 是运行时已经从前后进度信号算出的判断;它应该作为那个判断来呈现,而不是作为一条独立观察到的事实。最近的转换提供局部上下文,而完整的轨迹仍可供调试、评估与恢复使用,不会自动变成推理上下文。

这种分工是刻意的:

运行时保留必须保持可检视、正确的东西
        ↓
投影挑选这次决策所需要的东西
        ↓
模型只收到那个工作视图

投影仍然可能设计得很糟。太少的上下文会藏起必需的事实;太多则重新制造对话记录问题。这让投影本身成为一个值得测试的组件,而不是把状态整个倒出来的借口。


11. 循环控制器

以上的一切组装成一个控制器。应用提供真正应用特定的部分:如何决策、如何执行、观察如何归约为状态、进度如何度量、什么算经外部确认的完成、什么状态差异对恢复重要,以及受控环境如何被截取检查点。

控制器拥有继续策略与核算。

只有组件报告它们消耗的资源,预算才有效,因此用量是显式的:

from dataclasses import dataclass
from time import monotonic
from typing import Callable

@dataclass(frozen=True)
class Usage:
    model_calls: int = 0
    cost: float = 0.0

@dataclass(frozen=True)
class DecisionResult:
    action: dict
    usage: Usage = Usage(model_calls=1)

@dataclass(frozen=True)
class ExecutionResult:
    observation: Observation
    usage: Usage = Usage()

def account(state: RunState, usage: Usage) -> None:
    state.model_calls += usage.model_calls
    state.cost += usage.cost

这很重要,因为早先的控制器自己递增 model_calls 却从不更新 cost,让 max_cost 成为一个背后没有机制的策略字段。返回用量也让工具实现得以报告嵌套的模型调用——如果执行本身使用模型的话。

循环于是变成:

_RECOVERABLE = frozenset({
    StopReason.NO_PROGRESS,
    StopReason.NONPRODUCTIVE_CYCLE,
})

@dataclass
class AgentLoop:
    decide: Callable[[dict], DecisionResult]
    execute: Callable[[dict], ExecutionResult]
    reduce: Callable[[RunState, dict, Observation], None]
    measure: Callable[[RunState, RunState, Observation], Progress]
    verified: Callable[[RunState], bool]
    take_checkpoint: Callable[[RunState], Checkpoint | None]
    restore_environment: Callable[[object], bool]
    state_key: Callable[[RunState], str]
    model_fact_keys: frozenset[str]
    budget: Budget

    def run(self, goal: str, requirements: Requirements) -> RunState:
        state = RunState(goal=goal, requirements=requirements)
        checkpoint = self.take_checkpoint(state)
        started = monotonic()

        while True:
            reason = self._stop_reason(state, started)

            if reason in _RECOVERABLE and checkpoint is not None:
                if state.recoveries < self.budget.max_recoveries:
                    try:
                        state = rewind(
                            checkpoint,
                            state,
                            self.restore_environment,
                        )
                    except RecoveryError:
                        state.stop_reason = StopReason.UNRECOVERABLE_ERROR
                        return state
                    continue

                reason = StopReason.RECOVERY_EXHAUSTED

            if reason is not None:
                state.stop_reason = reason
                return state

            decision = self.decide(
                model_view(
                    state,
                    fact_keys=self.model_fact_keys,
                )
            )
            account(state, decision.usage)

            resource_reason = self._resource_stop_reason(state, started)
            if resource_reason is not None:
                state.stop_reason = resource_reason
                return state

            action = decision.action

            if action.get("name") == "finish":
                if state.requirements.complete and self.verified(state):
                    state.stop_reason = StopReason.SUCCESS
                    return state
                continue

            mark = fingerprint(action)
            key = attempt_key(self.state_key(state), action)

            if key in state.blocked_attempts:
                continue

            before = deepcopy(state)

            execution = self.execute(action)
            account(state, execution.usage)
            observation = execution.observation

            self.reduce(state, action, observation)
            progress = self.measure(before, state, observation)

            state.trace.append(
                Transition(
                    step=state.step,
                    fingerprint=mark,
                    attempt_key=key,
                    action=action,
                    observation=observation,
                    progress=progress,
                )
            )

            if progress.productive:
                checkpoint = self.take_checkpoint(state) or checkpoint

    def _resource_stop_reason(
        self,
        state: RunState,
        started: float,
    ) -> StopReason | None:
        b = self.budget

        if state.step >= b.max_steps:
            return StopReason.MAX_STEPS
        if state.model_calls >= b.max_model_calls:
            return StopReason.MAX_MODEL_CALLS
        if state.cost >= b.max_cost:
            return StopReason.COST_BUDGET
        if monotonic() - started >= b.max_seconds:
            return StopReason.TIME_BUDGET

        return None

    def _stop_reason(
        self,
        state: RunState,
        started: float,
    ) -> StopReason | None:
        if state.requirements.complete and self.verified(state):
            return StopReason.SUCCESS

        resource_reason = self._resource_stop_reason(state, started)
        if resource_reason is not None:
            return resource_reason

        if state.trace and not state.trace[-1].progress.measurement_ok:
            return StopReason.PROGRESS_UNAVAILABLE

        if nonproductive_cycle(state, b.max_cycle_period):
            return StopReason.NONPRODUCTIVE_CYCLE
        if stalled(state, b.no_progress_patience):
            return StopReason.NO_PROGRESS

        return None

几个细节是承重的。

measure 同时收到不可变的 before 快照与被改动后的 after 状态,因此进度是真正关系性的。

reduce 除了观察还收到动作,因此状态转换不必从藏在观察里面的散文中恢复被尝试动作的身份。

Usage 让成本与嵌套模型调用成为运行时核算接口的一部分,而不是控制器希望某人去递增的副作用。控制器在决策之后、在授予提案动作执行权威之前,重新检查这些预算。

执行时的用量必然不同。如果工具或模型辅助的能力只在完成之后报告其成本,控制器可以核算这笔花费,却无法追溯性地阻止它。因此每次调用的硬上限属于能力或 provider 边界;片段级核算属于这里。

被阻止的恢复尝试以状态加动作作为键,而循环检测继续使用动作指纹。因此这两个机制不再把同一个动作与同一次尝试混为一谈。

最后,started 不因回退而重置。挂钟时间无论分支后来是否被放弃,都已经花掉了。

有一道边界刻意保持不完整:verified 仍只是一道接缝。如果验证本身昂贵或带有概率性,它的尝试与预算也必须被核算。后面的验证章拥有那个策略。

这个循环不再是一个碰巧会重复的提示。

它是带具名状态、具名出口、显式核算,以及一套可测试的继续策略的软件。


12. 把循环控制当作独立子系统来测试

循环控制的 bug 默认在生产环境里被发现,因为触发它们的条件罕见、昂贵且非确定。它们不必如此。

以上每个分支都可以用脚本化的决策、观察、用量与进度在毫秒之内强制走出来,循环里没有任何活的模型或工具。

情形 强制方式 预期结果
A search(X), search(X), 相同结果 NONPRODUCTIVE_CYCLE,周期 1,在第 2 步
B edit, test, edit, test, 失败数下降 无循环停止;一直运行到 MAX_STEPS
C edit, test, edit, test, 什么都没变 NONPRODUCTIVE_CYCLE,周期 2,在第 4 步
D 全部唯一的动作,进度 +1, +1, 0, 0, 0, 0, 0 NO_PROGRESS
E 外部确认为假时提案 finish 被拒绝;已执行步数保持不变而模型用量上升
F 每个执行的动作都唯一且有成效 MAX_STEPS
G 测试被删除,失败计数从 8 降到 0 productive 为假;integrity_ok 为假
H 每次安全回退后都是新的无成效尝试 RECOVERY_EXHAUSTED
I 回退后提案了相同的 state+action 尝试 被 blocked_attempts 拒绝;最终一个资源上限停止这次运行
J 有意义的状态变化之后提案相同的动作 被允许,因为 attempt_key 变了
K 运行时状态中缺少进度输入 PROGRESS_UNAVAILABLE,而非 NO_PROGRESS
L 环境快照无法被安全恢复 UNRECOVERABLE_ERROR

B 与 C 是对循环检测最重要的那一对,因为它们包含相同的动作模式,却必须产出相反的决定。任何通过一个、失败另一个的检测器,度量的是重复,而不是无成效的重复。

I 与 J 是恢复对应的那一对。一张原始的动作黑名单无法同时满足两者:它要么允许完全相同的失败尝试再次发生,要么在世界已经改变之后阻止一次合法的重试。把它们分开的是状态感知的尝试身份。

K 保护进度机器免于一种更安静的失败。缺失的仪表应该以缺失的仪表的身份停下,而不是静默地变成五步表面上的无进展。

L 保护检查点抽象本身。一个无法恢复它声称要回退的环境的运行时,必须拒绝恢复,而不是捏造一个从未存在过的状态。


13. 度量那些你不该做出的停止

停止策略可以像过于宽松一样容易过于激进,而激进的失败更难看见:运行终止,日志记录 NO_PROGRESS,没有人发现再多一次有正当理由的步骤本可以完成任务。

两个方向都需要度量。

把同一个任务集跑过一列运行时阶梯,每级增加一个机制:

运行时 状态 预算 循环检测 进度 恢复
A 对话记录 否 否 否 否
B 结构化 是 否 否 否
C 结构化 是 是 否 否
D 结构化 是 是 是 否
E 带检查点 是 是 是 是

记录已验证的成功、部分进度、假阳性停止、假阴性循环、模型与工具调用、挂钟时间、每个成功任务的成本,以及不成功运行的理由分布。消融比单一的英雄式配置更重要,因为它告诉你是哪个机制付了钱、哪个只是装饰。

steps_after_last_progress 在失败运行上尤其有用。如果最后一次有用的推进发生在第 5 步、运行停在第 28 步,那么在最后一次被度量的改善之后发生了二十三次执行的转换。这不能证明之后的每个动作都毫无价值,但它准确地告诉你该去检视轨迹的哪里。

继续策略读取的正是评估稍后分析的同一份进度结构,这让诊断保持连贯。它并不让指标自动正确。第 5 节已经确立了原因:策略可以优化一个弱的进度代理,而评估可以奖励同样的弱点。

因此,用控制器并不拥有的结果来度量它:

进度 / 停滞指标
        +
错误停止率
        +
已验证的任务成功
        +
完整性失败

当一段有用的进步结束之后,停止规则花得更少,同时没有切断本会赢得真实成功的轨迹时,这条停止规则就是好的。


14. 这买到了什么

现在有两个机制从相反的两端描述时间。计划描述打算做的未来工作;状态与轨迹描述实际发生的事。在它们之间坐着一个策略,它读取两者、加上最新观察、最近进度与剩余预算,并返回三个答案之一:继续、恢复,或带一个理由停下。

智能体因此而更有适应力,因为未来行为现在依赖执行期间累积的证据,而不只是依赖一条写在那些证据存在之前的路线。而且——并非巧合——它作为软件也普通得多:具名类型、一条仅追加的轨迹纪律、一个归约器、显式核算,以及一套带测试套件的继续策略。

能力的增长,是以神秘感的减少到来的。

有三条边界是刻意的、值得说出来,因为一章吞并它的邻居,最后会变成关于一切。这里的轨迹是局部执行历史,不是记忆:没有东西在这次运行之后幸存,而决定什么应该幸存是另一个问题。verified 是一道接缝,不是一个验证器:运行时坚持由某个外部东西确认成功,而对什么样的证据才充分保持沉默。而动作面仍然是被假定的,不是被设计的。

最后那个是更紧迫的缺口。

本章的每个机制都作用于运行时收到的动作;如果可用的动作是含糊的、重叠的、危险地宽泛的,或者描述得很糟糕,它们全都帮不上忙。一个对糟糕工具面有着出色控制的循环,会精确地、反复地失败,并且带着一个它说得出的理由。


研究渊源

本书是一次工程重构而非综述,下面的参考文献是经过选择的。它们在这里是为了把这些想法定位在文献之中、为具体的主张提供证据,而不是暗示某一篇论文定义了上面的架构。

  1. Yao et al. — ReAct: Synergizing Reasoning and Acting in Language Models (ICLR 2023). 把模型推理、动作与环境观察交错在一起——这个交互模式在本章被变成一条可检视的运行时轨迹,而不只是留在模型上下文里。 https://arxiv.org/abs/2210.03629

  2. Handa et al. — ActionReasoningBench: Reasoning about Actions with and without Ramification Constraints (ICLR 2025). 在最长十九个动作的序列上评估关于动作与变化的推理,包括状态追踪与动作可执行性;这里引用它,是因为随动作历史变长而观察到的退化,以及模型在静态属性与否定 fluents 上表现出的困难。 https://arxiv.org/abs/2406.04046

  3. Li et al. — Benchmark Test-Time Scaling of General LLM Agents (2026). General AgentBench 报告在序列化扩展下存在一个有效上下文天花板,越过它之后,额外的交互轮次带来不稳定而非改进;引用它是为了步数预算应该紧而不是宽这个主张。 https://arxiv.org/abs/2602.18998

  4. Jang et al. — Odysseys: Benchmarking Web Agents on Realistic Long Horizon Tasks (2026). 为 200 个长视野 Web 任务引入分级评分细则评估,以及每步评分细则分数的轨迹效率指标;所报告的 1.15% 效率对 44.5% 成功率,是度量轨迹而不只是终点的实证依据。 https://arxiv.org/abs/2604.24964

  5. Zhuang et al. — AgentRewind: Recoverable Execution for Long-Horizon LLM Agents (2026). 一个使用智能体上下文与受控环境状态之对齐检查点的运行时恢复框架;其 MettleBench 基准评估任务完成与部分清单进度,同时支撑这里使用的检查点边界与部分进度表示。 https://arxiv.org/abs/2608.14380


下一章:能力与路由

运行时现在能说出:目标是什么、计划了什么、提案了什么、执行了什么、环境返回了什么、它当前把什么表示为已确立、是否出现了被度量的进度、是否允许再走一步,以及这次运行为什么结束。它还说不出的是:智能体本来是否应该能够去尝试那些动作中的任何一个。

下一章设计动作面本身:一个智能体被允许做什么,以及这些能力应该如何被描述与分离,以便正确的那一个被可靠地选中。对时间的控制,让位给接口设计。