证据与验证
把成功的主张与证据分开:定义目标契约,把证据绑定到状态,保护一个最低证据门槛,并把验证器本身当作一个对抗性接口来对待。
智能体说:
完成。
那是一个主张。
它不是证据。
本书到目前为止的每个机制都让智能体更善于决定做什么,而它们没有一个确立用户的目标达成了。规划器能为错误的问题产出一份连贯的计划。工具可以返回退出码零而不产生预期效果。搜索可以在每个分支都错的时候选出得分最高的分支。记忆系统可以检索到一个完全相关、但在三月就不再为真的事实。
模型可以流利地叙述这一切,而现实纹丝不动。
因此最后一个机制是决定这一切挣到了什么的那个:
验证是智能体与「目标已达成」这个主张之间的一道证据与完整性边界。
那句话里有两个词在做不相等的工作量。证据是熟悉的那一半,大多数团队都做对过它的某个版本。完整性在一个智能体能对它被打分的环境采取行动时变得本质,因为问题不再只是检查是否通过。而是通过检查是否仍然要求做完了任务。
1. 四个看起来都像成功的层级
一个部署智能体运行 kubectl rollout restart deployment/api 并得到退出码零。
确立了什么?
那条命令被接受了。不是新 pod 就绪了、健康检查通过了、错误率回到了基线、被请求的版本确实是现在提供流量的那个,也不是沿途没有破坏任何受保护的约束。
四个不同的层级藏在「成功」这个词里面,混淆它们是大多数虚假完成的根。
| 层级 | 问题 | 证据来源 |
|---|---|---|
| 动作回执 | 工具调用完成了吗? | 工具自己的返回值 |
| 状态转换 | 相关的环境状态改变了吗? | 对环境的观察 |
| 目标满足 | 结果状态满足所要求的吗? | 目标契约,对照状态检查 |
| 评估完整性 | 那个结论是经由可信路径达到的吗? | 轨迹,以及它触碰过的东西 |
它们不可互换,而每一个都容易被错当成它下面那个。
一个成功的回执常常伴随一个失败的任务。一个真正正确的最终状态可以坐在一个无效的评估路径之上,这种情况下系统得到了正确答案,却没学到任何下次能依赖的东西。
没有缺失层的证据,不要把低层成功提升为高层成功。
架构已经指向这里。动作边界确立了:模型的输出是提案,而不是执行的权威。同样的贬低现在适用于运行的另一端:模型说「完成」是一个完成提案,运行时决定证据门槛是否被满足。
模型负责提出。运行时控制执行。环境提供观察。验证器决定那些观察支持什么证据,以及那些证据挣得了什么。
flowchart TD
G[用户目标] --> C[目标契约]
C --> A[智能体行动]
A --> E[环境改变]
E --> EV[证据收集]
EV --> B[状态绑定 + 完整性检查]
B --> AD[受保护的裁定]
AD --> V{"裁定"}
V -->|PASS| S[停止]
V -->|FAIL| R[诊断并恢复]
V -->|PARTIAL| P[继续追求剩余部分]
V -->|UNKNOWN| Q[收集证据或升级]
R --> A
P --> A
Q --> EV
2. 目标契约
验证器无法验证一个未定义的目标,而大多数目标以特定的方式欠定义:它们说出什么应当改变,却把什么必须不变留成隐式的。
加上分页,但不改变现有的响应 schema。
一个弱的智能体把它缩减为「分页可用」,丢掉了保留约束——而那才是请求里更难的一半。
修法是在任何工作开始之前,把目标表示为一个结构。
from collections.abc import Callable
from dataclasses import dataclass, replace
from enum import StrEnum
class CriterionKind(StrEnum):
CHANGE = "change" # something must become true
PRESERVE = "preserve" # something must remain true
FORBID = "forbid" # something must not become true
@dataclass(frozen=True)
class Criterion:
id: str
description: str
kind: CriterionKind
required: bool = True
@dataclass(frozen=True)
class GoalContract:
criteria: tuple[Criterion, ...]
revision: int = 0
def __post_init__(self) -> None:
ids = [criterion.id for criterion in self.criteria]
if len(ids) != len(set(ids)):
raise ValueError("criterion ids must be unique")
if not any(criterion.required for criterion in self.criteria):
raise ValueError(
"a goal contract must contain at least one required criterion"
)
@property
def required_ids(self) -> frozenset[str]:
return frozenset(
criterion.id
for criterion in self.criteria
if criterion.required
)
对分页请求来说,那变成一个关于分页的变更判据、关于响应 schema 与认证行为的保留判据,以及一个覆盖移除或绕过测试的禁止判据。成功现在意味着满足被请求的变更,同时保留让该变更可接受的那些约束。
表示契约并不保证契约忠实地表示请求。模型可以帮助抽取判据,但行动策略不应获得单方面权威去定义它自己的工作之后被判定为成功的条件。因此原始请求或可信的任务规格应当保持可用于契约审查,而含糊或高后果的契约可能要求在执行开始之前获得用户、操作者或确定性策略的显式批准。
契约有时需要移动。智能体可能发现一个判据不可能、不相关,或基于误解而规定,那是一个正当的发现。
它不是悄悄删掉判据然后通过的许可证。
危险的序列很短:判据失败、智能体断定判据不必要、判据消失、智能体通过。那里每一步局部都合理,这正是它难以在轨迹里被发现的原因。
@dataclass(frozen=True)
class ContractRevision:
criterion_id: str
old_description: str
new_description: str | None # None removes the criterion
reason: str
authorized_by: str
def apply_revisions(
contract: GoalContract,
revisions: tuple[ContractRevision, ...],
authorize: Callable[[ContractRevision], bool],
) -> GoalContract:
by_id = {c.id: c for c in contract.criteria}
order = [c.id for c in contract.criteria]
applied = 0
for revision in revisions:
current = by_id.get(revision.criterion_id)
if current is None:
raise KeyError(f"unknown criterion {revision.criterion_id!r}")
if current.description != revision.old_description:
raise ValueError(
f"stale revision for {revision.criterion_id!r}: "
"contract changed since the revision was proposed"
)
if not authorize(revision):
raise PermissionError(
f"unauthorized revision to {revision.criterion_id!r}"
)
if revision.new_description is None:
del by_id[revision.criterion_id]
order.remove(revision.criterion_id)
else:
by_id[revision.criterion_id] = replace(
current,
description=revision.new_description,
)
applied += 1
return GoalContract(
criteria=tuple(by_id[cid] for cid in order),
revision=contract.revision + applied,
)
三个细节是刻意的。authorized_by 是审计数据,不是权威的证明;可信的运行时决定那个行为者是否可以修订契约。如果修订是针对更老的描述提出的,它就被拒绝,这防止一份过期的批准悄悄编辑一份更新的契约。而改变描述会保留判据的 kind 与 required 状态,而不是用默认值重建它。
改变成功的定义是一个独立的、可归因的行动,不同于满足它。
验证器评估的是当前被授权的契约,而不是碰巧可达的那个目标。
3. 四种裁定,以及为什么 UNKNOWN 是其中之一
真实环境是嘈杂的。任务被部分完成,验证器不总能观察到足够的东西来决定,有时验证器自己会崩溃。
class Verdict(StrEnum):
PASS = "pass"
FAIL = "fail"
PARTIAL = "partial"
UNKNOWN = "unknown"
FAIL 与 UNKNOWN 是系统最常坍缩的一对,而它们意思相反。一个说要求是假的。另一个说我们无法确立要求是否为真,这发生在:监控数据还没到、第三方 API 超时、必需来源不可用、副本太过期而无法裁定,或人工批准仍在等待时。
从缺失的证据里制造确定性,是通往虚假成功的最容易的路。
PARTIAL 因另一个理由挣得自己的位置:长视野任务常常以有意义的不完整工作结束。十个请求的迁移完成了八个、两个因凭据不可用而被阻塞,PASS 与 FAIL 都不能诚实地描述它。叫它 FAIL 丢掉了那八个。叫它 PASS 是不真的。
把它报告为部分,带上计数与阻塞理由,让周围系统能精确追求还剩下的东西。
部分成功不放松必需判据。它精确描述什么被确立了、什么没有。
证据的缺席不是成功的证据。
4. 证据是对象,不是布尔值
把验证缩减为 success = True 扔掉了日后信任它所需的一切。
from datetime import datetime
@dataclass(frozen=True)
class Evidence:
criterion_id: str
source: str
tier: "EvidenceTier"
state_id: str
collected_at: datetime
verifier_id: str
verifier_version: str
verifier_config_id: str
verdict: Verdict
payload: dict[str, object]
@dataclass(frozen=True)
class CriterionResult:
criterion_id: str
verdict: Verdict
evidence: tuple[Evidence, ...] = ()
reason: str = ""
有了这些,系统能回答:检查了什么、对照哪个状态、由哪个验证器实现与版本、在哪个验证器配置下、用什么来源、何时,以及那次检查实际确立了什么。每当改变一个阈值、夹具集、策略文件或检查器配置能在不改变验证器代码本身的情况下改变 PASS 的含义时,这就要紧。
所以当智能体报告测试通过时,那个有用的问题有了答案:哪些测试、在哪个检查配置下、对照哪个状态?
后半句正是过期验证住的地方,而它是智能体的一个常见失败。测试通过。智能体再次编辑代码。智能体报告早先的通过结果。
证据完全真实,而它描述的是一个不再存在的状态。
state_id 弥合那个缺口,而什么属于它因领域而异。
| 领域 | 状态身份 |
|---|---|
| 代码 | 覆盖所有判据相关文件的不可变工作区快照或内容摘要 |
| 数据 | 数据集版本、分区快照、行校验和 |
| 部署 | 产物摘要、部署 ID、运行镜像哈希 |
| 业务工作流 | 订单 ID、交易 ID、记录版本 |
def evidence_is_current(evidence: Evidence, current_state_id: str) -> bool:
return evidence.state_id == current_state_id
状态标识符必须来自可信的运行时或环境状态,而不是来自动作的模型,并且每当判据相关的状态变化时它都必须变化。否则绑定只在语法上存在。
同样的信任要求适用于证据封套的其余部分。source、tier、验证器身份、验证器配置与收集时间,由执行了那次检查的可信收集器或运行时指派。它们不是行动模型可以自报的字段。否则智能体可以制造一条高层级证据记录,而不必制造底层观察。
如果状态在收集之后改变了,相应的结果就退回未验证。这与支配记忆的是同一条时间规则:一个缓存的 PASS 不压过一个此后变过的工作区,一个 14:02 健康的服务不是 14:08 健康端点失败的证据。
5. 验证状态,不验证叙述
智能体评估一直在稳步走向基于状态的验证,也就是说,给环境变成了什么打分,而不是给智能体关于它说了什么打分。STAGE-Claw 通过真实个人计算环境里最终系统状态的正确性给智能体打分,而不是只通过文本输出。[1]
到生产的迁移是直接的,通常是一个找到第三方会去查询的那条记录的问题。
| 智能体 | 弱证据 | 状态证据 |
|---|---|---|
| 编码 | “我修好了 parser” | 仓库状态、测试、复现 |
| 日历 | “会议已安排” | 事件存在且字段正确 |
| 支持 | “退款已发” | 正确金额的退款交易存在 |
| 浏览器 | “订单已下” | 后端订单记录存在 |
| 数据 | “流水线成功了” | 输出满足对账不变量 |
宁可要关于结果环境状态的证据,也不要关于智能体对它的叙述的证据。
6. 先收集,再裁定
证据收集与裁定是不同的工作,应当是不同的代码,因为观察失败与判断失败需要不同的修法。
缺失的服务回执不是一张显示失败的回执。一张正确的回执对照错误的判据被解释,不是环境问题。
对这次部署,收集器报告退出码、运行摘要、就绪副本三之三、一个返回 200 的健康端点,以及处于基线的错误率。裁定器把它们映射到契约的判据上。两者对对方都知之甚少。REDAgentBench 在安全评估里做了相关的区分,把实际的有害效果与评估视图能观察到的东西分开,并把裁定建立在服务回执与最终状态变化上。[5]
裁定有一条比其余都要紧的规则:必需的证据门不得溶解成一个平均。
假设单元测试通过、API 契约测试失败、风格评审器通过。
那不是三局两胜。契约失败可能是整个任务的要点,而任何让两个软通过盖过一个硬失败的标量,都已经毁掉了结果的意义。
def adjudicate(
contract: GoalContract,
results: dict[str, CriterionResult],
) -> Verdict:
required = [
results[c.id]
for c in contract.criteria
if c.required and c.id in results
]
missing = contract.required_ids - results.keys()
if any(r.verdict is Verdict.FAIL for r in required):
return Verdict.FAIL
if missing or any(r.verdict is Verdict.UNKNOWN for r in required):
return Verdict.UNKNOWN
if any(r.verdict is Verdict.PARTIAL for r in required):
return Verdict.PARTIAL
return Verdict.PASS
注意这个顺序。任何必需判据上的确定失败压过一切,因为一个硬要求坏了的任务不是部分完成。缺失的证据压过部分的证据,因为不知道比知道得不完整更弱。
必需判据应当从 Criterion.required 选取——契约已经携带它——而不是从判据 ID 的命名约定推断。
7. 验证器是攻击面的一部分
一旦智能体能影响给它打分的环境,一个舒适的假设就破了:一个通过的检查器不再自动是预期能力被行使过的证据。
假设任务是把一个基准分数提到 0.90 或以上,而智能体可以修改 score.py。一个函数体 return 1.0 完全满足打分器。同样的形状不断重现:读隐藏答案、查看基准元数据、删掉失败测试、给可见实例写特例,或整个跳过一个验证阶段。
验证器说 PASS。目标没有达成。
那个裁定本身没有任何东西把这次运行与一次正当的运行区分开。
所以一个通过的任务检查器不够,第二个问题必须与表面的成功一起被问出:
检查器是通过一条仍然要求预期能力的路径被通过的吗?
那个问题需要自己的状态,与正确性分开追踪。
class IntegrityStatus(StrEnum):
CLEAN = "clean"
VIOLATED = "violated"
UNKNOWN = "unknown"
一个完整性为 CLEAN 的判据 PASS 可以为成功出力。一个完整性为 VIOLATED、理由是「测试文件被智能体修改」的判据 PASS 不能。完整性 UNKNOWN 又不一样:它意味着运行时还没有确立证据路径保持可信,所以一个正面的主张必须被降级为不确定,而不是被提升或被发明。
这件事在实践中要紧的证据现在是具体的。2026 年奖励作弊基准研究使用工具的智能体利用评估捷径,包括跳过验证、任务相邻元数据,以及篡改与评估相关的函数。[2] 2026 年六月一项对五个终端智能体基准共 1,968 个任务的审计发现,其中 323 个的结果验证器可被前沿模型仅从任务描述黑入,并提出了一个对抗性黑客—修复者加固循环。[3] 2026 年七月一项协议有效性研究主张:只有当评估协议让预期能力对成功仍然必要时,基准分数才支撑一个能力主张。[4]
这个框架化可以推广到基准之外。这个问题的生产版本不仅是检查器是否返回了 PASS,而是检查路径是否仍然度量任何人在乎的性质。
当一个智能体对着一个可度量的信号优化时,度量路径本身需要保护。
8. 最低证据门槛
保护意味着行动策略不会获得对以下东西的无限制权威:哪些判据是必需的、每个判据什么算作充分证据、验证器实现、参考答案、受保护的夹具、证据日志,以及完整性策略本身。
flowchart TD
subgraph M[智能体可变的]
W[工作区] --> ENV[环境状态]
end
ENV -.被观察.-> P
subgraph P["受保护的:智能体不能写入"]
BAR[证据门槛] --> CH[独立检查]
CH --> ADJ[裁定]
ADJ --> INT[完整性监控]
end
style P fill:#eef3fb,stroke:#4a6fa5
这些都不要求验证器是秘密的。它要求运行时保住让证据有意义的任何分离,在不同系统里这意味着隐藏测试、不可变的策略规则、只读夹具、独立的服务回执,或一个智能体碰不到的第二个环境。
更微妙的攻击不篡改任何东西。
它只是挑选更弱的检查。
被要求修复一个 API 行为时,一个由模型控制的验证计划常常会提议读被编辑的函数,而不是复现那个 API 请求。前者便宜且自我确认。后者因果相关。
没有任何东西被破坏。证据只是被悄悄降级了,而裁定可以看起来一模一样。
防御是把门槛做成一个一等对象:智能体能抬高它、不能降低它。
from enum import IntEnum
class EvidenceTier(IntEnum):
JUDGE = 0 # model or subjective evaluator
PROCESS_MODEL = 1 # learned evaluator
DOMAIN_SIGNAL = 2 # task-specific heuristic or partial check
ENVIRONMENT = 3 # direct observation, receipt, or deterministic test
@dataclass(frozen=True)
class EvidenceBar:
"""The floor for one criterion. Set by trusted runtime policy."""
criterion_id: str
min_tier: EvidenceTier
accepted_sources: frozenset[str] = frozenset()
def qualifying(self, evidence: tuple[Evidence, ...]) -> tuple[Evidence, ...]:
return tuple(
e for e in evidence
if e.tier >= self.min_tier
and (not self.accepted_sources or e.source in self.accepted_sources)
)
def cleared_by(self, evidence: tuple[Evidence, ...]) -> bool:
return bool(self.qualifying(evidence))
层级排序是这个运行时的一条默认信任策略,不是关于证据的普遍定理。一个领域可能需要不同的排序或来源特定的规则,这就是为什么门槛也点出被接受的来源。重要的性质是:最低门槛是显式的、受保护的、判据特定的。
这套词汇与搜索期间的部分状态评估共享,但这里的语义更严。搜索估计哪个分支配得上更多计算;验证决定什么证据强到足以关闭一个判据。
智能体可以自由在门槛之上添加检查。
它不能用方便的证据替代必需的证据。
9. 组装起来的验证器
覆盖率必须是显式的,因为一份有五个必需判据、其中两个被检查并通过的契约不是一个通过。它是两个已确立、三个未知,而一个不追踪这个差别的验证器会带着完全的信心报告错误的东西。
组装起来的验证器还必须刻意地消解证据。较低层级的证据对诊断有用,但它不应该仅凭副本更多就能盖过一个更强的来源。
from typing import Callable
def verdict_from(supporting: tuple[Evidence, ...]) -> Verdict:
"""Adjudicate the strongest qualifying evidence tier conservatively."""
if not supporting:
return Verdict.UNKNOWN
strongest = max(e.tier for e in supporting)
strongest_evidence = tuple(e for e in supporting if e.tier == strongest)
verdicts = {e.verdict for e in strongest_evidence}
if Verdict.FAIL in verdicts:
return Verdict.FAIL
if Verdict.UNKNOWN in verdicts:
return Verdict.UNKNOWN
if Verdict.PARTIAL in verdicts:
return Verdict.PARTIAL
if verdicts == {Verdict.PASS}:
return Verdict.PASS
return Verdict.UNKNOWN
@dataclass(frozen=True)
class GoalVerification:
verdict: Verdict
integrity: IntegrityStatus
results: tuple[CriterionResult, ...]
coverage: float
established: int
total_required: int
reason: str = ""
def verify_goal(
contract: GoalContract,
evidence: tuple[Evidence, ...],
bars: dict[str, EvidenceBar],
*,
current_state_id: str,
integrity: IntegrityStatus,
) -> GoalVerification:
missing_bars = contract.required_ids - bars.keys()
if missing_bars:
raise ValueError(
f"required criteria have no protected evidence bar: "
f"{sorted(missing_bars)}"
)
fresh = tuple(
e for e in evidence
if evidence_is_current(e, current_state_id)
)
results: dict[str, CriterionResult] = {}
for criterion in contract.criteria:
supporting = tuple(
e for e in fresh
if e.criterion_id == criterion.id
)
bar = bars.get(criterion.id)
if not supporting:
continue
qualified = (
bar.qualifying(supporting)
if bar is not None
else supporting
)
if not qualified:
results[criterion.id] = CriterionResult(
criterion_id=criterion.id,
verdict=Verdict.UNKNOWN,
evidence=supporting,
reason="evidence exists but does not clear the protected bar",
)
continue
results[criterion.id] = CriterionResult(
criterion_id=criterion.id,
verdict=verdict_from(qualified),
evidence=supporting,
)
verdict = adjudicate(contract, results)
if integrity is IntegrityStatus.VIOLATED:
verdict = Verdict.FAIL
elif (
integrity is IntegrityStatus.UNKNOWN
and verdict in (Verdict.PASS, Verdict.PARTIAL)
):
verdict = Verdict.UNKNOWN
required = contract.required_ids
established = sum(
1 for cid in required
if cid in results and results[cid].verdict is not Verdict.UNKNOWN
)
reason = ""
if integrity is IntegrityStatus.VIOLATED:
reason = "verification integrity violated"
elif integrity is IntegrityStatus.UNKNOWN:
reason = "verification integrity not established"
elif verdict is not Verdict.PASS:
reason = "see criterion results"
return GoalVerification(
verdict=verdict,
integrity=integrity,
results=tuple(results.values()),
coverage=established / max(len(required), 1),
established=established,
total_required=len(required),
reason=reason,
)
有趣的部分不是类型层级。而是这个函数拒绝坍缩彼此的东西的清单:缺失的证据、过期的证据、门槛之下的证据、同等可信证据之间的分歧、失败的证据、部分的证据,以及一次完整性违反。
coverage 是裁定覆盖率,不是成功率。一个必需判据在合格证据支持一个确定的 PASS、FAIL 或 PARTIAL 结果时算作已确立;UNKNOWN 不算。因此这个字段回答的是必需契约的多少被裁定了?,而不是目标的多少成功了?
一个必需判据缺失的证据门槛,被当作验证器配置错误,而不是被当作接受碰巧存在的任何证据的许可。
完整性检查只能让一个正面的结论更难挣得。VIOLATED 产生 FAIL。UNKNOWN 不伪装成一条干净路径;它把 PASS 或 PARTIAL 降级为 UNKNOWN。一个确定的判据失败无论如何仍然是失败。
10. 前置条件与后置条件
动作边界已经拥有前置条件:在一个被提案的动作执行之前,运行时检查世界是否处于该动作可以运行的状态。验证不把那个责任收回去。
验证添加的是操作的另一面:关于执行是否产生了它应当产生的状态的证据。同一批注册的检查可以支撑两道边界,但归属仍然不同。
@dataclass(frozen=True)
class Gate:
id: str
description: str
check: str # identifier of a registered deterministic check
@dataclass(frozen=True)
class GatedOperation:
name: str
preconditions: tuple[Gate, ...]
postconditions: tuple[Gate, ...]
对一次破坏性迁移,动作边界在执行之前检查前置条件,例如 schema 版本 41、一个有效的备份和一把持有的迁移锁。验证在之后检查后置条件,例如 schema 版本 42、对账后的行数、完好的约束和健康的应用状态。
模型可以提案这次迁移。运行时拥有执行之前的前置条件门与执行之后的后置条件证据路径。一个失败的后置条件是一次已验证的失败,而不是一个要去叙述的不幸结果。
有用的统一在检查注册表里,而不是在坍缩两个阶段。同一个可信检查可以参与前置条件执行、进度度量与最终验证,而每个机制仍然回答自己的问题。
11. 按成本与后果分阶段
验证消耗时间、工具调用,有时还有金钱,所以检查运行的顺序本身就是一条策略。验证器不应该花十五分钟去证明一段解析失败的代码也跑不过完整回归套件。
def verify_staged(
stages: list[tuple[str, Callable[[], tuple[Evidence, ...]]]],
contract: GoalContract,
bars: dict[str, EvidenceBar],
*,
current_state_id: str,
integrity: IntegrityStatus,
) -> GoalVerification:
collected: tuple[Evidence, ...] = ()
if not stages:
return verify_goal(
contract,
collected,
bars,
current_state_id=current_state_id,
integrity=integrity,
)
result = verify_goal(
contract,
collected,
bars,
current_state_id=current_state_id,
integrity=integrity,
)
for _name, collect in stages:
collected += collect()
result = verify_goal(
contract,
collected,
bars,
current_state_id=current_state_id,
integrity=integrity,
)
if result.verdict is Verdict.FAIL:
return result # a hard failure ends the cascade
return result
对代码,级联可能先跑解析,然后有针对性的复现,然后相关测试,然后完整套件,然后——如果契约要求——性能检查。对数据,它可能先跑 schema、样本不变量、分区对账,然后完整对账。普遍的部分不是顺序而是形状:按失败概率与后果的比例花证据预算,并在一个必需判据确定坏掉时立刻停下。
这份草图假设 current_state_id 标识一个在级联期间保持稳定的状态。如果环境能并发变化,验证器必须要么验证一个不可变快照,要么在裁定之前重新获取当前状态身份。只有当比较中所谓当前那一侧确实当前时,状态绑定才保护对抗过期证据。
默认只有 FAIL 短路。
第二阶段的 UNKNOWN 是继续收集的理由,不是停下的理由。当后续阶段可能确立剩余部分时,PARTIAL 也能证明继续是正当的。生产验证器可以加上成本上限或针对后果的升级,但那些应当是显式策略,而不是意外的提前退出。
12. 评审器是证据,不是预言机
不是每个任务都有一个确定性的预言机。写一份有说服力的备忘录、评审一份架构、综合一份文献、改进一篇散文:这些都没有测试套件,假装否则产生的是表演。
验证在那里不消失。
它分解,因为主观任务包含客观岛屿。一份研究综合包含若干可直接检查的性质。被引来源存在且可达。日期是对的。引文与来源一致。必需章节存在。其他性质即使仍需要判断,也能比一个整体质量分数被更有力地检查——例如,一个主张是否真被被引段落支持,而不只是提到了同一话题。
那些检查之后剩下的是一个更小的主观残余:清晰度、综合质量、论证判断,以及其他不存在直接预言机的性质。
@dataclass(frozen=True)
class Claim:
id: str
text: str
source_ids: tuple[str, ...]
def verify_claims(
claims: tuple[Claim, ...],
check_source,
) -> dict[Verdict, int]:
from collections import Counter
return Counter(check_source(claim) for claim in claims)
报告四条主张被支持、一条部分支持、一条不支持,远比一个 8.7 分(满分 10 分)的答案质量有用,因为前者可以被采取行动,后者不能。
对残余而言,一个学习型评审器是合理的仪器,只要它的输出被正确地读。「评审器说 PASS」意味着一个评估器产出了支持 PASS 的证据。它不意味着现实被证明了。在上面那条默认策略之下,评审器坐在直接环境证据之下,无法关闭一个受保护门槛要求环境来源的判据,无论它听起来多自信。
评审器会因以下东西改进:显式的评分细则、扎根于源材料、生成器与评审器角色的分离、对抗性样本,以及一个带已知标签的校准集。它们也应当在独立标注的案例上,为与任何其他验证器相同的两个错误率被度量。
13. 验证驱动恢复
裁定不只是一份最终报告。它是控制循环的一个输入,四个各自通向不同的地方:PASS 停下,FAIL 诊断不匹配并恢复,PARTIAL 追求剩余的判据,UNKNOWN 收集更多证据、重试观察,或升级。
这些要起作用,一次失败必须结构化到足以改变下一个决定。一个裸的 FAIL 不是。一个判据 checkout_total,期望值 49.99、观测值 59.99、状态 order:8172:v6、来源是后端订单记录,就是一个附了下一步的诊断。
有一个循环要小心,因为它从噪声里制造确定性:
def verify_with_budget(run_check, *, attempts: int = 3) -> Verdict:
if attempts < 1:
raise ValueError("attempts must be at least 1")
seen = [run_check() for _ in range(attempts)]
if any(v is Verdict.FAIL for v in seen):
return Verdict.FAIL
if all(v is Verdict.PASS for v in seen):
return Verdict.PASS
if all(v is Verdict.PARTIAL for v in seen):
return Verdict.PARTIAL
return Verdict.UNKNOWN
它防止的失败模式是:UNKNOWN 被重试直到一个 PASS 出现,然后那个 PASS 被当作答案。聚合必须是保守的:任何 FAIL 都粘住,未知之中单个 PASS 不清除该判据,重复的 PARTIAL 结果保持部分而不是被提升。
当一个确定性或权威来源不可用时,把一个模型判断再跑三次并不替代缺失的来源。
证据预算花完之后,UNKNOWN 保持未知。
同样的诚实适用于人工评审,它属于这个列表之内,而不是之外。发布、不可逆的高影响动作、含糊的验收标准、法律批准与财务授权,都可能以一个人作为它们正确的最终验证器。因此 AWAITING_REVIEW 是一个合法的运行时状态,而不是一个架构上的尴尬。
智能体工程的目标不是最大自主。它是在显式权威与证据之下可靠地委派。
14. 对验证器做红队
智能体用失败注入来测试。
验证器应当得到同样的对待,理由更强:验证器将会被对着优化。
对一个编码验证器,攻击是具体的、值得刻意去跑的:删掉一个失败测试、跳过测试发现、修改一个夹具、把可见示例硬编码、只对测试输入返回期望值、编辑打分脚本、读一个受保护的答案产物,或在缓存里留下过期的 PASS 证据。然后问那个验证器是否仍然拒绝无效的解法。
2026 年的黑客—修复者工作把这个系统化。一个黑客寻找不解决就能通过的方法,一个修复者给验证器打补丁,一个正当的求解者确认真实解仍然通过,循环重复,直到攻击预算找不到洞为止。[3] 那个循环的后半通常是跳过的部分,而它正是阻止验证器加固变成验证器偏执的东西。
主动搜索验证器能在不满足目标的情况下被满足的方式。
两个决定性的错误率在后果上不对称,它们应当用实际的真值类别作分母,而不是用验证器自己的预测。
def verifier_error_rates(
labelled: list[tuple[Verdict, bool]],
) -> dict[str, float]:
"""Known-outcome cases: (verdict returned, goal truly satisfied)."""
def rate(count: int, total: int) -> float:
return count / total if total else float("nan")
positive = [
(verdict, truth)
for verdict, truth in labelled
if truth
]
negative = [
(verdict, truth)
for verdict, truth in labelled
if not truth
]
false_pass = sum(
1
for verdict, _ in negative
if verdict is Verdict.PASS
)
false_fail = sum(
1
for verdict, _ in positive
if verdict is Verdict.FAIL
)
unknown = sum(
1
for verdict, _ in labelled
if verdict is Verdict.UNKNOWN
)
partial = sum(
1
for verdict, _ in labelled
if verdict is Verdict.PARTIAL
)
return {
"false_pass_rate": rate(false_pass, len(negative)),
"false_fail_rate": rate(false_fail, len(positive)),
"unknown_rate": rate(unknown, len(labelled)),
"partial_rate": rate(partial, len(labelled)),
}
假失败拒绝真正满足了目标的工作,可能触发不必要的恢复或升级。
假通过对于自主完成通常是更危险的错误,因为它终止运行并记录一个错误的成功状态。这就是为什么一个更强的智能体配一个弱的验证器,能看起来在改善,而只是变得更善于满足代理。
相对代价是领域特定的,所以即使生产策略给它们指派非常不同的后果,两个率都属于评估。
把行动智能体与验证器放在一起测会让任何改变不可解释,所以用已知结果的案例,分开四种能力:智能体能否解决任务、验证器能否认出真实成功、它能否拒绝假成功,以及完整性层能否拒绝被钻空子的成功。
注入测试集应当覆盖:一个成功但效果失败的命令、一个过期的通过测试、错误的环境、一次部分写入、一个别处带回归的正确本地结果、缺失的来源、矛盾的证据、被修改的测试、被修改的打分器、答案键暴露、验证器崩溃,以及一个缓慢的最终一致更新。
15. 验证的成本
本书每个机制都被问过是否挣得它的成本,验证不得到豁免。
| 级 | 增加 | 它应当减少什么 |
|---|---|---|
| A | 仅智能体自报告 | 基线;什么也没度量 |
| B | 有针对性的复现检查 | 明显的假通过 |
| C | + 相关回归测试 | 附带损害 |
| D | + 状态绑定的证据 | 过期的 PASS |
| E | + 受保护的门槛与完整性检查 | 被钻空子的 PASS |
固定模型、工具、任务集、预算与基础提示,对照报告的成功度量真实任务成功、两个错误率、覆盖率、完整性违规、成本与延迟。
要紧的那一级通常不是原始完成率最高的那一级。
它是声称的成功与已验证的成功之间差距最小的那一级。
一条完整的验证级联可能减少虚假成功而明显增加成本——对一次生产部署这是极好的交易,对一份一次性草稿则不必要。必需的证据门槛应当跟踪出错的后果,那是关于任务的决定,而不是关于验证器的决定。
16. 成功的主张在哪里被挣得
这本书现在构成一个整体构造,每个机制回答前一个暴露的问题。
| 机制 | 问题 | |
|---|---|---|
| 1 | 控制 | 谁决定接下来发生什么? |
| 2 | 有效性 | 这个被提案的动作可以执行吗? |
| 3 | 替代方案 | 存在哪些完整的替代? |
| 4 | 修订 | 一个候选能否无回归地改善? |
| 5 | 规划 | 什么未来工作被打算? |
| 6 | 进度 | 发生了什么,我们应该继续吗? |
| 7 | 能力 | 智能体现在能做什么、能看到什么? |
| 8 | 记忆 | 什么过去信息应该影响这个? |
| 9 | 搜索 | 哪个可能的未来配得上更多计算? |
| 10 | 证据 | 什么挣得了目标已达成的主张? |
这个进程不是朝向一个更有能力的模型。
它朝向一个更显式的运行时,而最后的循环显示:那台承重的机器现在几乎不剩多少坐在模型内部。
flowchart TD
G[用户目标] --> GC[目标契约]
GC --> ST[运行时状态]
ST --> MP[模型提案]
MP --> VA{"校验 + 授权"}
VA -->|rejected| MP
VA -->|accepted| EX[执行]
EX --> OB[观察]
OB --> PR["进度:继续、恢复、停止"]
PR --> ST
PR --> EC[证据收集]
EC --> SB["状态绑定 + 证据门槛"]
SB --> IN[完整性监控]
IN --> AD[受保护的裁定]
AD --> VD["PASS / FAIL / PARTIAL / UNKNOWN"]
在本书开始时,模型看起来像系统的中心。它仍然重要,而它的角色现在清晰可辨:它在它不拥有的边界之内生成提案、做决定。运行时拥有状态、权威、动作边界、预算,以及记忆、搜索与验证策略。环境拥有据以构建证据的观察。
所以记录成功的权威不来自模型的置信、计划的优雅,或一个分支分数。它甚至不自动来自一个通过的测试。
不要问智能体现实是否改变了。构建一条证据路径,它能确立什么改变了、什么保持为真,以及通往那个结论的路径本身是否可信。
当那条路径产出足够,裁定就是 PASS。当它显示要求是假的,FAIL。当只挣得契约的一部分,PARTIAL。而当系统确实无法确立其中哪一个为真时,UNKNOWN 是比发明出来的确定性更好的工程结果。
研究渊源
这些参考文献为这里使用的机制确立了血统。本章的架构是一次工程综合,而不是主张任何单篇论文定义了正确的智能体验证器。
-
Liang et al. — STAGE-Claw: Automated State-based Agent Benchmarking for Realistic Scenarios (2026). 通过真实个人计算环境里结果系统状态的正确性评估智能体,而不只是文本响应;引用它,是因为第 5 节的基于状态的验证论证。 https://arxiv.org/abs/2606.10394
-
Thaman — Reward Hacking Benchmark: Measuring Exploits in LLM Agents with Tool Use (2026). 研究使用工具的智能体利用评估捷径,包括跳过验证、任务相邻元数据与篡改评估相关函数;引用它,是因为第 7 节的攻击分类。 https://arxiv.org/abs/2605.02964
-
Zhong et al. — Hardening Agent Benchmarks with Adversarial Hacker-Fixer Loops (2026). 审计五个终端智能体基准的 1,968 个任务,发现 323 个仅从任务描述就可黑入,并引入第 14 节所用的黑客—修复者—求解者循环。 https://arxiv.org/abs/2606.08960
-
Shao et al. — Do Agent Benchmarks Measure Capability? Protocol Validity in the Age of Agentic AI (2026). 主张只有当评估协议让预期能力对成功仍然必要时,基准分数才支撑能力主张;引用它,是因为第 7 节的生产推广。 https://arxiv.org/abs/2607.22368
-
Chen et al. — REDAgentBench: Executable Red Teaming and Faithful Measurement of LLM Agent Systems (2026). 把有害效果与证据可见性分开,并用服务回执与最终状态变化验证效果;引用它,是因为第 6 节的收集/裁定区分。 https://arxiv.org/abs/2608.10669
下一章:构建完整智能体
十个机制已经构建,每一个都各自被论证和度量。
这不同于展示它们一起工作。每一章都针对一个为隔离它而选的问题确立它的机制,这是解释一个东西的正确方式,却是弄清它能否在与另外九个的接触中存活的糟糕方式。组合失败是它们自己的一类:一个与搜索预算打架的记忆策略、一个状态绑定与搜索用于分支隔离的检查点格式不匹配的验证器、一个悄悄变成它本该描述的状态的计划表示。
最后一章取一个小的、真正坏掉的仓库,把整套东西端到端跑一遍。那里有趣的结果不是成功的修复。而是当验证器被攻击时发生了什么。