结语
目的
为什么一个由各自都通过了测试的部件构建而成的智能体，仍然需要工程师来定义何为完成？
此前的每一章都构建了智能体系统的一个部分，并依据该部分自身的标准进行测试；但生产环境中的一条轨迹会同时涉及所有这些部分，而两个部分衔接处的故障，若架构没有明确责任归属，就无人负责。写入后仍留在上下文中的过期文件、导致重复付款的重试，以及同时充当训练奖励的验证器，都能通过每个子系统自身的全部测试。本章沿着一条轨迹运行整个系统，为每次转换指定责任主体并留下记录，展示不同部分的原则在何处交汇，又在何处相互牵制。随后，本章将指出任何子系统都无法接管的工作，即编写整台机器必须遵循的契约与完成标准。运行时可以针对任务的长时间跨度、所携带的状态以及对外部世界的权限提供闭合保障，但只有工程师才能说明任务的目的，以及怎样才算完成。
学习目标
- 追踪一条工具调用轨迹如何经过智能体系统的每个部分，明确每次转换的责任主体及其记录。
- 将本卷的每项原则映射到它所消除的 H·S·A 风险暴露，或它所提供的证据。
- 将由五部分组成的任务契约转化为强制执行的时间跨度、状态与权限边界，以及所需的闭合证据等级。
- 诊断子系统衔接处出现的故障，并为每种故障指定责任主体。
- 对已完成归因的故障应用干预阶梯，并确定任务量达到何种规模时，修改权重才具有成本效益。
- 利用机械检查、重复运行评估和分阶段发布，构建由主张、论证和证据组成的安全论证。
- 通过布鲁克斯提出的本质复杂性与偶然复杂性，评估智能体能够自动化哪些工作，并解释为什么任务契约仍由工程师负责。
综合参考架构
《智能体系统基础》阐明了为什么一个不具备任何环境隐含权限、且失败表现看似合理的模型无法独自执行任务，而@sec-vol3-intro-invariant-closure则阐明了必须由运行时而非模型来闭合任务边界并判断任务是否完成。随后，第 I 至第 VI 部分逐一构建了该运行时的各个子系统，并分别依据各自的标准进行了测试。
本章探讨的是：当所有机制都作用于同一条轨迹时，每次转换由谁负责，以及哪些工作无法由任何机制承担。为回答这些问题，本章沿着一条事件修复轨迹，从最初的告警一直追踪到修复方案被验收，让它经过完整架构（图 1），并明确每一步的责任主体与审计记录。随后，本章其余部分将考察不同部分的原则在何处交汇、在何处相互牵制，以及机器的能力止于何处。
智能体系统的综合参考架构将各个子系统放在构建它们的章节所确定的位置上。运行时封装模型调用（基座模型）及其测试时推理（测试时计算），对 KV 缓存进行分页管理并共享前缀（KV 缓存管理），检索持久状态（长期记忆），将带类型的工具调用（工具调用）分派至隔离的 microVM 沙箱（智能体沙箱），将每一步提交到仅追加日志（持久执行），通过 Saga 对失败的外部步骤进行补偿（故障恢复），收集经过验证的轨迹记录（轨迹整理）以调整策略（轨迹微调；可验证奖励强化学习），协同智能体集群（多智能体协同），并在事后重建因果轨迹（智能体评估）。
该轨迹是一项由生产数据库延迟告警触发的自动化事件修复任务。当分布式集群与遥测互连结构检测到 SLA 违约时，轨迹开始，并通过 OpenTelemetry 采集器捕获指标异常和追踪跨度。集群协调器将事件载荷路由至监督运行时，后者在易失性主机内存中实例化一个智能体控制块（ACB）。ACB 初始化轨迹状态：分配唯一的进程标识符，设置单调递减的 token 预算和实际时间预算，并将任务的五部分契约提交至仅追加的预写日志（WAL）。
接下来，内存层次结构准备任务上下文。上下文管理器为任务契约、事件载荷和当前环境描述信息分配工作上下文。键值（KV）缓存管理器使用 PagedAttention 映射加速器物理内存，并在基数树中为共享提示前缀建立索引，避免冗余的预填充计算。同时，上下文管理器查询持久存储，对向量索引和关系数据库发起语义检索，以获取相关服务运维手册和以往事件的复盘报告，将权威来源摘录注入提示，并建立用于验证来源的加密哈希。
随后，计算引擎——无特权的基础模型引擎——对已准备好的上下文缓冲区进行求值。推理运行时在分布式 GPU 加速器上运行，先执行预填充 GEMM 阶段，再执行自回归解码 GEMV 迭代。在生成过程中，受语法约束的 logit 掩码将 token 输出严格限制在有效的工具调用模式内。如果任务需要深入规划，审议引擎会执行有界的测试时搜索轨迹采样，对候选推理路径评分，然后将无特权的行动提案 \(a_t\) 提交至提案端口。
监督运行时从提案端口截获 \(a_t\)，并将其暂存于内存中托管。运行时的能力防火墙依据当前有效的 Macaroon 租约和安全策略评估该行动。如果所提议的行动涉及不可逆的变更，例如删除数据库表或重启核心集群节点，控制平面会暂停执行，并请求人类提供加密会签。对于已授权的工具行动，运行时封送带类型的参数，并将其跨越 \(W \oplus X\)（写入与执行互斥）隔离屏障，分派至临时 microVM 沙箱（如 Firecracker）。
在 microVM 沙箱内，工具在隔离的网络命名空间和叠加文件系统中执行。执行框架捕获 stdout、stderr 和整数返回码，将其封装为规范化的观测记录 \(o_{t+1}\)。如果某项行动改变了持久化的外部状态，该事务会被注册为一个活跃的 Saga 步骤。如果下游操作失败或触发不变量违例，控制平面会按时间倒序执行已注册的补偿行动 \(C_i\)，恢复外部状态的一致性。
收到观测 \(o_{t+1}\) 后，监督器将状态转移 \((a_t, o_{t+1})\) 追加到预写日志中，使该行动所涉及文件的所有派生视图失效，并将规范化的观测追加到工作上下文中。这一闭环循环持续重复，直至智能体输出候选交付物，例如包含配置修复的拉取请求。
关键在于，交付物的验收由外部验证判定器决定，而非依据智能体的口头声明。遥测与验证关卡执行确定性的验收测试：在封闭的测试框架中运行单元测试套件，执行静态分析检查器，检查数据库一致性断言，并监测预发布环境的金丝雀指标。只有当验证判定器的求值结果为退出码 0 时，监督器才会将轨迹标记为已提交，更新 SRE 金丝雀关卡，并关闭运维工单。
与此同时，跨任务生命周期基础设施采集该轨迹，用于长期学习。轨迹数据引擎读取已定稿的预写日志，应用拒绝筛选机制以筛出成功轨迹，并将其整理为标准执行记录。离线策略编译器生成针对行动的损失掩码，并执行可验证奖励强化学习（RLVR）或监督微调循环。这一优化过程将成本高昂的多步骤审议推理编译到高效的单轮模型权重中，通过金丝雀发布部署更新后的参数检查点，以提升集群未来的性能。
这一流程示例跨越了 实时执行循环：四个功能子系统 和 跨任务集群基础设施 所划定的界线。直至验收为止的所有工作都属于实时运行时的负责组件，它们持有轨迹的时间为数秒至数分钟。轨迹采集、策略编译器、集群遥测和金丝雀关卡则属于跨任务基础设施，它们以数小时至数天的时间尺度处理已经结束的轨迹。
这种职责划分自 系统架构蓝图 起便贯穿本书；其中，随机计算机明确了哪些部分分别负责模型调用、上下文状态、动作边界、运行时、策略编译器和集群。这一综合体系从经典计算机系统中借鉴的是一致性、预写日志、Sagas、能力机制和端到端论证等方法原则，而非组件身份，因此模型不是处理器，上下文窗口也不是缓存。
这条轨迹的每一步都遵循不变量闭合原则（不变闭包原则）。运行时通过预算、能力检查、托管机制和沙箱，以机械化方式封闭任务边界；该原则的端到端部分则支配验收，因为模型的任何报告都无法证明任务已经完成。只有宿主运行的密封测试、静态检查和一致性断言才能证明这一点，而 闭合证据等级 则对它们各自的证明价值进行排序。
智能体系统是一个可追责的执行循环，其模型调用、状态、动作边界、监督器、学习流水线和集群运维都可以追溯到任务契约，并依据认可的结果进行检验。
动态轨迹编排与职责归属
生产数据库触发了一条延迟告警，值班智能体接手了这一事件。在接下来的几分钟里，它将读取指标、检索运维手册、查询日志、提出配置回滚建议、等待人工批准重启节点，并报告事件已解决。本书构建的每个子系统都会参与这条轨迹，而且每个子系统都已单独接受测试。本章要探讨的问题是：当所有子系统都作用于同一条轨迹时，每一次转换由谁负责，以及哪些工作是它们都无法承担的。
图 2 将本书的各个部分放置在相应章节最终确立的位置上。工程师在顶部编写契约。实时循环在智能体运行框架内执行模型调用、上下文组装、工具调用和沙箱操作，而运行框架负责预算、日志和恢复。验收位于循环下方；学习与规模扩展则跨越多条轨迹开展，而非在单条轨迹内部进行。
轨迹在任何模型调用之前就已开始。智能体运行框架为该事件创建轨迹记录（智能体运行框架），将任务契约写入轨迹日志（持久执行），并设置约束这条轨迹的预算。契约还确定了任务在 H·S·A 空间中的位置。该事件的处理持续约十轮，携带着不归它所有的持久状态（生产指标、运维手册、配置仓库），并在改变生产环境的那一步达到最高权限级别。
随后，上下文组装决定首次调用能够看到什么。它准备好契约、告警，以及依据带类型约束的检索契约检索到的运行手册摘录，并附上各自的来源（长期记忆）；同时将稳定内容置于最前面，以便后续轮次复用同一前缀（上下文工程）。服务系统保留该前缀对应的注意力状态（KV 缓存管理），因此，后续每一轮的开销主要来自新追加的观测，而无须再次处理整个上下文。
模型调用返回一个结构化工具调用和一个停止原因（基座模型），此时现实世界尚未发生任何变化。当诊断存在歧义时，智能体运行框架可以投入计算资源生成多个候选假设，并依据能够区分这些假设的检查对其排序（测试时计算）；只有当检查获取了新证据时，这种做法才有帮助（原则 2）。
查询数据库慢查询日志的提议会依据工具的模式进行验证，并对照任务获得的授权进行检查（工具调用）。查询在沙箱中执行，模型无法扩大其边界（智能体沙箱）；查询输出作为不可信数据返回上下文，按观测预算裁剪，并标注来源。当查询超时时，运行时不会直接重新发送查询。它会利用调用携带的幂等键，在重试前确定首次尝试是否已经生效（原则 9）。
几轮之后，智能体提出两项变更：一是回滚近期的一次配置变更，后续动作可以对该回滚进行补偿；二是重启主节点，这一操作无法撤销。智能体运行框架会在操作效果超出运行时边界之前，将每项意图写入日志（原则 13）。它为回滚注册补偿操作，并将重启操作阻留在审批关卡，直到人工签字批准（智能体运行框架）；同时，它将这一不可逆的关键操作安排在所有可补偿步骤之后（原则 14；故障恢复）。如果进程在两项操作之间终止，恢复过程会读取日志并继续执行，而不会重复回滚。如果智能体开始反复发出失败的查询，进展检测机制会远早于预算耗尽时将其停止（原则 12）。
随后，智能体报告事件已解决，而这份报告也只是一项提议。验收依据来自运行时自行执行的检查：查询延迟在一段持续时间内恢复到目标值以下，错误率处于限定范围内，且配置差异与人工批准的内容一致。智能体评估 以这种方式评定轨迹，其记录的追踪信息将事件中的每个跨度连接成一份因果记录。
在线轨迹在验收时结束，但系统仍会继续处理它。由于轨迹已经通过验证，它便具备了被纳入整理的资格（轨迹整理）。微调以策略输出的词元为训练对象，并对策略读取的观测进行掩码处理（原则 17；轨迹微调）；在存在封闭检查机制的情况下，强化学习以该检查为优化依据，同时将验证器与策略隔离（原则 18；可验证奖励强化学习）。更新后的模型只有通过与其他变更相同的发布关卡，才能进入生产环境。这些操作都不会改变风险暴露。更好的模型会在完全相同的边界内提出更好的行动。
规模因素在两处发挥作用。如果事件涉及多个服务，智能体运行框架可以将各服务的诊断委派给子智能体，但前提是划分上下文或收缩权限带来的收益足以抵偿协同开销（原则 19；多智能体协同），且每个子智能体只能获得父智能体权限、时间和预算的一部分（原则 21）。在整个集群层面，这条轨迹是计算每项通过验收的任务成本时的一个单元，而路由、缓存和容量决策的目标就是尽量降低这一成本（智能体经济学）。
表 1 将上述演练归纳为责任主体及其记录。该演练还跨越了引言中划定的在线工作与跨任务工作之间的界线（跨任务集群基础设施）。验收之前的所有工作均由在线责任主体负责，它们持有轨迹的时间为数秒至数小时。整理、训练、发布把关和集群资源配置则由跨任务基础设施负责，它们以数小时至数天的时间尺度处理已经结束的轨迹。
| 状态转换 | 负责子系统 | 留下的记录 |
|---|---|---|
| 任务获准接纳 | 智能体运行框架（智能体运行框架） | 轨迹记录、日志中的契约条目 |
| 上下文准备就绪 | 上下文组装（上下文工程） | 上下文清单，注明每个片段的来源 |
| 提案已生成 | 模型调用（基座模型） | 结构化工具调用及停止原因 |
| 调用通过校验并获授权 | 工具层（工具调用） | 模式校验结果、授权决策、幂等键 |
| 效果已执行 | 沙箱（智能体沙箱） | 已确定的执行结果，其意图在分派前已记入日志 |
| 不可逆步骤获批 | 审批关卡（智能体运行框架） | 与确切提案绑定的签名批准记录 |
| 崩溃或错误操作 | 恢复（故障恢复） | 恢复点、补偿条目 |
| 交付物获验收 | 评估（智能体评估） | 检查结果及串联所有片段的追踪记录 |
| 轨迹用于训练 | 数据筛选（轨迹整理） | 接纳决策及其归入的数据划分 |
每一行都遵循不变量闭合原则（不变闭包原则）。运行时通过预算、授权、审批关卡和沙箱，以机械方式闭合任务的边界；该原则中端到端的另一半则支配验收，因为模型的任何报告都无法证明任务已经完成。只有运行时实际执行的检查才能证明这一点，而 闭合证据等级 则对各类检查的价值作出了排序。
原则总表
时域、状态和权限再次一同出现，运行时在同一条轨迹上逐一将其闭合。
本卷的每一项原则都在这一架构中占有一席之地，表 2 按照本书引入这些原则的顺序将其汇总，并列出每项原则所闭合的风险敞口。第 I 部分的原则衡量单次模型调用的成本，并界定检查能够证实的范围。第 II、III 和 IV 部分的原则闭合了单次调用所不具备的三类风险敞口：跨轮次携带的状态、对外部世界的权限，以及足以让错误累积的时域。第 V 部分改变模型，但不改变任何风险敞口；第 VI 部分使这三类风险敞口在多个智能体和多条轨迹间成倍增加；第 VII 部分的原则则标明机器无法自行闭合的部分。
| # | 原则 | 部分 | 所闭合的风险敞口 | 不变量简述 |
|---|---|---|---|---|
| 不变闭包原则 | 不变量闭合 | 引言 | 全部三类（闭合要求） | 约束绝不依赖模型；边界由模型下层的机制闭合，验收由模型上层的证据决定 |
| 1 | 内存带宽受限的解码 | I | 无（衡量单次调用的成本） | 批大小为一时，每个词元的延迟等于权重字节数除以内存带宽 |
| 2 | 受证据约束的审思 | I | 无（受证据约束） | 额外的推理计算只有在获取到能够区分候选项的证据时才有帮助 |
| 3 | 验证的不对称性 | I | 闭合证据 | 声称做过检查成本很低，而可靠的验证成本高；提交关卡是一项封闭的确定性检查 |
| 隔离不变量 | 隔离不变量 | I | 无（单次调用） | 状态不是 COMPLETED 的载荷绝不会进入验证、编译或执行环节 |
| 4 | 上下文是经选择的工作集 | II | 状态 | 每次调用只看到有界的选定内容，压缩时不丢失标识符 |
| 5 | 注意力状态由词元前缀派生 | II | 状态 | KV 缓存是确切前缀的函数，只能从左侧起复用，并且始终可以重建 |
| 6 | 检索是一项契约，而非召回 | II | 状态 | 持久化数据只能通过带类型的检索契约重新进入上下文；相似性不等于许可 |
| 7 | 权威性始终属于源头 | II | 状态 | 只有源制品具有权威性；每次写入都会使所有派生视图过时 |
| 8 | 带类型的动作契约 | III | 权限 | 工具调用只有作为经过校验并获授权的带类型提案，才能到达环境 |
| 9 | 重试前先确定执行结果 | III | 权限，同时涉及时域 | 超时无法说明变更是否已经发生；只有确定执行结果后才能重试 |
| 10 | 模型下层的遏制机制 | III | 权限（完整性与机密性） | 每个动作都在由下层机制强制执行的边界内运行，通过销毁来重置，并对向外传输进行控制 |
| 11 | 轨迹级封装 | IV | 时域 | 轨迹保存在运行时拥有的 ACB 中，是调度、预算分配和保护的基本单位 |
| 12 | 带外抢占与进度看门狗 | IV | 时域 | 控制、预算和进度判断均位于模型之外 |
| 13 | 意图先于效果 | IV | 时域（状态体现为持久性） | 授权某一效果的记录持久化之前，该效果不得离开主机 |
| 14 | 枢轴边界与补偿 Saga | IV | 时域（权限体现为顺序约束） | 先注册补偿操作，只允许一个不可逆的枢轴步骤，并将其排在最后 |
| 16 | 基于已验证轨迹的后训练 | V | 均不改变（改变模型） | 权重变更是最后一级手段，以经过外部验证的轨迹进行训练 |
| 17 | 观测损失掩码 | V | 均不改变 | 损失仅覆盖策略输出的词元；观测保留在上下文中，但不计入损失 |
| 18 | 以隔离的验证器为依据的强化学习 | V | 均不改变 | 检查奖励什么，训练就会学到什么；应隔离验证器，并留出测试集 |
| 多智能体评估的三轴前沿 | 三轴多智能体评估前沿 | VI | 全部三类，成倍增加 | 在相同预算下，一种拓扑在质量、总完工时间和每个获验收任务的成本上都必须不劣于比较基准 |
| 19 | 协同开销 | VI | 全部三类，成倍增加 | 拆分任务只有通过任务分区、风险衰减或独立探索才能获得收益 |
| 21 | 单调委派 | VI | 跨智能体的权限 | 子智能体的权限、时间和预算必须是父智能体剩余持有资源的子集 |
| 15 | 发布的因果证据与统计证据 | VI | 集群规模的闭合证据 | 发布以统计判据把关，依据是由同一条因果追踪记录串联的、经过验证的状态变化 |
| 22 | 轨迹有效吞吐量与获验收任务 | VI | 集群成本 | 只有经过验证的轨迹才能交付价值；集群应最小化每个获验收任务的成本 |
| 23 | 轨迹生命周期容量与尾部感知调度 | VI | 集群规模的时域 | 按轨迹并发量配置容量，并在利用率拐点以下运行 |
| 24 | 规约边界 | VII | 机器之外 | 智能体可以实现设计，但无法制定支配自身的契约 |
将这种归属关系形式化，首先需要明确每条轨迹运行所遵循的契约。
工作负载契约规范
分级升级边界可防止灾难性的预算超支，同时维持正常运行时的自主处理吞吐量。
当一个不受约束的智能体运行时收到开放式自然语言提示，例如“修复仓库中的集成测试失败问题”时，宿主监督器会立即面临边界判定困境。由于缺少对运行限制的明确规定，底层基础模型会进入无引导的自回归循环：通过修改测试断言本身来处理含义不明的测试失败，通过不加节流的搜索查询耗尽外部 API 的速率限额，或者陷入无休止的语法修正循环，产生未建立索引的构建产物并耗尽宿主磁盘容量。由于运行时监督器缺少对允许行为的形式化规范，它无法判断连续三十次编译尝试究竟是在进行有效的迭代改进，还是已陷入无法恢复的失败循环，直到操作人员手动终止进程。
设计智能体系统，首先要明确由五部分组成的任务契约，以及根据任务的 H·S·A 暴露与闭合证据确定其定位的四个问题。契约来自 五部分契约规范，问题来自 四个问题的定价。本节探讨当整个架构同时运行时，强制落实每个字段所需付出的代价。
从暴露到可强制执行的边界
上述每个问题都会转化为一项边界，由运行时在分配计算资源或配置沙箱之前强制执行。时间跨度转化为三项上限。墙钟超时 \(T_{\max}\) 可防止挂起的连接、死锁的编译器和缓慢的推理工作进程长期占用沙箱。轮次上限 \(H_{\max}\) 限制模型与环境之间的往返次数，因为生成过程没有内在的停止条件，持续发出有效工具调用的循环可以无限运行。覆盖预填充和解码阶段的累计 token 上限 \(M\) 可防止任务通过在每一轮用检索结果载荷填满上下文来规避预算限制。
状态通过明确的写入边界来界定：这些边界区分了临时工作记忆（上下文缓冲区及其 KV 缓存）、记录每一次模型输出、工具载荷、返回码和运行时干预的持久日志，以及任务所修改的权威性工件，从而确保暂存存储器中的推理绝不会被误认为实际修改。权限则体现为有效期限定于任务生命周期的能力令牌、工具白名单、挂载命名空间和出站流量规则，以及在经身份验证的人类签署授权之前暂缓执行任何不可逆操作的托管机制。完成证据则体现为宿主能够求值的确定性谓词，例如编译器和代码检查工具的退出码均为零、结构化测试日志、AST 不变量检查，以及所生成工件的哈希值。如果宿主无法对这样的谓词求值，那么无论模型如何报告，都不能认定任务已完成。
粗略估算 0.1: 确定物理运行边界的规模
给定参数：
- 轮次上限：\(H_{\max} = 20\text{ turns}\)。
- 实际时间超时限制：\(T_{\max} = 600\text{ s}\)（{python} SizingPhysicalOperatingEnvelope.timeout_min_str）。
- 模型参数：{python} SizingPhysicalOperatingEnvelope.params_str 个以 FP8 表示的稠密参数（\(70 \times 10^9\text{ bytes} \approx\) {python} SizingPhysicalOperatingEnvelope.model_weights_str 模型权重）。
- 服务架构：在 {python} SizingPhysicalOperatingEnvelope.n_gpus_str 个 GPU 上采用张量并行，使用 FP8 KV 缓存，包含 {python} SizingPhysicalOperatingEnvelope.n_layers_str 层，每层有 {python} SizingPhysicalOperatingEnvelope.n_kv_heads_str 个键值头，头维度为 \(d_k = 128\)。
- 最大上下文窗口：\(L_{\max} = 32{,}768\text{ tokens}\)。
- 本地构建环境：增量 C++ 编译需要 \(4\text{ vCPUs}\)、{python} SizingPhysicalOperatingEnvelope.host_dram_str 主机 DRAM，以及在只读根仓库快照之上的 {python} SizingPhysicalOperatingEnvelope.disk_overlay_str 写时复制（CoW）磁盘覆盖层。
步骤 1：计算每个实例的 KV 缓存内存占用 每个 token 在所有层上的 KV 缓存所需内存为： \[\text{Bytes per token} = 2 \times (\text{layers}) \times (\text{KV heads}) \times d_k \times (\text{bytes per element})\] \[\text{Bytes per token} = 2 \times 64 \times 8 \times 128 \times 1\text{ byte} = 131{,}072\text{ bytes} = 128\text{ KB/token}\] 在最大上下文长度 \(L_{\max} = 32{,}768\) 下： \[\text{Max KV Cache Size} = 32{,}768 \times 128\text{ KB} = 4{,}194{,}304\text{ KB} = 4.0\text{ GB}\] 分摊到 {python} SizingPhysicalOperatingEnvelope.n_gpus_str 个服务 GPU 上，KV 缓存每个 GPU 需要占用 \(1.0\text{ GB}\)，与分片后的模型权重（\(17.5\text{ GB/GPU}\)）共同存储时，仍处于标准高带宽内存（HBM）的容量余量之内。
步骤 2：计算推理和沙箱执行的最大延迟预算 假设每轮平均生成 \(256\text{ tokens}\)，解码吞吐量为 \(40\text{ tokens/s}\)（解码时间为 \(6.4\text{ s}\)），而对平均长度为 \(16{,}384\text{ token}\) 的提示进行预填充需要 \(0.8\text{ s}\)。每轮模型推理的总延迟为 \(7.2\text{ s}\)。 在 \(H_{\max} = 20\) 轮中，模型总耗时为： \[T_{\text{model}} = 20 \times 7.2\text{ s} = 144\text{ s}\] 由此剩余： \[T_{\text{sandbox}} = T_{\max} - T_{\text{model}} = 600\text{ s} - 144\text{ s} = 456\text{ s}\] 将 \(456\text{ s}\) 分配到 20 轮中，每轮最多可用 \(22.8\text{ s}\) 进行容器化工具执行、文件系统差异比较和增量编译。如果中间测试运行超过 \(22.8\text{ s}\)，监督器的逐步看门狗会通知运行时限制测试套件的执行深度。
细化五部分契约
五部分契约规范 将契约写成一个五元组：
\[\mathcal{C} = \langle G, \mathcal{E}_{\text{env}}, \mathcal{A}_{\text{perm}}, \mathcal{O}_{\text{avail}}, \mathcal{K}_{\text{comp}} \rangle\]
在运行时实施该契约，需要将每个字段细化为智能体运行框架中的某个子系统能够检查的结构：
\[G = \left( \text{id}, \text{type}, \mathbf{p}, \Phi_{\text{inv}} \right)\]
目标 \(G\) 封装了唯一任务标识符 \(\text{id}\)、任务类型、带类型的参数字典 \(\mathbf{p}\)，以及一组在整个轨迹中都必须保持不被违反的形式化不变式断言 \(\Phi_{\text{inv}}\)。关键在于，\(G\) 不提供关于如何解决任务的指令；它规定的是期望最终状态的数学性质。
\[\mathcal{E}_{\text{env}} = \left( \mathcal{I}_{\text{base}}, \mathcal{M}_{\text{mounts}}, \mathcal{R}_{\text{quotas}}, \mathcal{N}_{\text{network}} \right)\]
环境 \(\mathcal{E}_{\text{env}}\) 决定执行的物理底层。在这里，\(\mathcal{I}_{\text{base}}\) 指定容器基础镜像的不可变密码学摘要；\(\mathcal{M}_{\text{mounts}}\) 定义虚拟文件系统挂载表，指定哪些主机目录作为只读层暴露，哪些目录获得临时写时复制覆盖层；\(\mathcal{R}_{\text{quotas}}\) 对 CPU 份额、内存分配和磁盘写入 I/O 设置严格的 cgroup 限制；\(\mathcal{N}_{\text{network}}\) 定义网络路由表，除非特定代理端点被列入白名单，否则默认采用完全隔离的回环命名空间（\(127.0.0.1\)）。
\[\mathcal{A}_{\text{perm}} = \left\{ a_1, a_2, \dots, a_k \mid a_i = (\text{name}_i, \Sigma_i^{\text{in}}, \Sigma_i^{\text{out}}, \rho_i) \right\}\]
允许的动作集合 \(\mathcal{A}_{\text{perm}}\) 枚举了所有可调用工具。每个动作 \(a_i\) 均由其标识符、严格的输入模式 \(\Sigma_i^{\text{in}}\)、带类型的输出模式 \(\Sigma_i^{\text{out}}\) 和能力策略 \(\rho_i\) 定义。能力策略规定速率限制、允许访问的文件系统路径，以及调用是否需要在执行前进行托管验证。尝试调用未注册的工具或传入未通过模式验证的参数，都会立即被监督器拦截。
\[\mathcal{O}_{\text{avail}} = \left( \Delta_{\max}^{\text{bytes}}, \Psi_{\text{filter}}, \Omega_{\text{encoding}} \right)\]
可用观测 \(\mathcal{O}_{\text{avail}}\) 规定如何将原始执行输出摄取到智能体的上下文中。不受控制的工具执行很容易产生数百兆字节的原始编译器输出或日志转储，瞬间超出上下文窗口限制并污染工作记忆。观测策略设定了绝对字节上限 \(\Delta_{\max}^{\text{bytes}}\)、主动净化过滤器 \(\Psi_{\text{filter}}\)（用于剥离 ANSI 转义码并屏蔽敏感凭据或环境机密），以及编码函数 \(\Omega_{\text{encoding}}\)（用于将结构化错误规范化为紧凑、机器可读的记录）。
\[\mathcal{K}_{\text{comp}} = \left\{ v_1, v_2, \dots, v_m \mid v_j: (\mathcal{E}_{\text{env}}, \text{Artifacts}) \to \{0, 1\} \right\}\]
完成标准 \(\mathcal{K}_{\text{comp}}\) 由确定性验证谓词组成的有序数组构成。每个验证器 \(v_j\) 都是外部二进制程序、脚本或静态分析器，独立于模型检查沙箱环境和生成的产物。任务成功要求所有验证器的合取结果为真：
\[\text{Success}(\mathcal{C}) \iff \bigwedge_{j=1}^{m} v_j(\mathcal{E}_{\text{env}}, \text{Artifacts}) = 1\]
此契约的结构字段、强制执行机制以及遗漏风险详见 表 3。
| 契约字段 | 数学域 | 监督器强制执行机制 | 缺失时的失效模式 |
|---|---|---|---|
| 目标 (\(G\)) | 结构体 \((\text{id}, \text{type}, \mathbf{p}, \Phi_{\text{inv}})\) | 分派验证与参数类型检查 | 语义漂移；无引导的目标变更 |
| 环境 (\(\mathcal{E}_{\text{env}}\)) | 容器/cgroup 规范 | Linux 命名空间、seccomp、cgroups v2 | 主机资源耗尽；文件系统污染 |
| 动作 (\(\mathcal{A}_{\text{perm}}\)) | 带类型的模式集合 \(\{a_i\}\) | RPC 网关过滤器与 JSON Schema 验证 | 任意代码执行；权限提升 |
| 观测 (\(\mathcal{O}_{\text{avail}}\)) | 变换流水线 \((\Delta, \Psi, \Omega)\) | 流截断器、正则表达式净化器、词元计数器 | 上下文窗口溢出；凭据泄露 |
| 完成 (\(\mathcal{K}_{\text{comp}}\)) | 谓词集合 \(\{v_j \to \{0,1\}\}\) | 隔离式测试运行器与 AST 验证器 | 假阳性的完成声明（幻觉） |
这一契约形式体系确立了计算机系统架构中所称的沙漏设计模式——类似于互联网协议（IP）在网络中或 POSIX 在操作系统中的作用。如 图 3 所示，受管轨迹接口契约构成了智能体计算栈的狭窄腰部。它将高层异构智能体工作负载（软件工程、云端事件修复、企业数据工作流、具身机器人以及集群群体）与多样化的底层运行时服务（准入调度器、存储层次结构、动作执行虚拟机监控器、预写持久性日志以及验证预言机）和物理硬件基底解耦。
沙漏模式的架构威力源于其形式化的接口分解。图 3 的上半部分涵盖了运行节奏迥异的多种智能体工作负载：执行快速编译器循环的交互式编码智能体、对分布式遥测级联事件进行分诊的云端 SRE 工作单元、处理关系数据变更的批量数据迁移流水线、在硬实时截止期限内持续传输感觉运动向量的具身机器人，以及执行共识投票的分布式集群群体。每种工作负载都映射到同一个狭窄的腰部，即受管轨迹，从而无需各应用自行构建内存管理和沙箱虚拟化机制；运行时将该轨迹的智能体控制块作为一个整体进行调度、预算分配和保护（原则 11）。沙漏的下半部分将这一规范表示转化为具体的系统服务：管理队列优先级及预填充/解码分离的准入调度器，在主机 DRAM 与加速器 HBM 之间对 KV 块进行分页调度的内存子系统，强制执行 seccomp 过滤器和 \(W \oplus X\) 策略的动作中介，提交 WAL 帧和补偿性 Saga 账本的持久化引擎，以及依据物理硬件约束验证结果谓词的确定性验证预言机。
生产运行包络
实例化的契约定义了执行的正常路径，但鲁棒的系统工程还需要一个运行包络，即智能体被保证能够正常工作的边界，以及在越过该边界时采用的确定性升级处置策略。任务的 H·S·A 位置（H·S·A 暴露面）在运行包络中转化为运行时配置。跨度 \(H\) 受目标 \(G\) 所附带的轮次、时间和 token 上限约束。任务携带的状态 \(S\) 由环境 \(\mathcal{E}_{\text{env}}\) 划分，并由观测策略 \(\mathcal{O}_{\text{avail}}\) 过滤。权限 \(A\) 在运行时完全中介下，由允许的动作集合 \(\mathcal{A}_{\text{perm}}\) 确定。完成标准 \(\mathcal{K}_{\text{comp}}\) 并非第四个风险暴露维度。它们规定验收所需的闭环证据等级，该等级随其他三个维度的提升而提高。
如 图 4 所示，主机监督器通过持续监测执行过程是否满足四个明确的不变量子卡中的要求，实施完全中介：当前资源预算（\(B\)）、错误上限（\(\kappa\)）、沙箱约束参数，以及持久化审计账本（WAL）。任何运行阈值一旦被超出，红色边界触发器就会将控制权直接移交给确定性升级处置分派器。分派器会调用针对特定故障模式的缓解例程，避免系统盲目崩溃或让异常执行消耗无限的集群资源：当工具错误超过 \(K\) 时，使计划缓存失效并强制重新读取暂存存储器；当交互轮次达到 \(H_{\max}\) 时，停止实时 token 生成并隔离智能体控制块（ACB）状态；在实际经过时间超过时限时，使用 SIGKILL 终止失控进程，其超时阈值为 \(T_{\max}\)；当影响范围较大的命令需要人工授权时，将状态托管于内存并暂停后续执行。
运行包络由四项硬阈值指标约束：
- 连续错误上限（\(K\)）： 如果智能体连续执行 \(K\) 个动作，且这些动作均返回非零退出码、格式错误的工具参数或模式验证错误，监督器就会判定模型已进入退化的自回归循环。运行时会停止推测性工具分派，向上下文注入高优先级诊断帧，并强制模型先评估中间状态，再发出下一次工具调用。
- 轮次上限（\(H_{\max}\)）： 模型与环境之间往返交互次数的硬性限制。当轮次计数达到 \(H_{\max}\) 时，无论模型是否声称即将完成任务，监督器都会发出不可屏蔽的终止信号。
- 实际经过时间看门狗（\(T_{\max}\)）： 在主机系统上运行的异步计时器。计时到期后，监督器会向容器沙箱发送
SIGKILL，对文件系统叠加层中的脏数据创建快照以供事后分析，并向编排器返回超时故障。 - 累计 token 上限（\(M\)）： 对会话期间消耗的输入和输出 token 总量设定严格上限，防止费用无止境增长或推理集群发生资源饥饿。
当执行中的智能体突破上述任一阈值时，系统会执行升级处理协议。监督器不会静默终止执行，而是沿着确定性的分级处置阶梯转换执行状态。轻微的边界越界，例如无效的 JSON 载荷或不存在的文件路径，会触发本地错误恢复，将确切的解析器错误作为观测反馈给模型。系统性的边界越界，例如超过 \(K\) 或达到内存上限，会触发状态挂起：运行时对沙箱文件系统创建快照，将故障向量记录到持久化 WAL 中，然后将工作区回滚到最近一个已知正常的检查点，或通过交互式托管关卡将会话提交给人工操作员。
| 工作负载原型 | 执行时域边界（\(T_{\max}, H_{\max}\)） | 状态层级与配额 | 权限（\(A\)） | 完成标准（\(\mathcal{K}_{\text{comp}}\)） |
|---|---|---|---|---|
| 封闭式补丁合成 | \(T_{\max} = 900\text{ s}\) \(H_{\max} = 25\text{ turns}\) |
短暂状态：\(4\text{ GB}\) KV 缓存 磁盘：\(5\text{ GB}\) CoW 覆盖层 主机：\(8\text{ GB}\) RAM，\(4\text{ vCPUs}\) |
\(A_1\)；仅限回环网络；仅允许向 /src 写入；禁止权限提升 |
干净构建（exit 0），已有测试通过，新增回归测试通过 |
| 批量数据迁移 | \(T_{\max} = 3600\text{ s}\) \(H_{\max} = 100\text{ turns}\) |
短暂状态：\(2\text{ GB}\) KV 缓存 磁盘：\(50\text{ GB}\) 暂存缓冲区 主机：\(16\text{ GB}\) RAM，\(8\text{ vCPUs}\) |
\(A_2\)；数据库端点白名单；源数据库只读；写入暂存模式 | 模式验证通过，零记录丢失（\(\sum \text{src} = \sum \text{dst}\)），校验和匹配 |
| 事故修复 | \(T_{\max} = 300\text{ s}\) \(H_{\max} = 10\text{ turns}\) |
短暂状态：\(1\text{ GB}\) KV 缓存 磁盘：\(512\text{ MB}\) 临时暂存区 主机：\(2\text{ GB}\) RAM，\(2\text{ vCPUs}\) |
\(A_3\) 受托管机制约束；限定范围的遥测 API；指标只读；可更改状态的 CLI | 满足遥测健康不变量；错误率 \(< 0.01\%\)；经签名的人工令牌 |
| 文献综合 | \(T_{\max} = 1200\text{ s}\) \(H_{\max} = 40\text{ turns}\) |
短暂状态：\(8\text{ GB}\) KV 缓存 磁盘：\(10\text{ GB}\) PDF/向量存储 主机：\(8\text{ GB}\) RAM，\(4\text{ vCPUs}\) |
\(A_1\)；出站访问白名单仅包含 arXiv/PubMed API；允许写入本地向量索引 | 符合模式的 JSON 报告；所有提取的 DOI 引用均通过 CrossRef 核验 |
如 生产运行边界 所示，不同的运行原型需要截然不同的运行边界配置。封闭式补丁合成工作进程在严格的封闭隔离条件下运行，完全没有外部网络连接，仅依靠本地编译器和确定性单元测试来建立正确性证据。相比之下，事故修复智能体所处的环境离不开实时网络遥测，但任何写入操作的影响范围都可能造成灾难性后果；因此，其权限边界严格禁止无人监督的状态变更，要求任何更改状态的修复命令都必须获得人工密码学托管授权。
通过建立五部分契约，并在运行时强制执行其运行边界，系统工程师将原本不可预测的神经自回归模型转变为大型生产基础设施中一个行为有界、可追责的组件。随着契约将执行边界和状态生命周期形式化，架构挑战转向内存：在执行过程中，系统如何在这些短暂、持久和权威层级之间，从物理层面组织、移动和保存信息？
内存层次结构综合
当自主编码或重构智能体经历数十轮迭代执行时，状态损坏很少源于 Transformer 多头注意力计算中的数学错误。相反，它源于未协调的内存边界之间悄然发生的缓存分歧。设想一个负责更新企业软件服务的智能体：在第 4 轮，智能体调用外部工具，重构头文件中的一个核心数据结构。文件系统快照立即更新，确立了新的权威真实状态。然而，除非宿主监督器强制实施主动缓存一致性协议，否则系统就会进入脑裂状态。智能体的逻辑工作上下文仍保留着第 1 轮提取的修改前代码片段；推理服务引擎保留着已失效提示前缀的预计算键值（KV）缓存激活；外部检索索引则继续返回表示已废弃方法签名的向量嵌入。在下一轮中，模型以自回归方式生成差异补丁，其目标是磁盘上已不存在的标识符。当编译器拒绝这一幻觉生成的差异补丁时，智能体又生成更多推测性的补救修改，使错误在各层之间不断累积，直至达到交互轮数上限 \(H_{\max}\) 或耗尽词元预算 \(M\)。
端到端设计为选定的上下文、物理 KV 状态、权威制品以及持久化索引或日志分配不同的所有权和生命周期规则。 在智能体计算架构中，不能将内存建模为同质的扁平缓冲区或非结构化的仅追加聊天历史。鲁棒的执行要求在明确的所有权域、确定性的失效协议和密码学溯源保障下，整合四个不同的物理与逻辑状态层，涵盖易失性的加速器高带宽内存（HBM）、宿主 DRAM、持久化检索索引和持久化文件系统制品。
Alan Jay Smith 关于缓存存储器的奠基性综述（1982 年）表明，分层存储系统通过利用空间局部性和时间局部性，营造出单一、速度均一且快速、容量无限的内存空间这一假象。在智能体机器学习系统中，这一层次结构弥合了微秒级加速器张量内存与持久化、权威的外部环境之间，在性能和易失性方面存在的数量级差距。
状态层次结构的生命周期
智能体系统的内存架构可分解为四个独立层，每一层都具有不同的延迟特征、物理介质、存储容量和运维责任主体。当运行时设计者模糊这些层之间的边界，将派生的搜索索引视为权威状态，或假定物理加速器缓存会自动跟踪外部环境中的变更时，系统就会崩溃。
第一层是逻辑工作上下文，以离散的字节对编码（BPE）词元计量。该层构成直接呈现给基础模型、供其下一次前向传播使用的活跃证据窗口。逻辑上下文在编排期间驻留于宿主系统内存中，并严格受模型的物理序列长度限制 \(L_{\max}\) 和任务契约的活跃窗口预算 \(S_{\max}\) 约束。逻辑上下文完全由宿主智能体监督器运行时持有，具有临时性，并可在各轮之间修改。监督器通过结构化压缩、滑动窗口截断、观测过滤和工作集选择，持续调整这一缓冲区。逻辑上下文并不代表持久化存储；它是一个临时且高度选择性的视窗，用于查看任务更广泛的历史轨迹和环境状态。
第二层是物理键值（KV）缓存，由连续的浮点激活张量（\(\mathbf{K}, \mathbf{V} \in \mathbb{R}^{B \times L \times H \times d_k}\)）组成，分配在推理服务引擎（如 vLLM 或 SGLang）的高带宽内存（HBM）和宿主 DRAM 中。逻辑上下文表示离散的符号词元，而物理 KV 缓存则将预填充阶段（GEMM）在每个注意力层中计算出的中间线性投影具体存储下来。该层完全由推理服务引擎持有，而非智能体监督器，并针对高吞吐量的张量并行执行进行了优化。现代运行时通过 PagedAttention 管理这些张量，将不连续的物理内存页映射到逻辑序列位置，并将多轮对话组织为基数树前缀层次结构，以支持零拷贝前缀共享。物理 KV 块的生命周期与任务逻辑解耦：这些块可被动态保留、经 PCIe 总线换页，或在 GPU 内存池承受压力时按最近最少使用（LRU）策略被逐出。
第三层由权威外部制品构成，代表外部环境的绝对真实状态。这一层包括纳入版本控制的目标软件仓库、生产数据库表、容器化文件系统以及运行中的操作系统进程。权威制品存放在持久性非易失介质上，例如本地 NVMe 阵列或分布式云存储。与模型内部表示不同，权威制品在智能体重启后仍然保留，且严格只能通过沙箱内受中介管控的工具执行操作来修改，因为模型不具有任何隐式权限。宿主监督器必须将这一层视为判断任务完成与否的唯一事实来源；候选补丁、生成的报告或拟议的数据库修改，在依据这些权威记录完成验证之前，都只是未经证实的候选结果。
第四层由派生检索索引与日志构成。这一层涵盖稠密向量存储（例如分层可导航小世界图和倒排文件量化器）、稀疏词法倒排索引（例如 BM25）、结构化代码属性图（AST 依赖数据库），以及运行时的仅追加预写日志（WAL）。这些结构由宿主监督器的存储与检索子系统管理，是从历史执行轨迹和权威制品快照中派生的次级表示。支配这一层的规则是：权威性始终归属于源数据（原则 7）。派生索引本身不具有任何权威性，其存在仅用于加速大规模语料上的近似召回。因此，当权威制品发生变化时，由其派生的每个索引条目都会过时，必须在下一次调用读取它之前使其失效或重新建立索引。这四个层级的特征、延迟范围和驱逐策略汇总于 综合内存层级。
| 内存层级 | 存储介质 | 易失性与生命周期 | 所属子系统 | 驱逐与压缩策略 | 缓存失效协议 | 访问延迟范围 | 容量上限 |
|---|---|---|---|---|---|---|---|
| 逻辑工作上下文 | 宿主 DRAM / 编排器堆 | 短暂存在；每轮重建 | 宿主智能体监督器 | 语义压缩、滑动窗口、观测过滤 | 环境状态变更时同步重写 | \(\le 1\,\text{ms}\)（词元组装） | \(L_{\max} \le 128\text{k}\text{ tokens}\) |
| 物理 KV 缓存 | 加速器 HBM / 宿主 DRAM | 易失；生命周期受推理会话限制 | 推理服务引擎 | 分页内存分配、基于基数树的 LRU 前缀驱逐 | 通过前缀哈希失效断开树节点 | \(10\text{ ns}\)（HBM）/ \(50\text{ ns}\)（PCIe） | GPU HBM 容量（\(80\text{--}192\,\text{GB/GPU}\)） |
| 权威制品 | NVMe SSD / 分布式文件系统 | 持久；跨运行永久保留 | 外部环境 / 沙箱 | 显式任务清理、沙箱销毁 | 通过文件系统监视器发送外部变更通知 | \(10\,\mu\text{s}\text{--}10\,\text{ms}\)（I/O） | TB 级 / 卷配额 |
| 派生索引与日志 | NVMe / 映射内存 / 云数据库 | 持久；生命周期跨越多个项目 | 索引子系统 / WAL 引擎 | 墓碑压缩、定期索引重聚类 | 直写墓碑、异步后台重建索引 | \(2\text{--}50\,\text{ms}\)（图 / ANN 查询） | 无固定上限 / 可扩展至多 TB |
跨层缓存一致性
在经典共享内存多处理器架构中，缓存一致性由专用硬件逻辑强制保障。正如 Leslie Lamport（1979）所形式化阐述的，在并发执行实体之间维持顺序一致性，需要遵守一条不可妥协的规则：所有进程都必须以全局一致的顺序观察到变更。在硬件对称多处理（SMP）系统中，每当处理器向某个共享内存地址发出写事务时，总线侦听机制和基于目录的协议（例如 MESI）就会向 L1 和 L2 缓存广播失效信号。
在智能体计算机中，这种由硬件介导的安全保障并不存在。核心计算引擎——自回归基础模型——是一个无特权、无状态的推理例程。一旦输入被切分为词元并投影为加速器 HBM 中的物理 KV 激活，神经网络就没有任何物理机制能够感知后台工具是否修改了磁盘上的源文件或更新了外部数据库中的某一行。因此，四个层级之间的缓存一致性必须完全由宿主监督器内部的软件协议来协调（图 5）。
如 图 5 所示，该内存架构通过将存储组织为四个同步层，消除了高速加速器张量与持久外部状态之间的阻抗失配。上部的易失性层涵盖第 1 层（宿主堆中的逻辑工作上下文，通过动态压缩将序列长度限制在 \(L_{\max} \le 128\text{k}\) 个 token 以内）和第 2 层（跨加速器 HBM 和宿主 DRAM 的物理 KV 缓存，其中 PagedAttention 块表将虚拟 token 映射到物理页框，基数树则共享提示前缀）。在易失性层下方，中央宿主监督器一致性互连结构协调与持久层之间的数据流：第 3 层（Git 工作树和 microVM 覆盖层中的权威外部产物）和第 4 层（派生检索索引，例如 HNSW 向量数据库和 Tree-Sitter AST 图，以及仅追加的预写日志）。当智能体执行会修改权威外部产物的执行命令时，例如通过沙箱文件系统工具应用代码补丁，宿主监督器必须通过多阶段一致性流水线传播失效通知：
def on_artifact_mutation(event: MutationEvent, supervisor: AgentSupervisor) -> None:
# 1. Authoritative mutation committed to Write-Ahead Log
supervisor.wal.append_mutation(event.path, event.old_hash, event.new_hash)
# 2. Invalidate stale spans in the active logical working context
supervisor.context_manager.invalidate_paths({event.path})
# 3. Sever prefill prefix branches in inference engine Radix cache
prefix_hash = compute_prefix_hash(event.path, event.old_hash)
supervisor.inference_client.invalidate_prefix_cache(prefix_hash)
# 4. Mark tombstones on derivative vector and lexical retrieval indexes
supervisor.vector_index.tombstone_by_uri(event.path)
supervisor.retrieval_queue.schedule_async_reindex(event.path)一致性协议始于权威层。当工具修改某个制品时，沙箱会捕获该变更，计算变更前后字节内容的密码学摘要，并生成一条原子变更记录 \(\Delta = \langle \text{path}, \mathcal{H}_{\text{old}}, \mathcal{H}_{\text{new}}, \text{diff} \rangle\)。监督器截获该记录，并将其追加到不可变的预写日志中，同时附上单调递增的逻辑纪元计数器 \(e\)。
日志提交后，监督器执行逻辑上下文失效操作。上下文管理器检查当前已暂存、供模型生成使用的所有活动文本块。凡是元数据将其关联到 \(\text{path}\)，且所关联纪元为 \(e' < e\) 的文本块，都会被标记为过期。监督器不会任意清空整个上下文窗口，因为这会破坏宝贵的对话连续性和任务依据；它会有选择地将过期的上下文片段替换为结构化差异，或直接从已修改制品中读取的最新片段。
与此同时，监督器使物理加速器缓存失效。如果推理服务运行时通过基数树缓存提示前缀，以加速多轮预填充，那么与变更前词元序列对应的 KV 激活值此时便已失效。如果使用旧的前缀激活值运行模型，其自回归解码阶段就会以源自过期词元的隐藏状态为条件。监督器向服务引擎发送失效 RPC，其中包含已失效序列的前缀哈希值。服务引擎从前缀树中移除相应节点，释放物理 GPU 内存页以供重新分配，并强制推理引擎对更新后的上下文词元重新执行预填充计算。
最后，监督器确保各个派生检索索引的一致性。在单轮交互的延迟预算内，无法对数 GB 的代码同步重算稠密向量索引和词法存储。为解决这种时间上的不匹配，监督器以直写方式为所有与已变更 URI 匹配的索引条目设置墓碑标记。当智能体随后执行语义检索查询时，检索网关会过滤掉带有墓碑标记的分块，确保过时的嵌入向量绝不会被返回到活动上下文缓冲区。异步后台工作进程从重新索引队列中拉取已修改的文件，提取更新后的语法分块，计算新的嵌入向量，并在带外更新索引图。
粗略估算 0.2: 智能体层级中的缓存失效
系统参数：
- 模型架构：采用 FP8 精度的 Llama-3-70B（\(70 \times 10^9\text{ parameters} = 70\text{ GB}\) 权重）。
- 注意力结构：80 个 Transformer 层，采用分组查询注意力（GQA），包含 64 个查询头和 8 个键值头，头维度为 \(d_k = 128\)。
- 活跃序列长度：\(L = 32{,}768\text{ tokens}\)。
- 集群计算能力：节点 FP8 张量计算总峰值为 \(15{,}832\text{ TFLOPs}\)（每块 H100 为 \(1.979\text{ PFLOPs}\)）；预填充期间达到的模型浮点运算利用率（MFU）为 \(\eta = 0.50\)。
- 失效事件：在词元位置 \(4{,}096\)，一次源文件修改使提示前缀的剩余部分失效。
步骤 1：计算物理 KV 缓存占用量 对于 FP8 KV 缓存（\(b_{\text{elem}} = 1\text{ byte}\)），每个词元在所有层上的内存消耗为： \[M_{\text{token}} = 2 \times n_{\text{layers}} \times n_{\text{kv\_heads}} \times d_k \times b_{\text{elem}}\] \[M_{\text{token}} = 2 \times 80 \times 8 \times 128 \times 1\text{ byte} = 163{,}840\text{ bytes} = 160\text{ KB/token}\] 对于长度为 \(L = 32{,}768\text{ tokens}\) 的活跃上下文： \[M_{\text{total\_KV}} = 32{,}768 \times 160\text{ KB} = 5{,}242{,}880\text{ KB} = 5.0\text{ GB}\] 通过张量并行将 KV 缓存分布到 {python} CacheInvalidationAgentHierarchy.gpu_count_str 块 GPU 上后，每块 GPU 需要 \(0.625\text{ GB}\)，在 {python} CacheInvalidationAgentHierarchy.gpu_mem_str 的物理 HBM3 容量预算中，这一占比可以忽略不计。
步骤 2：比较缓存命中与失效时的预填充延迟 对于具有 \(N_{\text{tokens}}\) 的预填充输入，在参数量为 \(P = 70 \times 10^9\) 的模型上执行预填充阶段所需的理论浮点运算量约为： \[\text{FLOPs}_{\text{prefill}} \approx 2 \times P \times N_{\text{tokens}} = 1.4 \times 10^{11} \times N_{\text{tokens}}\] 系统的有效计算吞吐量为： \[\text{Throughput}_{\text{eff}} = 15{,}832 \times 10^{12}\text{ FLOPs/s} \times 0.50 = 7.916 \times 10^{15}\text{ FLOPs/s}\]
场景 A：基数缓存前缀命中（无失效）。 智能体在已缓存的 32k 提示后追加 512 个新的观测词元。只有这 512 个新词元需要预填充： \[T_{\text{hit}} \approx \frac{1.4 \times 10^{11} \times 512}{7.916 \times 10^{15}} = \frac{7.168 \times 10^{13}}{7.916 \times 10^{15}} \approx 9.05\text{ ms}\]
场景 B：前缀完全截断（缓存未命中）。 在词元位置 4,096 处编辑文件，会使其后的 \(28{,}672\) 个提示词元失效。加上 512 个新词元，引擎必须对 \(N_{\text{tokens}} = 29{,}184\) 重新进行预填充： \[T_{\text{miss}} \approx \frac{1.4 \times 10^{11} \times 29{,}184}{7.916 \times 10^{15}} = \frac{4.086 \times 10^{15}}{7.916 \times 10^{15}} \approx 516.2\text{ ms}\]
重新预填充带来的延迟代价为： \[\text{Slowdown} = \frac{516.2\text{ ms}}{9.05\text{ ms}} \approx 57.0\times\] 这一量化差异说明，要保持智能体的实时响应能力，就必须采用细粒度的前缀树切分和精准的上下文替换。
跨子系统衔接与权责归属
除层级内部的内存一致性之外，跨子系统边界还会引入关键的集成故障模式：各个组件虽然能通过隔离的单元测试，却在端到端执行中失败。当一条轨迹变成多条轨迹时，第五个衔接点便出现了。本书中的预算具有嵌套关系。单次调用上限约束一次模型调用（基座模型），单次决策预算约束测试时搜索（测试时计算），单条轨迹预算约束循环（智能体运行框架），而资金预算则覆盖委派和集群（智能体经济学）。每个内层预算都必须处于外层预算的限额之内，委派时必须向下传递预算的一个子集，绝不能传递一份完整副本（原则 21）。如果将父智能体的全部授权和预算交给子智能体，就会在无人作出相应决策的情况下成倍增加风险敞口。
共享权重的智能体也会共享错误（多智能体协同）。三个子智能体对同一诊断达成一致，并不意味着它们提供了三份独立证据，因此，这种一致意见不能替代运行时执行的检查。表 4 汇总了这五个衔接点。
| 衔接处 | 各方测试均未发现的故障 | 相互牵制的原则 | 修复责任方 |
|---|---|---|---|
| 世界及其副本 | 基于已发生变化的源的过时视图构建提案 | 源的权威性与前缀复用 | 智能体运行框架，负责其派发的每一次写入 |
| 从提案到实际效果 | 重复或未记录的效果、注入的指令 | 类型化动作契约、结算、先记录意图再产生效果 | 工具层与日志，按固定顺序执行 |
| 恢复与权限 | 缺少所需授权的补偿操作 | 枢轴边界与衰减后的授权 | 恢复机制，在注册正向动作时一并注册权限 |
| 从日志到模型 | 钻认证检查空子的策略 | 发布证据与针对验证器的强化学习 | 数据整理与评估，将验证器保留在训练之外 |
| 智能体之间 | 委派使风险暴露成倍增加、投票相关联 | 协同开销与单调委派 | 执行委派的智能体运行框架与集群预算 |
来源追踪
自回归模型的一项核心弱点是，无法仅凭符号布局辨别语义上的权威性。外部数据无论来自可信的系统契约、权威源文件、未经验证的用户评论，还是对抗性网页载荷，一旦经字节对编码解析为线性的词元 ID 序列，所有词元就会在数学上以同等地位进入 Transformer 的自注意力矩阵。注意力机制不加区分地对整个提示中的词元计算两两缩放点积。如果检索到的网页片段包含对抗性的提示注入字符串，那么在没有带外架构机制介入的情况下，模型就无法区分合法的系统提示指令与嵌入的恶意载荷。
为维持不变量的闭包性并防止权限提升，内存层次结构必须对所有工作词元实施基于密码学的来源追踪。宿主监督器为注入当前逻辑上下文的每个连续词元片段封装一个不可变的来源描述符。
设当前逻辑上下文序列 \(\mathbf{x} = [t_1, t_2, \dots, t_N]\) 被划分为互不重叠的连续区段。监督器维护一份辅助的带外来源账本 \(\mathcal{P}\)，其定义为从每个词元区间 \([i, j]\) 到形式化来源元组的映射：
\[\mathcal{P}([i, j]) = \left\langle \text{uri}, \mathcal{H}_{\text{content}}, \text{epoch}, \tau_{\text{trust}}, \sigma_{\text{sig}} \right\rangle\]
在该元组中，\(\text{uri}\) 指定权威源制品的规范统一资源标识符（例如，git://repo@sha256:src/parser.c#L45-L80 或 sandbox://proc/104/stdout）；\(\mathcal{H}_{\text{content}} = \text{SHA-256}(\text{bytes})\) 记录摄取时原始源数据的密码学摘要；\(\text{epoch}\) 记录逻辑环境时钟；\(\tau_{\text{trust}}\) 分配明确的安全权限分类；\(\sigma_{\text{sig}}\) 表示由可信验证预言机或人工监督者签发的可选密码学签名。
信任分类 \(\tau_{\text{trust}}\) 将内存区段划分为四个形式化安全环：
- \(\text{AUTHORITATIVE}\)：不可变的任务契约规范、系统边界约束，以及从封闭沙箱中直接检查过的已验证文件。
- \(\text{DERIVATIVE}\)：由可信内部流水线生成的摘要、AST 索引查询结果和语义向量。
- \(\text{EPHEMERAL}\)：智能体的中间暂存存储器词元和尚未提交的内部推理步骤。
- \(\text{UNTRUSTED}\)：从外部网页搜索、第三方问题跟踪系统或未经验证的用户输入中摄取的任意输入。
这份来源账本使监督器能够在动作边界实施数据流防火墙。当模型输出动作提案 \(a_t = (\text{tool}, \text{args})\) 时，监督器的解析器并非仅检查 args 的语法，而是通过注意力分布，将构成拟议参数的词元追溯到它们在 \(\mathcal{P}\) 中的来源。如果针对可修改状态的工具（如 execute_shell 或 write_file）的动作提案主要源自标记为 \(\text{UNTRUSTED}\) 的上下文区段，监督器就会拦截执行。由于模型不持有任何隐式权限，运行时会拒绝执行该动作，或将其转入隔离沙箱，从而防止间接提示注入攻击劫持宿主控制流。
此外，来源追踪为可验证的完成证据提供了实证基础。当智能体发出任务契约已满足的信号时，监督器会查询来源账本，以验证交付物是否以权威工件为依据。如果完成声明引用的文件哈希与磁盘上的实时状态不匹配，或依赖从已失效的纪元（\(e' < e_{\text{current}}\)）中推导出的假设，监督器就会拒绝确认完成，并强制重新评估。
建立明确分区、保持一致且可通过密码学确定来源归属的内存层次结构，可确保无特权的神经推理引擎严格以新鲜、真实的证据作为其自回归解码循环的条件。然而，仅靠结构化记忆既无法改变外部世界，也无法保护宿主基础设施免受格式错误的操作、失控循环或恶意副作用的影响。要将经过验证的上下文转化为安全、持久的现实世界效果，智能体架构需要一个执行框架，能够通过类型化解析、细粒度能力检查、隔离执行虚拟化、持久日志记录和可补偿事务管理，对模型的每次输出进行中介处理。下文将综合阐述这些防御边界如何组合成端到端执行流水线，以及为何绝不能将多步骤智能体轨迹视为单个原子事务。
执行框架综合
当无特权的基础模型生成一个操作字符串，提议删除云资源、编译不可信的 C 库或提交会改变外部系统状态的 API 请求时，若将这段原始生成文本视为具有权威性的远程过程调用，就可能导致灾难性的系统故障。在开环采样下运行的随机词元预测引擎可能输出语法无效的工具调用、幻觉出不存在的 shell 标志、构造会触发命令注入的 shell 参数，或陷入针对第三方网络端点且无法取得进展的重试循环。此外，现实世界中的分布式副作用无法封装在一个原子数据库事务内；一旦网络套接字传输了 HTTP 数据包，或外部数据库提交了更新，就无法通过两阶段提交来回滚物理世界的状态（\(2\text{PC}\)）。
执行框架将解析、权限、隔离、持久化的意图与效果记录、观测和恢复连接起来，使每一道边界都可接受测试；跨越外部系统的轨迹并非一个原子事务。 执行框架构成了宿主监督器的防御边界。它将模型视为不可信的提议者，模型不具有任何隐式权限。通过在候选词元生成与实际操作之间插入一条确定性的六阶段流水线，执行框架确保每个副作用都经过类型化、获得授权、在实际操作前记入日志、被限制在隔离边界内、在返回时经过净化，并登记到仅追加的补偿账本中。
Jim Gray 于 1981 年发表的开创性论文《事务概念：优点与局限》表明，尽管原子性、一致性、隔离性和持久性（ACID）事务这一抽象简化了数据库系统，但跨越自主管理域的现实世界分布式系统必须依赖消息契约、日志记录和补偿操作，而非全局分布式锁。
集成的六阶段执行流水线
正如 图 6 中所形式化描述的，执行框架的运行核心是一条线性的六阶段确定性中介流水线。无特权基础模型提出的每个候选工具调用输出，均以提示上下文 \(c_t\)（其中包含任务契约 \(\mathcal{C}\)）为条件，并且必须依次通过每一道确定性防御边界：(1) 在 logit 层面使用下推自动机进行语法掩码，以保证在解码结束前符合模式要求；(2) 评估密码学能力令牌和预算令牌，确保只有获准的操作才能运行；(3) 将意图同步写入非易失性存储中的预写日志（fsync）；(4) 在只读写时复制（Copy-on-Write）覆盖层和 seccomp-bpf 系统调用过滤器的约束下，在隔离的 MicroVM 沙箱中执行操作；(5) 对观测进行净化，强制落实 \(W \oplus X\) 提示注入防火墙；(6) 将正向操作与补偿操作成对登记到 Saga 账本中。任何阶段的失败都会立即停止后续实际操作，将诊断事件记入日志，并构造包含充分信息的错误封装返回给智能体的工作上下文，同时避免宿主操作系统受到损坏状态的影响。
阶段 1：受语法约束的模型提案
防御边界始于自回归解码循环本身，先于工具分派。执行框架不会让模型先输出自由形式的文本再事后解析，而是在解码期间强制执行类型化动作契约中的模式约束部分（原则 8），具体通过 文法引导解码 中建立的融合式 GPU logit 掩码流水线实现，并将其中的授权部分留给阶段 2。1 在每个解码步骤 \(i\)，下推自动机将候选词元严格限制为有效的语法续接 \(\mathcal{V}_{\text{valid}} \subset \mathcal{V}\)，在 softmax 归约之前，于加速器 SRAM 中将无效的 logit 设为 \(-\infty\)。这使得候选提案尚未离开加速器内存，JSON 语法错误、右括号缺失和非法参数类型就已被消除。
1 硬件级语法掩码：如 文法引导解码 中所详述，下推自动机被编译为存储在 GPU 设备内存中的紧凑位掩码，直接在 SRAM 中施加 \(-\infty\) 惩罚，避免 CPU-GPU 同步停顿。
阶段 2：能力门控
语法有效并不意味着拥有操作权限。语法有效的动作提案 \(a_t = (\text{tool\_name}, \text{args})\) 一经解码，就会到达策略与能力门控。模型在宿主机上不持有任何隐式权限，因此，每项获准执行的动作都需要由监督运行时出示一个显式的、经过密码学签名的能力令牌（例如 macaroon 或限定作用域的授权令牌）。
能力门控执行三项强制检查：
- 作用域与边界验证： 门控检查 \(\text{args}\) 中编码的目标路径、网络端点和系统资源。如果正在执行隔离单元测试的智能体尝试访问
/etc/passwd或查询内部元数据 IP 地址（169.254.169.254），该请求就会被拦截并拒绝。 - 权限衰减委派： 能力令牌强制执行严格的权限衰减。如果父级协调器向工作智能体委派子任务时仅授予代码仓库只读权限，那么即使该工作智能体的提示声称拥有管理授权，它也无法执行会修改状态的工具。
- 人工托管与影响范围触发机制： 对于影响范围较大的动作，例如执行数据库模式删除、向受保护的 git 分支强制推送，或部署生产容器，门控会触发操作托管机制。执行过程让出控制权，持久化轨迹状态，并等待获得授权的人工操作员通过带外渠道提供密码学签名。
阶段 3：意图预写日志（WAL）
动作提案通过能力门控后，执行框架会在执行任何系统调用或发送任何网络数据包之前，向该轨迹的预写日志（WAL）提交一条不可变记录。这一顺序体现了意图先于效果的原则（原则 13），使恢复过程能够区分已提出的动作与已执行的动作。
运行时遵循预写日志这一经典系统设计原则，确保分布式环境中的崩溃一致性。如果宿主机监督程序在工具执行期间崩溃、断电或遭遇网络分区，恢复管理器会在重启时读取 WAL，以确定某个动作是仅被提出、正在执行，还是已获确认。日志记录包含一个不可变的意图元组：
\[\mathcal{J}_t = \left\langle t, \text{action\_id}, a_t, \text{hash}(\text{args}), \text{token\_id}, \text{status} = \text{COMMITTED} \right\rangle\]
通过强制显式执行 fsync，将 \(\mathcal{J}_t\) 写入非易失性存储，系统消除了孤立状态变更的可能性：外部系统的状态发生了变化，而智能体运行时却丢失了曾发起该命令的全部记录。
阶段 4：在沙箱化 MicroVM 中执行
意图提交到持久存储后，执行框架便将动作分派到隔离的执行沙箱中。在生产级智能体系统中，直接在宿主机运行时的容器内运行不受信任的代码或 shell 命令，是不可接受的安全漏洞；容器逃逸漏洞利用和命名空间污染很容易危及宿主基础设施。
由于隔离约束必须在被隔离代码的下层强制实施（原则 10），执行框架会在临时 microVM 或用户态内核沙箱（智能体沙箱）内运行命令。沙箱实施纵深防御隔离：
- 系统调用虚拟化与过滤： 客体内核在严格的
seccomp-bpf过滤器约束下执行，该过滤器将系统调用限制在最小白名单内，阻止原始套接字创建、模块加载或 ptrace 注入等危险操作。 - 隔离的网络命名空间： 动作执行在封闭的网络命名空间内进行。出站流量经由实施域名白名单策略的出口代理路由，以防止数据外泄和命令与控制通信。
- 写时复制（CoW）存储： 所有文件系统修改都发生在叠加于权威工作区之上的临时写时复制快照中。如果某次执行破坏了依赖项或写入了恶意二进制文件，底层根文件系统仍保持不变，且该快照可在毫秒内丢弃。
阶段 5：观测规范化
当沙箱化进程终止时，其原始输出（标准输出、标准错误、退出码和生成的文件）会返回运行框架。原始工具输出不能直接馈入基础模型的活动上下文窗口。不受约束的工具输出可能产生数兆字节的二进制数据，耗尽 token 预算 \(L_{\max}\)，或包含旨在颠覆智能体后续推理过程的提示注入攻击。
观测规范化层执行三项防御性转换：
确定性模式类型化： 将原始字节流解析为强类型观测记录：
\[\mathcal{O}_t = \left\langle \text{status}, \text{exit\_code}, \text{content}, \text{bytes\_truncated}, \mathcal{H}_{\text{digest}} \right\rangle\]
状态被严格限定为规范的运行时状态：
COMPLETED、TRUNCATED、REFUSED或TRANSPORT_FAILURE。token 预算截断与转存： 如果标准输出超出当前轮次的观测预算 \(L_{\text{obs}}\)，运行框架会保留数据流的头部和尾部，截断中间字节，将完整且未经删减的输出记录到外部制品存储中，并将一个基于密码学的 URI 引用注入 \(\mathcal{O}_t\)。
对抗性输入摄取过滤： 扫描内容中的 ANSI 转义码、终端控制序列和递归注入向量。任何可疑载荷都会被消除危害，并标注一个无特权的来源描述符（\(\tau_{\text{trust}} = \text{UNTRUSTED}\)）。
阶段 6：补偿 Saga 注册
流水线的最后一个阶段将动作的语义足迹记录到轨迹的分布式 Saga 账本中。如果已执行的工具修改了外部状态，例如创建临时分支、分配测试数据库或修改配置文件，运行框架就要求工具执行封装注册相应的补偿动作 \(c_t\)。
补偿动作表示正向动作在语义上的逆操作。正如 Hector Garcia-Molina 和 Kenneth Salem（1987）所形式化描述的那样，跨异构系统的分布式多步事务无法维持数据库式的可串行化。通过在持久存储中注册 \(c_t\)，执行框架保证：如果整体轨迹在第 \(t+k\) 轮失败，监督器就能执行后向恢复，按逆序 \((c_t, c_{t-1}, \dots, c_1)\) 调用补偿序列，将环境恢复到可接受的静止状态。完整的六阶段执行流水线总结于 表 5。
| 流水线阶段 | 架构职责 | 强制执行机制 | 主要应对的故障模式 | 恢复与隔离策略 |
|---|---|---|---|---|
| 1. 语法提议 | 保证工具模式有效性 | CFG / FSM logit 掩码 | 格式错误的 JSON、幻觉生成的标志参数 | 在 token 生成阶段零成本拒绝 |
| 2. 能力门控 | 强制实施最小权限 | 基于密码学的能力令牌 | 权限提升、命令注入 | 立即触发陷阱，升级至人工托管处理 |
| 3. 预写日志 | 确保崩溃一致性 | 仅追加的非易失性日志 | 宿主监督器崩溃、孤立修改 | 启动时重放与对账 |
| 4. 沙箱化执行 | 隔离不可信执行 | 临时 MicroVM、seccomp-bpf |
宿主失陷、容器逃逸 | 丢弃临时 CoW 快照 |
| 5. 观测规范化 | 防止上下文污染 | 截断、类型化、净化 | 上下文耗尽、间接注入 | 转存至对象存储、token 截断 |
| 6. Saga 注册 | 保证可补偿恢复 | 分布式 Saga 补偿日志 | 轨迹失败、部分状态修改 | 顺序执行逆操作 |
分布式 Saga 契约
朴素智能体系统设计中的一个核心谬误，是将智能体轨迹视为原子的、全有或全无的数据库事务。在理想的关系数据库中，多步操作受 ACID 保证约束：中间写入与并发事务隔离；如果第 10 步发生约束违反，数据库引擎就会中止事务，回滚第 1 至第 9 步，仿佛它们从未发生。
在与外部操作系统、开发者工具和分布式网络交互的智能体计算机中，普遍的原子隔离在物理上不可能实现。当智能体在 GitHub 上创建议题、在云服务提供商处配置虚拟机，或向共享仓库推送中间提交时，这些修改会立即对外部观察者可见。这些外部系统是自主的管理实体，不参与共享的两阶段提交协议。在本地基础模型思考下一步推理时，没有任何分布式锁管理器能够冻结 GitHub 或外部第三方 API 的状态。
由于轨迹是非原子且长期运行的，执行框架必须将其建模为 Hector Garcia-Molina 和 Kenneth Salem（1987）所提出的分布式 Saga。轨迹的 Saga 日志 \(\Lambda\)（该轨迹跨越 \(H\) 轮）将每个正向动作 \(a_i\) 与其补偿动作 \(c_i\) 配对：
\[\Lambda = \left\langle (a_1, c_1, o_1), (a_2, c_2, o_2), \dots, (a_H, c_H, o_H) \right\rangle\]
每个正向动作 \(a_i\) 都将外部环境从状态 \(\mathcal{S}_{i-1}\) 转换到 \(\mathcal{S}_i\)。补偿动作 \(c_i\) 是一种在语义上定义的逆操作，旨在将环境从状态 \(\mathcal{S}_i\) 转回等价或可接受的状态 \(\mathcal{S}_{i-1}' \approx \mathcal{S}_{i-1}\)。
补偿是语义上的修正，而非回滚。在枢轴边界与补偿 Saga 原则（原则 14）下，只有局限于沙箱内的写入才可通过恢复快照来逆转。对共享外部系统的动作至多是可补偿的：恢复环境的不变量，但无法恢复其历史。如果动作 \(a_i\) 向事件响应 Slack 频道发布了一条消息，补偿动作 \(c_i\) 就是再发布一条消息，说明前一条消息有误且已撤回，而接收者仍然已经读过它。完全无法补偿的动作是不可逆的，运行时允许每条轨迹至多包含一个这样的枢轴动作，并将其安排在所有可补偿工作之后。
# Minimal Saga compensating transaction registration
def execute_pipeline_step(action: ActionProposal, supervisor: Supervisor) -> Observation:
# 1. Authorize and commit intent to Write-Ahead Log
supervisor.capability_gate.verify(action.token, action.tool, action.args)
supervisor.wal.append_intent(action.id, action.tool, action.args)
# 2. Execute within isolated MicroVM sandbox
obs = supervisor.microvm.run(action.tool, action.args, timeout_s=30)
norm_obs = supervisor.normalizer.process(obs, max_tokens=2048)
# 3. Register compensating action in durable Saga ledger
comp_action = action.get_compensating_action()
supervisor.saga_ledger.register(action.id, comp_action)
return norm_obs当步骤 \(k\) 发生不可恢复的故障时——例如循环无法推进、环境超时或未处理的工具崩溃——监督器会终止前向执行并启动恢复协议：
- 后向恢复（补偿）： 恢复管理器按逆序遍历 Saga 日志，执行补偿操作 \(c_{k-1}, c_{k-2}, \dots, c_1\)。这会清理临时资源、删除临时分支并释放已分配的云实例，使系统恢复到干净状态，然后再向用户报告失败。
- 前向恢复（检查点重试）： 或者，如果故障是暂时性的（例如网络套接字超时或临时限流），监督器会检查 WAL，将智能体的逻辑上下文恢复到轮次 \(k\) 之前的确切快照，修改执行参数（例如退避或选择备用镜像），然后恢复前向执行。
粗略估算 0.3: 防御性执行中介的开销
物理硬件环境配备了一个 8 核主机 CPU、PCIe 4.0 NVMe 存储和一个隔离的 microVM 池：
- 阶段 1（语法掩码）： 集成在推理服务引擎中；每个 token 的开销为 \(< 0.1\,\text{ms}\)，在整个解码序列中累计产生 \(8\,\text{ms}\) 的开销。
- 阶段 2（能力令牌门控）： Ed25519 密码学签名验证和路径 ACL 求值：\(1.8\,\text{ms}\)。
- 阶段 3（预写意图日志）： 向 NVMe 存储追加一条 \(2\,\text{KB}\) 的二进制记录，并显式执行
fsync：\(15\,\mu\text{s} \approx 0.015\,\text{ms}\)。 - 阶段 4（沙箱化 MicroVM 执行）： 在预先派生的 Firecracker microVM 快照内执行动作需要 \(115\,\text{ms}\)（主要耗时来自客户机内核上下文初始化和 virtio 块设备挂接），再加上 \(250\,\text{ms}\) 的实际命令编译时间。
- 阶段 5（观测规范化）： 对 \(4\,\text{KB}\) 的输出进行流截断、SHA-256 内容哈希计算和 BPE 分词：\(1.4\,\text{ms}\)。
- 阶段 6（Saga 台账登记）： 将补偿描述符追加到仅追加的 SQLite 状态存储中：\(0.05\,\text{ms}\)。
我们计算每轮的总墙钟延迟：
\[T_{\text{model}} = 80\text{ tokens} \times 32\,\text{ms/token} = 2,560\,\text{ms}\]
\[T_{\text{harness}} = 8\,\text{ms} + 1.8\,\text{ms} + 0.015\,\text{ms} + 115\,\text{ms} + 1.4\,\text{ms} + 0.05\,\text{ms} = 126.265\,\text{ms}\]
\[T_{\text{total}} = T_{\text{model}} + T_{\text{harness}} + T_{\text{workload}} = 2,560\,\text{ms} + 126.3\,\text{ms} + 250\,\text{ms} = 2,936.3\,\text{ms}\]
防御性执行运行框架每轮增加 \(126.3\,\text{ms}\) 的系统开销。相对于基础模型的自回归解码延迟（\(2{,}560\,\text{ms}\)），运行框架的开销占比为：
\[\text{Overhead Fraction} = \frac{126.3\,\text{ms}}{2,560\,\text{ms} + 126.3\,\text{ms} + 250\,\text{ms}} = \frac{126.3}{2,936.3} \approx 4.30\%\]
以每轮延迟小幅增加 {python} OverheadDefensiveExecutionMediation.overhead_pct_str 为代价，该架构获得了确定性的语法保证、可防止主机遭受任意攻陷的完全隔离、跨故障的崩溃一致性，以及有保证的可补偿性。在整个 30 轮轨迹中，WAL 日志和 Saga 记录累计消耗的存储空间（\(2\,\text{KB} \times 30 = 60\,\text{KB}\)）与标准操作系统文件缓冲区相比微不足道。
语义看门狗执行
即使单个动作在语法上有效、经过授权、受到隔离且已记入日志，自主智能体仍可能表现出灾难性的宏观行为。以多轮失败观测为条件的基础模型经常陷入病态行为吸引子：在这类退化循环中，模型反复发出完全相同且会失败的命令，在两项相互冲突的编辑之间来回切换，或消耗数千个 token 却没有取得可衡量的进展。
由于不能依赖底层神经模型自行诊断其退化循环，执行运行框架部署了一个带外的确定性监督组件：语义看门狗。
在经典容错计算中，如果处理器未能在指定时间间隔内清零计数器，硬件看门狗定时器就会重置这个停滞的处理器。语义看门狗将这一概念推广到高层轨迹语义，在多轮交互中监控状态增量和行为熵。
语义看门狗与执行运行框架并发运行，在每轮结束后依据三个结构性不变量评估轨迹：
1. 精确语法循环检测
最简单的失败模式是语法重复，即模型在连续多轮中发出完全相同的工具调用，且参数也完全相同（例如，反复查询一个不存在的文件，或执行一个始终不变的搜索查询）。看门狗维护一个存储动作摘要 \(\mathcal{H}(a_t) = \text{SHA-256}(\text{tool\_name} \mathbin{\Vert} \text{canonical\_json}(\text{args}))\) 的滑动窗口环形缓冲区。如果同一动作哈希出现 \(k \ge 3\) 次，且这些出现都位于一个包含 \(W\) 个步骤的窗口内，看门狗就会立即标记语法锁定。
2. 状态增量停滞（语义振荡）
更隐蔽的是，智能体可能改变其输出的语法形式，却仍被锁定在语义循环中。例如，在软件修复任务中，智能体可能交替修改源文件以通过测试 A（却导致测试 B 失败），又修改该文件以通过测试 B（却导致测试 A 失败）。虽然工具调用在语法上不同，环境状态却在两个反复出现的配置之间振荡。
看门狗在每次会改变状态的动作执行后计算密码学状态摘要 \(\mathcal{S}_t = \text{git\_tree\_sha}(\text{workspace})\)，以衡量状态进展。如果 \(\mathcal{S}_t = \mathcal{S}_{t-2}\)，或者跨 \(N\) 轮的累计编辑距离表明净变化为零（\(\Delta \mathcal{S} = 0\)），同时通过测试的数量未能单调增加，看门狗就会判定发生了语义反复切换。
3. 轨迹熔断器
为防止资金和计算资源被无约束地消耗，执行运行框架将智能体轨迹置于一个形式化的熔断器状态机内。熔断器源自分布式系统工程，在三种运行状态之间转换：
CLOSED（正常执行）：动作可顺畅通过六阶段流水线。看门狗持续监控错误率、状态增量和轮次预算。OPEN（熔断执行）：如果突破失败阈值，例如超过 \(T_{\max}\)、累计发生 \(K\) 次连续工具执行失败，或检测到无法打破的语义循环，熔断器就会触发熔断OPEN。后续工具派发立即停止。监督组件截停智能体进程，挂起 MicroVM，在已配置的情况下反向执行 Saga 补偿，并向人工操作员或编排器发出警报。HALF-OPEN（探测恢复）：在自动恢复场景中，熔断器转换至HALF-OPEN。智能体获得受限的预算（例如，恰好两轮），且只能使用只读诊断工具。如果智能体展现出向前推进的能力（例如，输出逻辑连贯的诊断或执行有效的恢复计划），熔断器便重置为CLOSED；如果再次失败，熔断器就会永久熔断至OPEN。
以下诊断跟踪展示了语义看门狗如何在 token 预算耗尽之前拦截一个振荡的编译器修复循环：
[WATCHDOG: TURN 12] Action: patch_file(path="src/parser.c", diff="@@ -42,2 +42,2 @@...")
[SANDBOX: TURN 12] Exit: 1 | stderr: "parser.c:45:12: error: unknown type name 'NodeId'"
[WATCHDOG: TURN 13] Action: patch_file(path="src/parser.c", diff="@@ -42,2 +42,2 @@...")
[SANDBOX: TURN 13] Exit: 1 | stderr: "parser.c:45:12: error: expected ';' before 'x'"
[WATCHDOG: TURN 14] Action: patch_file(path="src/parser.c", diff="@@ -42,2 +42,2 @@...")
[WATCHDOG: TRAP] Semantic oscillation detected: State hash matches Turn 12 (git:e84f2b).
[CIRCUIT_BREAKER] State changed: CLOSED -> OPEN.
[CIRCUIT_BREAKER] Halting forward dispatch. Invoking Saga compensation ledger (c_14..c_12).
[SUPERVISOR] Escalating to human escrow: Diagnostic payload spooled to /var/log/traces/104.通过将执行监控与概率性神经引擎解耦，语义看门狗提供了一项确定性保证：无论模型出现幻觉、随机采样发生异常，还是环境给出意外反馈，智能体都无法执行无界且不推进任务的副作用操作。
构建一个集成语法 logit 约束、能力门控、预写日志、隔离式 microVM 操作执行、观测规范化、补偿式 Saga 和语义看门狗的执行框架，可以解决安全执行现实世界操作所面临的机制性难题。然而，执行框架仅能强制实施约束并限制故障影响；它并不会提升智能体底层的问题求解能力。当智能体在经过加固的运行框架内运行，却仍持续触发熔断器或无法满足任务契约时，系统工程师便面临一个架构问题：应当将工程投入放在系统的哪一层？工程实践不能贸然转向昂贵的基础模型微调或缺乏协同的多智能体群，而应沿着基于证据的干预阶梯逐级推进——从上下文工程和工具模式重新设计，有条不紊地推进至运行时防护、权重适配和多智能体委派。下文将综合阐述这一决策层级。
Checkpoint 0.1: 评估系统干预阶梯与故障修复
在考察实证安全案例和多层验证金字塔之前，请检验你对架构升级的理解：
系统干预阶梯
当智能体在生产环境的执行框架内运行，却反复触发看门狗计时器、违反语法约束，或无法通过后置条件验证器的检查时，工程团队便立即面临一个架构层面的故障分诊难题。不成熟的系统组织中普遍存在一种弊病，即过早升级干预：直接跳到计算成本最高、统计上脆弱且运维过程不透明的修复方案——要么启动定制模型微调任务，要么将任务拆分给一群缺乏协同的对等智能体。实际上，绝大多数任务执行失败源于上下文条件设置不佳、工具接口契约含糊不清，或运行框架存在约束漏洞，而非底层基础模型推理能力的内在缺陷。
系统干预阶梯为解决智能体能力局限确立了一套基于证据的架构修复层级。由于权重变更是最慢且最难逆转的干预方式，并且只能修复在排除上下文、工具模式和运行时故障后仍然存在的失败（原则 16），系统工程师必须穷尽上下文工程、工具模式重新设计和运行时防护加固的手段，才有理由承担权重适配（SFT、RLVR）所带来的资本支出、运维僵化性及分布漂移脆弱性，或多智能体委派带来的同步开销。沿阶梯向上升级，意味着从较低的前期工程投入和快速迭代周期，转向高额资本支出和专用基础设施；因此，只有当用于摊销成本的任务量足以抵消一次性工程成本，或物理上下文边界严格排除了单一上下文执行的可能性时，更高层级的干预才在数学上具有合理性。
系统升级谬误：试图通过微调神经网络权重来纠正确定性接口缺陷（例如含糊的参数类型或缺乏有效信息的错误载荷），违背了端到端论证。修改模型权重会在整个任务分布上引入不可逆的行为副作用，而其试图解决的问题，仅需修改五行 JSON Schema 即可获得数学上确定的解决方案。
系统化的工程实践要求将智能体视为一个分层技术栈。当任务契约未得到满足时，工程师必须辨明缺陷究竟属于哪一类：信息不足（模型缺少必要事实，或受到上下文噪声干扰）、接口不匹配（工具契约未能传达其约束）、约束执行缺失（运行框架允许无效状态转换，却未提供恢复指导）、行为先验不匹配（基础模型难以处理多 token 格式要求或确定性流程排序）、难以求解的搜索空间（解空间需要专门的多步探索，而标准推理采样无法发现解），或物理上下文分区（问题状态超出单一执行上下文的物理容量或计算能力）。沿着 图 7 所示的干预阶梯逐级推进，为在系统尽可能低的层级上解决这些故障模式提供了正式的决策流程。
如 图 7 所示，该决策架构从两个互补视角组织补救措施。左侧面板确立了按资本成本和影响范围递增排列的六级层次结构：从第 1 级（零成本、即时生效、百分之百可逆的上下文与提示清理）开始，依次经过第 2 级（工具接口契约）和第 3 级（运行框架中的看门狗与熔断器），然后才考虑第 4 级（监督微调）和第 5 级（基于可验证奖励的强化微调）的权重修改，最后是第 6 级（分布式多智能体拓扑）。右侧面板形式化描述了系统工程师评估的决策裁定树。当运行框架加固（第 1–3 级）达到其经验极限时，问题 2 检查经济盈亏平衡定律：只有当预计工作负载量 \(N\) 超过 \(N^* = C_{\text{invest}} / \Delta C_{\text{task}}\) 时，团队才会升级到有监督的权重适配。如果任务验证还提供了机械化判定器（编译器、类型证明器），问题 3 就为第 5 级的策略探索提供依据；否则，如果任务状态超出物理上下文限制，问题 4 则作为升级到多智能体流水线的决策关卡，同时明确警告应避免未经中介协调的对等通信。
系统干预的六个层级
干预阶梯将架构调整组织为六个不同的梯级，每个梯级都由其干预位置、运行成本特征和故障影响面的半径来表征。沿阶梯向上移动，会将控制点从暂态运行时状态转向持久化产物定义、编译后的权重和分布式进程拓扑（0.1）。
Definition 0.1: 系统干预层次结构
系统干预层次结构 是一个有序的决策序列 \(\text{Context} \prec \text{Tools} \prec \text{Harness} \prec \text{SFT} \prec \text{RLVR} \prec \text{Multi-Agent}\)，用于指导智能体性能缺陷的补救，并严格优先采用低成本、可逆的运行框架修改，而后才考虑昂贵、不可逆的权重适配和分布式拓扑。
- 重要性：防止工程团队为解决工具模式含糊、提示杂乱或缺少运行时防护机制所导致的缺陷，过早升级到耗资数百万美元的微调或复杂的多智能体架构。
- 区别：与通用软件调试工作流不同，智能体系统干预阶梯明确使用经济盈亏平衡定律 \(N^* = C_{\text{invest}} / \Delta C_{\text{task}}\)，为运行时软件层与神经网络权重适配之间的转换设置门槛。
- 常见陷阱：通过微调模型权重或部署多智能体群来掩盖确定性的接口缺陷（例如类型定义不完善的 JSON 模式或缺乏有效信息的错误返回码），而这些缺陷本可在工具边界处即时、可逆地解决。
这六个层级之间的定量工程权衡详见 干预阶梯的权衡。
第 1 级：上下文工程
第 1 级干预严格限定在模型的暂态上下文窗口内，无需对外部服务、运行框架或模型参数进行任何修改。该层级的能力失效源于模型缺少关键领域事实、受到多余词元引发的注意力干扰，或被迫推断从未明确定义的隐式格式要求。
补救措施的核心是优化工作记忆的整洁性：删减无关的检索结果，将系统指令隔离到专门的提示片段中以最大化注意力汇聚效应，以及注入与任务紧密耦合的少样本示范轨迹。通过重构上下文，系统工程师可以提高生成有效动作提案的后验概率，而无需修改宿主软件或向训练流水线投入资本。由于第 1 级干预可在数分钟内完成，并能立即通过集成测试平台进行评估，因此它构成任何故障分诊流程的必备基线。
第 2 级：工具接口重新设计
当智能体正确感知操作上下文，却持续输出无效的动作参数、不按顺序调用工具或臆造参数时，故障通常出在接口契约，而非模型的底层能力。第 2 级干预修改向智能体开放的工具的语法和语义规范。
工程师依据经典系统原则重构工具定义，以解决这些故障：
- 语法解耦： 将庞大、多用途的管理 API 分解为小型、正交、单一用途的端点，并尽量减少其参数数量。
- 类型与枚举收窄： 将宽松的字符串参数替换为严格的 JSON Schema 枚举、有界整数和显式正则表达式约束，并在语法引导的 logit 掩码过程中强制执行这些约束。
- 信息丰富的错误载荷： 将不透明的返回码（例如
400 Bad Request或Process exited with code 1）转换为结构丰富的诊断字符串，准确指出违反了哪项不变量、目标环境当前处于何种状态，以及预期应采取何种纠正措施。
// Antipattern: Opaque System Error
{"status": "error", "code": 1}
// Refactored: Rich Diagnostic Return
{
"status": "failed_precondition",
"violation": "lockfile_out_of_date",
"expected": "Run 'cargo update' first",
"target_file": "/workspace/Cargo.lock"
}第 2 级重构：将结构化、可操作的错误载荷直接输出到观测帧中，使智能体能够在现有的自回归循环内恢复，而无须触发运行时干预。
第 3 级：运行框架加固
当工具模式已足够稳健，但智能体仍陷入退化性的自回归陷阱——例如反复循环查询、语义漂移或忽略工具错误消息——时，就必须由监督器缓解故障。第 3 级干预修改模型外围的宿主运行框架，而不修改模型本身。
在这一级，工程师引入外部确定性状态机，例如 节 4 中开发的语义看门狗和进度监控器。第 3 级防护机制跟踪轨迹偏离指标 \(\mathcal{J}_t\)，检测执行步骤之间的循环词元模式，强制执行严格的资源预算，并注入动态系统中断（例如直接注入下一上下文帧的合成监督器消息），迫使模型确认尚未处理的异常。通过为执行故障设定明确边界，第 3 级加固可防止无界退化，并确保系统平稳降级至人在回路中的故障分诊流程。
第 4 级：监督适配（SFT）
当提示词开销、指令脆弱性，或基础模型即使经过第 1–3 级补救仍无法可靠遵循复杂结构协议，制约了智能体系统在运行上的可行性时，工程师就必须升级干预，修改模型的参数权重 \(\theta\)。第 4 级监督微调使用经过精心筛选的示范轨迹，调整模型的条件词元分布 \(P_\theta(a_t \mid s_t)\)。
SFT 将复杂的、长达数千词元的提示指令、工具模式和常见恢复行为直接编译进模型的神经回路。这一转变带来两项不同的系统收益：大幅缩短建立运行上下文所需的输入词元长度 \(N_{\text{tokens}}\)（降低预填充计算延迟），并消除遵循专有语法格式时出现的非确定性失败。然而，SFT 也带来了显著的架构权衡：它需要大量流水线基础设施来整理干净、多样的轨迹数据集；对微调分布之外的任务引入灾难性遗忘风险；并将运行时锁定在工具定义的静态快照上，若不重新训练或承受策略性能下降，就无法更改这些定义。
第 5 级：可验证奖励强化学习（RLVR）
监督微调教会智能体有效轨迹是什么样的，却无法教会它如何在组合问题空间中有效搜索。当智能体必须解决复杂的多步骤算法问题——例如仓库级补丁生成、硬件布局验证或定理证明——时，人类示范数据集往往稀疏、噪声较多，且无法涵盖最优回溯策略。
第 5 级干预使用策略梯度方法，直接依据自动化、程序化的验证判定器来优化策略 \(\pi_\theta\)。在外部确定性测试框架能够评估智能体的候选终止状态是否满足形式化正确性不变量（例如编译通过、测试套件通过或 SAT 约束验证通过）的领域，RLVR 会推动策略分布转向稳健、可自我纠正的探索。智能体学会将思维链验证内化，生成多样的假设分支，并在收到表示失败的工具反馈时回溯。第 5 级的前提条件十分苛刻：系统必须具备沙箱化、高吞吐量的执行环境，能够并行评估数百万条轨迹，同时配备无法被钻空子的奖励函数，以防止奖励投机。
第 6 级：多智能体委派
当单个推理上下文的物理容量被彻底耗尽时，就到达了这一阶梯的顶端。第 6 级将一个整体任务分解并分配给一组异构、松耦合的智能体进程，每个进程都维护自己的私有上下文窗口、专用工具运行框架和独立的内存生命周期。
委派并非通用的优化手段，而是在架构上对严格物理约束作出的妥协。只有在以下三种明确的运行条件下，采用委派才有充分理由：
- 上下文窗口耗尽：权威工件、中间推理轨迹和环境观测的总量严格超过物理上下文上限 \(L_{\max}\)，或导致严重的注意力稀释。
- 权限与隔离边界：子任务需要不同的能力分配（例如，将没有任何网络权限的不可信代码执行子智能体，与持有外部 API 凭据的管理子智能体隔离）。
- 异步并行探索：搜索空间可以划分为独立子问题，在多个推理引擎上并发执行，且不存在同步内存依赖。
将任务拆分给多个智能体，会把一个局部循环变成分布式系统，使序列化、网络延迟、部分失效和状态协调进入关键路径；而共享权重的智能体也会共享错误。在协同开销（原则 19）的约束下，智能体集群只有满足上述三个条件，才能使这项成本物有所值。这三个条件归结为上下文分区、权限收缩和独立探索，因此，委派应处于阶梯顶端，作为架构层面的最后手段，而非默认设计。
| 层级 | 主要机制 | 工程准备周期 | 前期资本成本 | 每次调用的延迟变化 | 故障恢复范围 | 主要系统风险 |
|---|---|---|---|---|---|---|
| 1. 上下文 | 提示调优、检索优化 | 数小时 | 可忽略（\(\sim \$0\)） | 不变或降低（若裁剪上下文） | 上下文重置 | 上下文干扰、提示注入 |
| 2. 工具 | 模式重构、类型标注、丰富的错误信息 | 数天 | 极低（\(< \$10^2\)） | 不变（微秒级模式解析） | 模式验证错误 | 语义阻抗失配 |
| 3. 防护 | 语义监控器、熔断器 | 数天 | 低（\(< \$10^3\)) | \(+10\text{--}50\text{ ms}\)（运行框架检查） | 运行框架中止、监督器重试 | 对探索施加过度约束 |
| 4. SFT | 基于精选轨迹的行为克隆 | 数周 | 中等（\(\$10^3\text{--}\$10^4\)） | 降低（上下文提示更短） | 分布外回滚 | 灾难性遗忘、模式漂移 |
| 5. RLVR | 以确定性验证器为依据的策略搜索 | 数月 | 高（\(\$10^4\text{--}\$10^6\)） | 增加（自我纠正的解码更长） | 回滚至基础检查点 | 奖励投机、利用验证器漏洞 |
| 6. 多智能体 | 分布式子任务划分 | 数周至数月 | 高（\(\$10^3\text{--}\$10^4\) 基础设施） | 成倍增加（\(2\times\text{--}10\times\) 次串行 RPC） | Saga 补偿、同伴重新委派 | 级联死锁、共识崩溃 |
经济摊销动态
决定是否从运行时上下文操控（第 1–3 层）升级至参数适配（第 4–5 层）或架构层面的分布式执行（第 6 层），归根结底是一项系统经济学分析。用于数据集整理、合成训练环境基础设施和 GPU 训练时数的前期资本投入，必须在智能体预计的整个部署生命周期内摊销。
考虑一项智能体工作负载，在总计 \(N\) 次任务执行中对其进行评估。基线系统运行于第 1 层（提示与上下文内示例工程），每步需要 \(T_{\text{base, in}}\) 个输入词元的高额提示开销，并生成 \(T_{\text{base, out}}\) 个输出词元；平均执行 \(H_{\text{base}}\) 个轨迹步骤后，才能满足任务契约。基线系统执行 \(N\) 项任务的总运行成本为：
\[C_{\text{base}}(N) = N \cdot H_{\text{base}} \left( T_{\text{base, in}} \cdot p_{\text{in}} + T_{\text{base, out}} \cdot p_{\text{out}} \right)\]
其中，\(p_{\text{in}}\) 和 \(p_{\text{out}}\) 分别表示模型推理服务对每个输入词元和输出词元收取的边际价格。
现在考虑升级至第 4 层（监督微调）的干预方案。构建这一适配后的模型会产生高额的一次性工程与训练成本，记为 \(C_{\text{invest}}\)：
\[C_{\text{invest}} = C_{\text{compute}} + C_{\text{data}} + C_{\text{human}}\]
其中，\(C_{\text{compute}}\) 包括参数更新所需的 GPU 集群时数，\(C_{\text{data}}\) 表示生成合成轨迹的成本，\(C_{\text{human}}\) 则涵盖专家标注和评估工程的成本。
然而，由于微调后的模型将工具定义、格式规则和过程不变量直接内化到权重中，其运行时提示规模大幅缩减：\(T_{\text{adapt, in}} \ll T_{\text{base, in}}\)。此外，由于适配后的策略在探索中走弯路的次数更少，其平均轨迹长度也会缩短：\(H_{\text{adapt}} \le H_{\text{base}}\)。假设微调模型的托管成本对应的边际词元成本为 \(p_{\text{in}}'\) 和 \(p_{\text{out}}'\)（若托管于共享企业基础设施，这些成本可能等于 \(p_{\text{in}}, p_{\text{out}}\)；若采用专用预配置吞吐量，则可能不同），则每项任务的边际成本变为：
\[C_{\text{task, adapt}} = H_{\text{adapt}} \left( T_{\text{adapt, in}} \cdot p_{\text{in}}' + T_{\text{adapt, out}} \cdot p_{\text{out}}' \right)\]
当任务量达到 \(N^*\) 时，适配后的系统相对于基线系统实现经济上的盈亏平衡，该任务量由以下等式推导得出：
\[C_{\text{base}}(N^*) = C_{\text{invest}} + N^* \cdot C_{\text{task, adapt}}\]
求解 \(N^*\)，可得标准的盈亏平衡任务量公式（公式 1）：
\[N^* = \frac{C_{\text{invest}}}{C_{\text{task, base}} - C_{\text{task, adapt}}} = \frac{C_{\text{invest}}}{\Delta C_{\text{task}}} \tag{1}\]
粗略估算 0.4: 微调何时值得投入
变量（示例场景取值）：
- 基线模型：每步使用 12,000 个输入 token 和 800 个输出 token，每项任务执行五步，采用前面章节中前沿模型的场景定价，即每百万输入 token $3，每百万输出 token $15。
- 适配模型：每步使用 1,500 个输入 token 和 800 个输出 token，每项任务执行四步，价格为每百万输入 token $1，每百万输出 token $4。
- 一次性投资：数据费用为 $4,000，训练计算费用为 $500，评估与审查费用为 $8,000，因此 \(C_{\text{invest}}\) 为 $12,500。
- 预期业务量：每月 20,000 个拉取请求。
计算：基线模型每步的输入与输出总成本为 $0.048，因此 \(C_{\text{task, base}}\) 为 $0.24。适配模型每步的成本为 $0.0047，因此 \(C_{\text{task, adapt}}\) 为 $0.019。每项任务的节省额 \(\Delta C_{\text{task}}\) 为 $0.22，根据 公式 1，盈亏平衡点约为 57,000 项任务。在每月 20,000 项任务的业务量下，这项投资约在 2.8 个月内回本，刚好在一个季度以内。
系统层面的洞见：回本时间的余量很小，而答案取决于团队能够控制的输入条件。业务量翻倍会使回本周期减半，但如果工具定义的变更迫使模型重新训练，回本周期就会重新计算，因此任务契约的稳定性与每项任务的节省额同样重要。
第三项决策是认清沿阶梯向上攀升无法换来什么。无论模型经过多么充分的微调或优化，在任何有限温度下，它仍然从一个对每种后续生成序列都赋予非零概率的分布中采样 \(\tau\)：
\[P(a_t = w_i \mid s_t) = \frac{\exp\left(z_i / \tau\right)}{\sum_j \exp\left(z_j / \tau\right)}\]
因此，在 \(H\) 轮的时间范围内，至少有一轮违反不变量的概率始终严格大于零：
\[P(\text{violation} \mid H) = 1 - \prod_{t=1}^{H} \left(1 - P_{\text{error}}(t)\right) > 0\]
训练能够降低 \(P_{\text{error}}\)，却永远无法使其降为零。因此，训练不能成为系统满足不变量闭包原则（不变闭包原则）的手段。在每一级阶梯上，支出限制、隔离和不可逆操作仍须由运行时管控，而任务正确性仍需要在验收时收集证据来证明。更好的模型会降低这些机制的触发频率，却不能让系统移除这些机制。
最高一级阶梯也有其自身的警示。将一个执行失败的任务拆分给多个智能体，会把局部循环变成分布式系统，使消息传递、局部故障和状态协调进入关键路径。根据协同开销原则（原则 19），只有通过划分上下文、收缩权限或独立探索，才能抵偿这项成本。当单个智能体因任务含糊而失败时，增加智能体只会让它们继承同样的歧义，并在此基础上增添分歧。
如果智能体在整个运行生命周期内的预计任务总量小于 \(N^*\)，那么升级到权重适配在经济上是不理性的：工程组织为构建和维护微调流水线而投入的资金，超过了通过节省 token 成本所收回的金额。反之，如果 \(N \gg N^*\)，那么在超过 \(N^*\) 之后，每多执行一项任务，都将带来纯粹的边际利润增长和延迟降低。
粗略估算 0.5: 权重适配的盈亏平衡分析
基线架构（第 1 级 + 第 3 级）： 为可靠地格式化补丁并调用代码仓库搜索工具，基础模型需要一份系统提示，其中包含详尽的模式定义和三个完整的代码仓库修复示例，共计 \(T_{\text{base, in}} = 12{,}000\) 个输入 token。在平均包含 \(H = 5\) 个工具交互步骤的任务中，智能体每步生成 \(T_{\text{base, out}} = 800\) 个输出 token。商业推理 API 的收费为 \(p_{\text{in}} = \$2.50 \times 10^{-6}\) per token and \(p_{\text{out}} = \$10.00 \times 10^{-6}\) 每 token。 \[\begin{aligned} C_{\text{step, base}} &= (12{,}000 \times \$2.50 \times 10^{-6}) + (800 \times \$10.00 \times 10^{-6}) \\ &= \$0.030 + \$0.008 = \$0.038\text{ per step} \\ C_{\text{task, base}} &= 5 \times \$0.038 = \$0.190\text{ per pull request} \end{aligned}\]
升级架构（第 4 级 SFT）： 系统团队对一个开放权重模型进行微调，使其内化工具接口和补丁生成语法。 - 数据集整理与合成生成：\(C_{\text{data}} = \$4{,}000\) - 云端 GPU 集群微调（8 \(\times\) H100 SXM5，运行 18 小时，单价为 \(\$3.50/\text{GPU-hr}\)): \(C_{\text{compute}} = 8 \times 18 \times \$3.50 = \$504\) - 工程验证与红队测试：\(C_{\text{human}} = \$8{,}000\) - 前期总投入：\(C_{\text{invest}} = \$4{,}000 + \$504 + \$8{,}000 = \$12{,}504\)
由于工具模式已编译到权重中，提示开销降至 \(T_{\text{adapt, in}} = 1{,}500\) 个输入 token。由于遵循指令的能力更强，平均步骤数降至 \(H_{\text{adapt}} = 4\) 步，输出生成量保持相同（\(T_{\text{out}} = 800\)）。自托管推理集群经摊销后的等效 token 成本为 \(p_{\text{in}}' = \$1.00 \times 10^{-6}\) and \(p_{\text{out}}' = \$4.00 \times 10^{-6}\)。 \[\begin{aligned} C_{\text{step, adapt}} &= (1{,}500 \times \$1.00 \times 10^{-6}) + (800 \times \$4.00 \times 10^{-6}) \\ &= \$0.0015 + \$0.0032 = \$0.0047\text{ per step} \\ C_{\text{task, adapt}} &= 4 \times \$0.0047 = \$0.0188\text{ per pull request} \end{aligned}\]
盈亏平衡评估： \[\begin{aligned} \Delta C_{\text{task}} &= \$0.190 - \$0.0188 = \$0.1712\text{ saved per task} \\ N^* &= \frac{\$12{,}504}{\$0.1712} \approx 73{,}038\text{ pull requests} \end{aligned}\]
系统结论： 如果企业每月处理 \(20{,}000\) 个拉取请求，前期微调投入将在约 {python} BreakEvenWeightAdaptation.payback_months_str 后达到盈亏平衡。超过这一请求量后，组织每月可节省超过 {python} BreakEvenWeightAdaptation.monthly_savings_str，同时，由于针对输入 token 的预填充 GEMM 计算大幅减少，端到端任务周转延迟降低 \(62\%\)。
架构权衡
干预阶梯所体现的设计准则遵循端到端论证：按照 端到端边界的双重保证 的划分，将模型下层的机械性闭合与模型上层的证据分开，并按照 为架构选择定价 的方式核算成本。在智能体架构中，将功能置于栈的较低层，与在监督端点提供这些功能相比，可能是冗余的或无效的。
在智能体机器学习系统中，试图仅通过权重适配（第 4 级和第 5 级）解决执行可靠性问题，会陷入逆向端到端谬误：试图迫使一个底层子系统（统计 token 预测器）保证某个端到端应用不变量，而该不变量只能由监督端点验证并强制执行。无论经过多么充分的监督微调或强化学习，神经模型仍然是一个无特权、非确定性的 token 生成器，受温度缩放和 softmax 概率支配：
\[P(a_t = w_i \mid s_t) = \frac{\exp\left(z_i / \tau\right)}{\sum_j \exp\left(z_j / \tau\right)}\]
由于在任意有限温度 \(\tau > 0\) 下，softmax 分布在整个词表上均具有非零支撑，因此在包含 \(H\) 轮交互的轨迹中，生成无效 token 序列或违反安全不变量的概率始终严格大于零：
\[P(\text{violation} \mid H) = 1 - \prod_{t=1}^{H} \left(1 - P_{\text{error}}(t)\right) > 0\]
无论进行多少策略梯度优化，都无法在无限的运行时域内将 \(P(\text{violation})\) 降至绝对零。因此，依靠微调后的权重来保证智能体永远不会删除数据库表或绕过安全检查，在根本上是有缺陷的。因而，训练不能成为系统满足不变量闭合原则（不变闭包原则）的手段。系统在安全性、资源和隔离方面的有界属性必须通过机械性机制实现闭合，包括第 3 级运行时防护、使模型不具备任何环境隐含权限的能力边界，以及宿主智能体运行框架中的语法约束解码；任务正确性仍然需要在端点收集的证据。
同样，部署第 6 级多智能体群体的冲动，往往违背 Frederick P. Brooks Jr. 提出的经典软件工程箴言 (Brooks 1987年)：切勿将偶然复杂性误认为本质复杂性。当单智能体系统无法收敛时，失败往往反映了工作记忆管理不当、检索日志噪声过多或工具文档含糊所引入的偶然复杂性。将这一界定不清的任务拆分给多个自主智能体，并不能消除底层的歧义；反而会因引入分布式共识开销、状态分歧和级联故障模式而使问题更加复杂。
在任何系统工程师批准将一个失败的智能体流水线升级到更高干预层级之前，必须按照 代码 1 中正式规定的分诊协议，对其故障模式进行评估。
def evaluate_intervention_level(failure_trace, current_level):
"""
Evaluates whether an agent capability failure justifies ladder escalation.
Enforces the Saltzer-Clark End-to-End and Brooksian simplicity invariants.
"""
if failure_trace.is_missing_domain_fact or failure_trace.has_context_distraction:
return InterventionTier.LEVEL_1_CONTEXT_ENGINEERING
if failure_trace.violates_tool_schema or failure_trace.uninformative_error_return:
return InterventionTier.LEVEL_2_TOOL_SCHEMA_REDESIGN
if failure_trace.is_cyclic_loop or failure_trace.exceeded_safety_boundary:
return InterventionTier.LEVEL_3_RUNTIME_HARNESS_GUARD
if failure_trace.prompt_token_budget_exhausted and failure_trace.stable_task_contract:
return InterventionTier.LEVEL_4_SUPERVISED_ADAPTATION
if failure_trace.verifiable_oracle_available and failure_trace.combinatorial_search:
return InterventionTier.LEVEL_5_REINFORCEMENT_LEARNING
if failure_trace.physical_context_exceeded or failure_trace.requires_privilege_isolation:
return InterventionTier.LEVEL_6_MULTI_AGENT_DELEGATION
raise UnjustifiedEscalationError("Failure remediable at current or lower tier.")系统工程师的首要目标，是在干预阶梯上尽可能低的层级，使智能体在其运行包络内达到完全可靠。通过将干预点保持在接近上下文与运行时边界的位置，系统能够保留最大的敏捷性，最大限度地减少基础设施与 token 开销，并维持清晰的审计轨迹。
然而，一旦选定干预措施、完成工程实现并将其整合到智能体运行时中——无论是通过强化的第 3 级语义防护、第 4 级蒸馏开放权重模型，还是第 6 级委托执行拓扑——工程团队就会面临发布前的最后一道关卡：在生产环境中实际执行操作之前，证明所构建的自主机器是安全、可信赖的，并且对灾难性回归具有鲁棒性。这要求构建形式化、实证性的安全论证。
实证安全论证
安全论证以亚毫秒级机械证明为根基，在其上建立统计性训练场界限与金丝雀遥测。
生产发布会全面遭遇 时间跨度拉伸：从纳秒指令到千秒级轨迹 所揭示的开环可靠性上限。在每步可靠性为 99% 的情况下，一条包含 100 次工具调用的轨迹只有约 37% 的概率能够在没有任何偏差的情况下完成；而在任务关键型运行时中，例如自动化数据库迁移、分布式集群编排或财务账本对账，接近三分之二的失败率是不可接受的。由于失败具有表面合理性（Fail-Plausible 故障模型），它们很少表现为明确的崩溃；相反，它们会表现为看似合理、语法规范、但语义上具有破坏性的操作：删除生产数据库的外键、配置不受限流约束的计算实例，或将敏感客户凭据泄露到第三方观测缓冲区。
将自主智能体发布到生产环境，需要一套经得起审查的多层安全论证，将确定性机械验证器、留出训练场上的统计评估以及金丝雀遥测结合起来。 可靠的系统工程不能依赖模型的自我反思或开环基准测试通过率，而是要求建立基于证据的保障框架，将神经模型视为不可信的随机组件，并将其封装在严格的确定性监督运行框架内。
主张—论据—证据框架
借鉴航空电子与核系统工程中严谨的安全关键方法论，自主智能体不能仅凭直觉上的信心或经验上的感觉，就获得生产部署认证。它需要一套形式化的安全论证：一组结构化、可审计的推理，用以证明系统在明确界定的部署包络内满足其运行不变量。安全论证可分解为由主张、论据和证据构成的三部分层级结构。
主张是精确、可检验的命题，断言智能体运行时在所有可达状态下均能保持特定的安全性与正确性不变量。主张必须能够被明确证伪。系统工程要求具体的不变量，而不是“智能体会负责任地行动”之类的模糊断言。主张 1 可以表述为“未经密码学双重授权，智能体进程无法修改生产数据库模式”；主张 2 为“智能体执行框架绝不会向私有 VPC 子网之外发送未加密的网络出站数据包”；主张 3 为“在滚动的 60 分钟窗口内，任何工具调用序列消耗的云计算预算都不能超过 \(B_{\max}\) 个单位”。
论据提供因果与架构层面的理由，解释系统设计为何能够保证某项主张成立。论据在抽象不变量与物理实现之间建立桥梁。对于主张 1，论据表明：模型不持有任何隐式权限，也没有直接的数据库句柄；候选 SQL 语句被暂存在隔离的内存托管区中；模式迁移 RPC 端点强制要求由硬件支持的签名，而模型的执行上下文无法生成此类签名。
证据表明，支撑论据的机制在实践中能够正确运行。由于自我报告不具备证据效力（闭合证据等级），有效证据只能由经过机器检查的产物构成：编译器诊断信息、静态分析 AST 转储、SMT 求解器的可满足性证书、封闭隔离的基准测试日志，以及经密码学签名的审计轨迹。
形式上，生产发布关卡会检查安全论证中的每一项声明。对于每项声明 \(k\)，必须存在一个架构论证 \(\text{arg}_k\)，该论证由证据集 \(\text{ev}_k\) 支持，使得：
\[\forall k, \quad \text{Verify}(\text{claim}_k, \text{arg}_k, \text{ev}_k) = \text{PASS}\]
如果任何证据制品未通过检查——例如 AST 检查器报告语法违规，或出站流量日志揭示了未经身份验证的套接字连接——则安全论证失效，发布关卡触发阻断，智能体部署在流水线边界处被阻止。
Definition 0.2: 三层验证金字塔
安全论证包含三个层次。声明是关于运行中系统的可证伪陈述，例如“智能体在没有签署批准的情况下不能更改生产环境模式”。论证通过指出机制及其所属子系统，解释架构为何能使声明成立。证据表明该机制在实践中有效。由于智能体自身的报告不具有证据效力（闭合证据等级），证据由运行时或独立运行框架生成的制品组成，例如检查结果、测试日志、追踪记录和签署的批准。由三项声明构成的安全论证 展示了三项声明在这三个层次中的具体展开。
三层验证金字塔
为了在不为每个交互步骤引入无限验证延迟的前提下证实安全论证，运行时将其经验证据组织成一个三层验证金字塔（图 8）。如 图 8 的面板 A 所详述，证据金字塔建立了分层的纵深防御：底层同步拦截超过 95% 的无效状态转换，所用手段是零容忍的机械验证器（AST 检查器、解码时下推自动机，以及延迟为 \(< 1\text{ ms}\) 的静态污点分析器）；中层在数千个封闭隔离的测试环境夹具上，对轨迹的统计稳定性进行基准测试（\(N \ge 2{,}400\)，将误差幅度限制在 \(\Delta p \le 2.0\%\)，采用 95% 的 Wilson 置信区间）；顶层通过异步金丝雀环和 OpenTelemetry 追踪保护真实生产环境（在 \(T_{\text{react}} < 50\text{ ms}\) 内对异常消耗速率作出反应）。在面板 B 中，这些经验验证层直接映射到形式化保障论证：声明 1（宿主机权限提升为零）通过 microVM 隔离论证加以证明，并由静态 seccomp 审计和逃逸模糊测试提供支持；声明 2（财务消耗有界）由单调支出托管机制强制执行；声明 3（确定性故障恢复）由 WAL 补偿日志和混沌注入重放测试予以认证。每一层都在不同的空间和时间边界上运行，在绝对的形式化保证与环境真实性之间进行权衡。
智能体运行时中的霍尔逻辑： 遵循 C. A. R. Hoare（1969）的理论，每次工具调用都受到前置条件 \(P\) 和后置条件 \(Q\) 的约束。在智能体运行时中，第 1 层机械验证器强制确保：若状态 \(s_t\) 满足 \(P\)，则动作 \(a_t\) 仅在静态分析保证后置条件 \(Q\) 不会违反安全包络 \(\mathcal{S}_{\max}\) 时才被允许执行。
第 1 层：确定性机械验证
金字塔的底层由确定性的、零容忍的软件检查构成，这些检查在宿主监督器内部本地执行，先于任何动作提案接触外部环境。第 1 层验证器同步处理模型的候选输出。它们无需 GPU 计算，引入的延迟可以忽略不计（\(\le 5\text{ ms}\)）。
- AST 与语法解析： 对以结构化交换格式（如 JSON 或 Protobuf）输出的候选工具调用，依据严格的上下文无关文法进行验证。如果自回归解码产生无法解析的令牌序列、格式错误的控制令牌或无法识别的模式键，候选帧会在解析器边界立即被丢弃。
- 类型检查与静态分析： 表示代码修改的工具参数（如 Python 差异或 SQL 补丁）在进入暂存阶段前，会被送入静态分析流水线。在代码生成智能体中，候选修改必须在内存托管区内通过语言专用的类型检查器（例如
mypy或rustc）和安全检查器（例如检查未参数化的 SQL 查询或危险的 shell 转义）。 - 形式化不变量证明器： 当安全边界涉及数值资源分配或时序安排时，候选计划会被编码为可满足性模理论（SMT）约束，并通过 Z3 等引擎求解。如果提出的操作计划违反访问控制顺序或超出已分配的预算阈值，SMT 求解器会返回
UNSAT，在发出任何网络数据包之前终止执行。
由于第 1 层完全是确定性的，其失效模式是二元的：任何违规都会中止轨迹或强制立即在本地重新规划。此边界不容许任何统计不确定性。
第 2 层：封闭式训练场评估
虽然第 1 层保证动作不违反静态语法或安全约束，但它无法判断智能体能否成功完成多步骤目标，或是否会陷入行为循环。第 2 层在一套大规模的、封闭且可复现的仿真环境（“训练场”）中评估智能体的动态策略 \(\pi_\theta\)。
统计发布门禁： 如 智能体评估 所述，若没有置信界限，智能体成功率的点估计在统计上就没有意义。发布标准必须基于置信水平为 \(1 - \alpha\) 的双侧 Wilson 得分区间下界来制定。
封闭式训练场提供目标运行环境的一个完全隔离、采用快照隔离的副本，其中包含临时数据库、合成 API 端点、模拟文件系统以及确定性的网络延迟模拟器。候选智能体在 \(N\) 个独立的随机化测试夹具上执行，这些测试夹具既涵盖正常工作流程，也涵盖对抗性边界情况（例如网络分区、损坏的输入模式以及诱发幻觉的工具观测）。
第 2 层评估产生统计通过率。为了保证模型检查点或提示配置不会引入细微的回归问题，系统工程师基于 Wilson 得分置信区间的下界 \(\hat{p}_{\text{lower}}\) 制定严格的统计发布标准：
\[\hat{p}_{\text{lower}} \ge \Theta_{\text{target}}\]
如果智能体要求经验任务成功率达到 \(95\%\)，统计置信水平为 \(99\%\)（\(\alpha = 0.01\)），并且在 \(N = 500\) 个留出测试夹具上测试得到 480 次成功，则经验通过率为 \(\hat{p} = 0.960\)。计算得到的 Wilson 下界为 \(\hat{p}_{\text{lower}} \approx 0.934\)。由于 \(0.934 < 0.950\)，该候选版本未能通过第 2 层门禁，工程团队必须扩充测试语料或强化策略，才能将其晋升到生产环境。
第 3 层：金丝雀运行时遏制
无论离线基准测试套件多么广泛，都无法涵盖实时生产环境的全部熵。因此，验证金字塔的顶层在金丝雀发布期间实施持续的动态遏制和实时遥测门禁。
| 遏制阶段 | 子系统基础设施 | 操作不变量与边界控制 | 遥测信号 | 故障安全响应 |
|---|---|---|---|---|
| 流量路由 | 动态 L7 入口代理 | 加权流量分配（\(\rho \approx 0.02\)） | 实时入口速率与请求分布 | 立即将流量转移至稳定集群（v1.4） |
| 运行时沙箱 | 无特权 MicroVM（gVisor/KVM） | 无环境隐式权限；内存与 CPU 配额 | 容器启动延迟与内存压力 | 立即冻结沙箱并转储核心内存 |
| 系统调用过滤器 | 严格的 seccomp-bpf 拦截器 |
仅分派白名单中的系统调用；阻止 ptrace/原始套接字 |
被拦截违规的计数器 | 异步内核陷阱；终止进程 |
| 安全断路器 | SRE 错误预算监控器 | 错误预算消耗速率 \(< 2\times\) 基线阈值 | 工具重试激增、延迟尾部 \(P_{99}\) | 自动触发断路器；立即回滚 |
候选智能体配置通过第 1 层和第 2 层后，会被部署到规模极小的金丝雀组，处理极少量（例如 \(1\%\) 至 \(5\%\)）的生产流量。如 表 6 中形式化定义的那样，第 3 层通过三种必须实施的遏制机制包裹在线智能体：
- MicroVM 隔离与系统调用陷阱： 如 智能体沙箱 中的分析所述，智能体运行时在无特权 MicroVM（例如 Firecracker）或用户态内核沙箱（例如 gVisor）内执行。限制严格的
seccomp-bpf过滤器拦截并记录所有系统调用。任何未经授权的系统调用（例如尝试调用ptrace或绑定到未经批准的网络接口）都会立即触发异步内核陷阱，冻结容器镜像以供取证分析。 - 影子执行与只读试运行： 在操作语义允许的情况下，金丝雀智能体以影子模式运行：它接收真实的生产观测并计算候选动作，但所有会修改状态的工具调用都被重新路由到模拟执行层，或作为试运行进行评估。影子输出会与稳定生产系统采取的动作进行异步差异比较。
- 自动回滚断路器： 借鉴站点可靠性工程原则 (Beyer 等 2016年)，金丝雀的健康状态由错误预算消耗速率控制。运行时监督器持续流式传输遥测指标，例如工具重试率、模式异常频率、意外的人工干预以及延迟分布。如果金丝雀组的短期错误预算消耗速率超出安全限值，自动断路器就会触发，切断金丝雀的入口流量，并在数秒内将所有路由状态恢复到稳定基线。
表 7 对比了三个验证层级的运行特征。
| 维度 | 第 1 层：机械式验证 | 第 2 层：封闭式训练场评估 | 第 3 层：运行时遏制 |
|---|---|---|---|
| 执行边界 | 同步宿主监督器 | 离线 CI/CD 流水线 | 在线生产基础设施 |
| 延迟特征 | 亚毫秒至 \(5\text{ ms}\) | 数小时至数天（\(N \ge 10^3\) 次运行） | 持续进行（实时遥测） |
| 确定性 | 绝对确定性（\(100\%\) 确定性） | 统计性（随机采样） | 经验性 / 有界非确定性 |
| 主要失败响应 | 拦截令牌、中止、重新规划 | 阻止构建通过发布门禁 | 触发断路器、自动回滚 |
| 验证产物 | AST 转储、类型检查、SMT 日志 | Wilson 置信区间、日志 | 系统调用审计记录、错误预算 SLO |
粗略估算 0.6: 金丝雀群组规模设定与错误预算消耗
一个大规模企业智能体集群每天执行 \(100{,}000\) 个自动化管理工作流。服务级别目标（SLO）保证，所有工作流轨迹中有 \(99.9\%\) 能够在不发生安全违规且无需人工干预的情况下完成，对应的 30 天允许错误预算为：
\[E_{\text{budget}} = 30 \times 100{,}000 \times (1 - 0.999) = 3{,}000 \text{ allowed trajectory failures}\]
系统团队将新微调的策略检查点 \(\pi_{\theta_{\text{new}}}\) 部署到一个金丝雀群组，该群组承接的流量比例为 \(f_c = 0.02\)（\(2{,}000\) 个工作流/天）。运维人员并未察觉，一处细微的对齐退化导致 \(\pi_{\theta_{\text{new}}}\) 在 \(5\%\) 的真实世界轨迹上失败（失败率为 \(p_f = 0.05\)）。遥测引擎配置为：如果金丝雀群组消耗的错误预算超过集群 30 天总错误预算的 \(2\%\)，就触发自动回滚熔断器。
我们计算系统终止此次发布之前的实际检测延迟和故障影响总量：
分配给金丝雀群组的允许失败次数： \[F_{\text{limit}} = 0.02 \times E_{\text{budget}} = 0.02 \times 3{,}000 = 60 \text{ failures}\]
金丝雀群组每日预期失败次数： \[\mathbb{E}[\text{Failures/day}] = 2{,}000 \times p_f = 2{,}000 \times 0.05 = 100 \text{ failures/day}\]
熔断器触发所需时间（\(T_{\text{trip}}\)）： \[T_{\text{trip}} = \frac{F_{\text{limit}}}{\mathbb{E}[\text{Failures/day}]} = \frac{60}{100} \text{ days} = 0.60 \text{ days} \approx 14.4 \text{ hours}\]
故障影响范围限制： 在 {python} CanaryCohortsErrorBudget.trip_time_hours_str 的执行期间，金丝雀群组被自动切断并排空之前，恰好发生 {python} CanaryCohortsErrorBudget.failures_contained_str 次失败。如果将该策略直接发布到整个集群（\(f_c = 1.0\)），系统将产生： \[\text{Failures}_{\text{uncontained}} = 100{,}000 \times 0.05 \times 0.60 = 3{,}000 \text{ failures}\] 多层金丝雀发布门控成功将故障影响总量限制在总错误预算的 \(2\%\)，防止集群的运行可靠性缓冲被灾难性地耗尽。
最小化故障影响范围
即使经过全面的多层验证，任何软件架构也无法将非确定性策略的残余失败概率降至绝对零（\(\epsilon_{\text{res}} > 0\)）。因此，系统工程要求智能体架构从一开始就围绕优雅失效和故障影响范围限制进行设计。如果未能预防的模型故障突破第 1 层和第 2 层，宿主基础设施必须保证损害在影响范围、持续时间和权限上均受到严格限制。
为实现结构性限制，智能体运行时采用临时最小权限原则。提供给沙箱的所有数据库连接、文件句柄和云 API 令牌均为动态生成的临时凭据，并具有明确的存活时间（例如，\(TTL \le 120\text{ s}\)）。凭据通过密码学机制被严格限制为仅能访问当前任务契约中列举的确切资源标识符。如果失控的解码循环导致智能体尝试执行超出其指定工作区的操作，宿主内核或远程服务网格会以授权错误拒绝该请求。
此外，跨多个微服务的状态修改不能作为盲目的开环操作执行。运行时强制采用 Saga 模式（详见 故障恢复）：预写日志中登记的每个正向修改操作 \(a_t\) 都必须配有可执行的补偿事务 \(a_t^{-1}\)。如果在步骤 \(t+k\) 中触发了运行不变式违规，监督器会停止执行、禁止进一步的模型解码，并逆向遍历日志，执行补偿操作，将环境回退到已知的一致基线状态 \(s_0\)。
最后，该架构建立了正式的运行升级处理路径。当候选操作的估计不确定性超过安全边界，或工具调用涉及不可逆的物理影响（例如删除持久备份或发送公开通信）时，监督器不得猜测。运行时应暂停执行线程，将完整的推理上下文和状态快照写入持久存储，并将该操作提交至异步的人类在环（HITL）审批队列。系统向人工操作员呈现明确的主张、模型的因果论证，以及所提议的确切确定性差异。只有在获得授权人类主体的密码学确认后，监督器才会解除该操作的暂存状态，并提交状态转换。
当我们反思智能体系统的能力时，哪些历久弥新的软件工程原则决定了 AI 能解决什么、不能解决什么？由安全论证、机械验证器和沙箱运行时构成的架构凸显了一个深刻的事实：代码与动作生成的自动化并不能消除软件工程中的智力负担。要理解智能体委托的根本局限，我们必须回到 Frederick Brooks 对偶然复杂性与本质复杂性的经典区分。
Checkpoint 0.2: 评估实证安全论证与故障影响范围遏制
在探讨本质复杂性与自主代码生成的局限之前，请检验你对保障架构的理解：
本质复杂性与规约边界
将偶然复杂性自动化，使构成比例从 60/40 变为 11/89，净收益为 \(2.2\times\)。
设想一个自主智能体运行时接到指令，要将无缓冲的预写日志重构为异步、采用分组提交的环形缓冲区，并以现代内核提交队列作为支撑。在四十五秒内，宿主监督程序协调其基础模型生成数千个词元，输出数百行类型安全的 C++20 代码，配备一套模拟单元测试，并准备好一个看似完美的拉取请求。所有合成测试均通过。然而，当系统接受对抗性故障注入框架的测试，在并发磁盘刷写期间触发突发的内核崩溃时，存储引擎却发生了灾难性且不可恢复的页损坏。智能体忠实地保留了局部语法，复现了模拟测试框架，并加速了代码输出，却未能理解非易失性存储中至关重要的并发顺序不变量。合成单元测试之所以通过，恰恰是因为模型按照自身有缺陷的假设合成了验证器。
智能体代码合成大幅压缩了软件构建中与偶然复杂性相关的机械性工作，却丝毫没有减轻本质性的工程负担——制定抽象概念模型、不变量边界、故障拓扑和实证验证标准。认为自回归词元预测器能够消除软件工程，是将语法的物理实现与系统架构的智力构建混为一谈。要负责任地部署智能体机器学习系统，系统工程师必须借鉴软件工程的奠基性文献，将学习模型能够自动化的工作，与仍需由人类工程师承担、不可约简的架构职责区分开来。
自回归推理时代的 Brooks 二分法
四十年前，Frederick P. Brooks Jr. 确立了软件工程中偶然复杂性与本质复杂性的根本区分。偶然复杂性包括在物理媒介中实际实现概念构造时伴随的种种阻力：记忆语言语法、处理编译器的特异行为、分配与释放内存缓冲区、应对构建图，以及按序列化协议组织数据格式。相比之下，本质复杂性指的是对抽象软件实体进行概念构建时固有的困难：定义相互关联的状态空间、确立并发同步不变量、对领域约束建模，以及在分布式系统发生部分故障时保证确定性行为。Brooks 的著名论断是，任何单一的技术突破——无论是高级语言、分时系统，还是结构化编程——都无法使软件工程生产率实现一个数量级的跃升，因为偶然性阻力只占整个智力任务的一部分。
布鲁克斯二分法对现代智能体计算的数学含义绘于 图 9。在面板 A 中，项目工程总耗时 \(T\) 被分解为偶然性的实现阻力与不可约减的本质性架构工作（本质性架构工作为 \(T_{\text{ess}} = 48\text{ hours}\)，对应于 0.7 中分析的 LSM 树存储引擎重构）。随着模型对偶然性工作的加速因子 \(S_{\text{acc}}\) 从 \(1\times\) 增长至 \(20\times\)，理想周转时间曲线（蓝色实线）迅速趋于平坦，逼近水平渐近线 \(T_{\text{ess}}\)：将语法生成时间压缩至零，并不能压缩人类为证明状态不变量、验证恢复语义和设计威胁边界所需付出的智力劳动。此外，若将实际情况纳入考量（橙色虚线），审核大量候选拉取请求以及构建不存在循环验证的集成测试夹具会引入审核开销，使总耗时始终无法达到理论最小值。在面板 B 中，阿姆达尔定律形式化地描述了由此产生的净加速比上限 \(S_{\text{net}} = 1 / [(1 - f_{\text{acc}}) + f_{\text{acc}} / S_{\text{acc}}]\)。对于偶然性阻力占工作量 \(60\%\) 的任务（\(f_{\text{acc}} = 0.60\)），生产率的最大加速比在数学上被限定为 \(2.5\times\)；而深层架构工作负载（\(f_{\text{acc}} = 0.40\)）则会触及 \(1.67\times\) 这一不可突破的上限，这说明了为什么仅提高 token 输出速率无法彻底变革系统软件的交付。
彼得·瑙尔论理论构建（1985）： “严格意义上的编程必须被视为一种知识的构建过程：了解程序如何满足其需求、各部分如何相互关联，以及程序将如何应对变化……仅凭程序文本，无法传递或审视这些知识。”
按照彼得·瑙尔的奠基性论著《编程即理论构建》中的表述，计算机程序并非仅仅是编译后的文本与测试脚本的集合。相反，程序是工程团队所持有的内部心智理论外化后留下的产物，是一种动态的概念模型，详细描述软件如何映射到其运行环境、其状态不变量如何应对压力，以及应如何处理边界情况。在开源代码仓库上训练且不具备特权的神经网络掌握了 token 序列之间的统计相关性，但对这一运行理论既不承担内在责任，也缺乏物理层面的基础。当智能体输出代码时，它会从以提示上下文为条件的自回归分布 \(\pi_\theta\) 中采样候选状态转移。它并不具备关于宿主系统运行时不变量的、经过验证的心智模型。
软件范式演进 梳理了从软件 1.0 经由 2.0 到 3.0 的演进。通过布鲁克斯的理论来理解，每次转变都改变了偶然性繁重工作所处的位置，却未缩减本质性核心，如 表 8 所示。
| 架构维度 | 软件 1.0（命令式与面向对象） | 软件 2.0（深度学习系统） | 软件 3.0（智能体机器学习系统） |
|---|---|---|---|
| 偶然性负担 | 语法、手动内存管理、编译错误 | 超参数扫描、CUDA 内核、数据流水线 | API 衔接代码、提示脚手架、样板代码转换 |
| 本质性核心 | 具体算法与状态机设计 | 损失函数构建、归纳偏置、评估分布 | 不变量规约、沙箱隔离、安全论证 |
智能体运行时自动完成将意图机械地转化为候选动作的过程，但定义意图、限定运行范围以及验证状态转移仍然是架构问题。
实现阻力的转化
自主智能体究竟自动化了什么？自回归模型以每个加速器每秒 50 至 150 个 token 的标准推理速度运行，消除了输入语法、查找不熟悉的库函数签名、编写重复的样板序列化例程，以及将数据库模式转换为对象模型时的机械性延迟。这种加速意味着偶然性复杂度被大幅压缩。过去需要数小时手动检索和输入的任务，如今可以在数秒内形成初稿。
然而，压缩代码实现的延迟会暴露一种危险的失效模式：循环验证陷阱。当自主智能体被要求实现某项功能并同时编写验证套件时，模型自然会以内部一致性为优化目标，而非外部运行事实。如果模型误解了异步锁协议，它就会生成单元测试，对同一套有缺陷的加锁序列进行模拟并作出断言。单元测试通过并显示绿色勾选标记，营造出正确性的假象，而系统的本质性不变量仍遭到违反。
为量化这种加速对实际运行的影响，系统工程师必须将阿姆达尔定律应用于工程生命周期。令 \(T_{\text{total}}\) 表示交付一个经过验证的系统组件所需的工程总耗时。该耗时分为偶然性部分 \(f_{\text{acc}}\)（生成语法、查找 API、起草样板代码）和本质性部分 \(1 - f_{\text{acc}}\)（规定不变量、构建故障模型、设计验证判定机制、分析并发边界）。如果一套智能体工具将偶然性实现工作加速 \(S_{\text{acc}}\) 倍，则净加速比 \(S_{\text{net}}\) 由下式决定：
\[S_{\text{net}} = \frac{1}{(1 - f_{\text{acc}}) + \frac{f_{\text{acc}}}{S_{\text{acc}}}}\]
即使智能体运行时将偶然性实现时间压缩至零（\(S_{\text{acc}} \to \infty\)），理论上的最大生产率加速比仍严格受限于：
\[\lim_{S_{\text{acc}} \to \infty} S_{\text{net}} = \frac{1}{1 - f_{\text{acc}}}\]
粗略估算 0.7: 压缩偶然复杂性
以往，这项工程工作需要资深工程师投入 \(T_{\text{total}} = 120\text{ hours}\) 的时间，具体分为：
- \(T_{\text{acc}} = 72\text{ hours}\)（\(f_{\text{acc}} = 0.60\)）：编写 C++ 样板代码、定义序列化模式、配置构建文件，以及编写常规的模拟测试框架代码。
- \(T_{\text{ess}} = 48\text{ hours}\)（\(1 - f_{\text{acc}} = 0.40\)）：证明能够避免写入停顿、定义预写日志恢复不变量、验证快照隔离级别，以及调优压缩调度。
团队配备了一个自主智能体运行时（例如先进的代码生成运行框架）来执行此次重构。对于偶然性任务，智能体实现了 \(S_{\text{acc}} = 12\times\) 的实现速度提升。然而，由于智能体生成了 \(8{,}000\) 行候选 C++ 代码，其中包含对边界情况的微妙假设，人类工程师必须额外花费 {python} CompressionAccidentalComplexity.audit_time_str 来审查生成的代码差异、构建不依赖循环论证的压力测试框架，并验证崩溃恢复语义。
计算：
- 本质性工作耗时保持不变时的理想加速比。
- 将审查和验证开销计入后的实测净加速比 \(S_{\text{net}}\)。
- 现在本质性工程工作占项目总时间的百分比。
解答：
理想加速比（本质性工作耗时不变）： 新的偶然性工作耗时为： \[T'_{\text{acc}} = \frac{T_{\text{acc}}}{S_{\text{acc}}} = \frac{72\text{ h}}{12} = 6\text{ hours}\] 在 \(T_{\text{ess}} = 48\text{ hours}\) 的情况下，理想总耗时为： \[T'_{\text{ideal}} = 6\text{ h} + 48\text{ h} = 54\text{ hours}\] \[\text{Speedup}_{\text{ideal}} = \frac{120\text{ h}}{54\text{ h}} \approx 2.22\times\]
实测净加速比（计入验证开销）： 计入额外的 \(6\text{ hours}\) 审查和验证开销后，实测本质性工作耗时变为： \[T''_{\text{ess}} = 48\text{ h} + 6\text{ h} = 54\text{ hours}\] 实测总耗时为： \[T''_{\text{total}} = T'_{\text{acc}} + T''_{\text{ess}} = 6\text{ h} + 54\text{ h} = 60\text{ hours}\] 实测净加速比为： \[S_{\text{net}} = \frac{T_{\text{total}}}{T''_{\text{total}}} = \frac{120\text{ h}}{60\text{ h}} = 2.00\times\]
工程重心的转移： 在基准人工工作形态下，本质性工程工作所占的时间比例为： \[\frac{48\text{ h}}{120\text{ h}} = 40.0\% \text{ of project time}\] 在智能体加速的工作形态下，本质性工程工作所占的时间比例为： \[\frac{54\text{ h}}{60\text{ h}} = 90.0\% \text{ of project time}\]
系统洞见： 尽管在键入代码、查阅语法和组装样板代码方面实现了高达 \(12\times\) 的工作量削减，项目交付的净加速比却恰好为 \(2.0\times\)。关键路径几乎已完全转移到本质性系统工程工作上：定义不变量、生成对抗性测试，以及验证安全性。
因此，即使将实现过程中的摩擦降至零，本质性工作以及由此决定的加速比上限仍掌握在工程师手中。关键路径从编写代码转向规定不变量，以及构建用于判定代码是否满足要求的验证器。
架构决策权
系统工程的本质性核心无法委托给模型，原因在于两种不同的验证成本。
对自回归模型进行采样的计算量是有界的，每生成一个词元需要 \(O(L_{\text{seq}} \cdot d_{\text{model}})\) 次浮点运算，因此生成五百行候选系统代码的成本很低。对这些代码执行明确规定的机械检查，例如一次编译器检查或一套封闭测试，同样成本很低，而运行时正是依赖这种验证不对称性（原则 3）。判断检查是否覆盖了任务要求，也就是是否覆盖并发交错、网络分区和恶意输入下的每一项全局不变量，则是另一个问题。这个问题在一般情况下是不可判定的，无论从模型中采样多少次，都无法解决。
由于采样无法决定检查必须覆盖哪些内容，智能体系统的完整性取决于工程师编写的任务契约：
\[\mathcal{C} = \langle G, \mathcal{E}_{\text{env}}, \mathcal{A}_{\text{perm}}, \mathcal{O}_{\text{avail}}, \mathcal{K}_{\text{comp}} \rangle\]
这五个组成部分均不能由其所约束的模型来编写（原则 24）：
- 目标制定（\(G\)）： 自回归模型最小化文本分布上的下一词元交叉熵损失；它不具备内在目标或操作意图。系统应当实现什么，其规范完全源于人类目的和组织需求。
- 环境边界（\(\mathcal{E}_{\text{env}}\)）： 定义智能体运行所处的安全命名空间、文件系统挂载点、虚拟私有云和内存限制，是系统虚拟化的核心任务。
- 允许的动作集合（\(\mathcal{A}_{\text{perm}}\)）： 模型不具有任何隐式权限，因此工程师必须明确筛选和配置向运行时开放的、经中介访问的 RPC 端点、工具和词元配额。
- 观测过滤（\(\mathcal{O}_{\text{avail}}\)）： 智能体运行时必须以确定性的方式隐去凭证、过滤专有上下文，并强制执行内存来源追溯要求，以防止提示注入和数据外泄。
- 完成标准（\(\mathcal{K}_{\text{comp}}\)）： 验收标准不能是模型的主观自我评估。正确性必须通过独立、确定性的软件判定机制来确立：编译器检查、静态代码检查、确定性重放基准测试，以及封闭的集成测试套件。
这种关注点分离是不变量闭合（端到端边界的双重保证）中端到端层面的那一半，其适用对象是编写契约的工程师，而非执行契约的运行时。在智能体架构中，基础模型是一个不受信任的底层组件，负责生成候选状态转移。监督器、沙箱和实证测试框架构成具有最终裁决权的端点。
最后，系统工程具有一个不可化约的道德与运维维度：问责责任的归属。当自动化系统管理金融交易、编排电网故障切换或重构医疗器械固件时，一旦不变量失效，无特权的神经网络无法承担法律责任或运维责任。模型既没有可供追缴的资产，也没有需要履行的职业责任。人类系统工程师仍然是唯一有权委托编制安全论证、确立风险边界并授权部署的主体。
在本书中，我们始终在分析数字智能体系统的运行机制：无特权模型、隔离的 Linux 沙箱、PagedAttention 内存缓冲区，以及确定性验证框架。在数字领域内，错误可以隔离，git 分支可以弃用，沙箱容器可以销毁，数据库事务可以利用预写日志回滚。然而，当智能体执行循环脱离可逆数字内存的安全保障，直接连接到在连续且不容妥协的物理环境中运行的电机、传感器和执行器时，会发生什么？
具身智能体的前沿
当运行在无特权 POSIX 容器内的数字智能体运行时发出错误命令，例如无效的数据库迁移或递归删除文件系统时，宿主监督器会拦截越界行为，或在不到五毫秒内回滚底层写时复制（CoW）存储卷。临时内存占用被清除，尚未提交的预写日志被截断，执行监督器将进程树重新实例化为已知的一致状态 \(\mathcal{S}_0\)。如果将同一个神经网络推理引擎连接到工业伺服驱动器、化学混合阀或自动驾驶车辆的转向齿条，物理环境并不提供写时复制抽象。热力学耗散、机械应力和动量传递在数学上不可逆。一旦电信号使执行器线圈通电，物理状态空间就会发生不可逆的转移，使推测性分支和试错探索可能造成致命后果。
本书中确立的各项保证都假设，一个效应要么在沙箱内可逆，要么在沙箱外可补偿，而物理执行两者皆不具备。 数字智能体虽然支持在沙箱内进行推测性执行和低成本回滚，但它也暴露出数字计算机系统内部深层且尚未解决的系统挑战：任务验证不完备、执行目标非平稳，以及难以求解的长时程信用分配。明确这些数字抽象在何处失效，就界定了软件智能体运行时与物理具身系统之间的操作边界。
数字安全包络
无特权智能体系统的基础架构依赖于第二、第三和第四部分中阐述的四项数字不变量：
- 零隐式权限：每个修改状态的操作都必须在托管内存缓冲区中声明为候选变更，依据明确的安全策略进行评估，并且只能通过起中介作用的能力令牌执行。
- 临时虚拟化：执行底层采用容器化命名空间、隔离的虚拟内存地址空间以及写时复制（CoW）文件系统快照（例如
overlayfs或 ZFS 克隆），将推测性试运行与权威真实状态解耦。 - 同步逻辑时间：在纯数字环境中，外部时间可以被冻结。当自回归模型针对数千个 KV 缓存词元执行持续数秒的解码阶段时，目标沙箱环境保持挂起，等待下一次离散的远程过程调用（RPC）。
- 确定性机械验证：候选状态转移由确定性、可重入的软件判定器验证，例如类型检查器、代码检查器、编译器和封闭隔离的单元测试套件，这些判定器输出通过或失败的二元信号。
这四个不变量将数字智能体的执行转化为离散有向无环图上的探索性搜索问题（图 10，面板 A）。智能体从初始系统状态 \(s_0\) 出发，推进到状态 \(s_1\)，并评估候选动作分支。当推测性分支 \(a_1'\) 导致失败状态 \(s_{\text{err}}\)，例如编译缺陷、静态类型检查失败或测试断言被违反时，执行监督器会启动瞬时写时复制回滚（\(T_{\text{rollback}} < 5\text{ ms}\)）。错误的上下文前缀被剪除，临时 Linux 容器被销毁，执行恢复到 \(s_1\)，且不会造成附带损坏。随后，智能体可以探索替代分支 \(a_1\)，到达已验证状态 \(s_2\)，并最终将轨迹 \(\tau^*\) 提交到 \(s^*\) 处的持久存储。探索的资金成本严格限定为词元推理和虚拟容器回收的成本。
与此形成鲜明对比的是，物理具身智能体在无法规避的连续动力学相空间 \(x(t) \in \mathcal{X}\) 中运行，该相空间受非线性运动方程 \(\dot{x} = f(x, u)\) 支配（图 10，面板 B）。由于动量传递和动能耗散在热力学上不可逆（\(T_{\text{reversal}} = \infty\)），在真实环境中通过试错进行探索会带来危及存续的风险。当不具备特权的高层神经规划器输出候选控制指令 \(u_{\text{neural}}\)，使系统朝着不安全的障碍物或运动学边界前进时（\(h(x) < 0\)），物理系统无法承受先发生碰撞、再执行事后回滚的过程。相反，硬实时控制屏障函数（CBF）安全防护层会在小于 \(1\text{ ms}\) 的时间内拦截该指令，将 \(u_{\text{neural}}\) 投影到允许的安全控制空间 \(u_{\text{safe}}\) 上，以确保安全集 \(\mathcal{X}_{\text{safe}} = \{x \mid h(x) \ge 0\}\) 的前向不变性。
然而，将数字系统视为普遍安全、封闭隔离的试验场是一种理想化。即使在纯软件领域，系统工程师也会遇到明确的边界，超出这些边界，完全可观测性、确定性重放和低成本可逆性的假设便不再成立。
数字智能体验证的开放前沿
在考虑物理执行之前，纯数字智能体运行时内部仍有三个尚未解决的基础性系统挑战：判定器缺失、非平稳环境漂移，以及组合性信用分配。
判定器缺失
贯穿本书，防范模型幻觉的主要手段一直是不变量闭合中的端到端部分（端到端边界的双重保证）：只有满足外部确定性验证器要求的提案才会被接受。在编译器驱动的软件工程中，这种验证器有明确的定义：代码必须在无警告的情况下完成编译，通过静态分析，并满足封闭回归测试套件的要求。
然而，对于广泛的现实计算工作负载，无法构造机械判定器。例如，智能体可能受托重构多层微服务架构以提升“运维可维护性”，综合一万份预印本 PDF 编写详尽的文献综述，或优化分布式查询规划器以降低尾延迟方差。在这些领域，规范本质上是不完整的。要编写确定性测试框架来验证架构是否“可维护”，就必须解决委托智能体处理的那个语义理解问题本身。
当系统设计者缺乏确定性判定器时，往往会用另一个被配置为评估器的基础模型替代，这就是“以 LLM 为裁判”的模式。从架构角度看，这种替代违反了系统的模块化与故障隔离保证。用另一个随机预测器替换确定性验证器，意味着放弃第一部分中的验证不对称性，因为此时检查器与生成器具有相同的盲点、校准误差和提示注入风险，而加大针对该检查器的搜索力度，会筛选出利用检查器错误的结果（过程验证）。为开放式数字任务建立严谨且不依赖循环论证的验证方法，仍然是系统工程中活跃的研究前沿。
非平稳环境风险
数字系统中的第二个开放挑战是环境平稳性假设失效。在基准评估中，智能体面对的是操作系统或软件仓库的隔离、冻结快照。在生产部署中，智能体则与实时外部生态系统交互：远程 SaaS API、生产关系型数据库、云基础设施平面，以及同时开展工作的工程师。
在这些环境中，外部状态会在智能体的审慎推理周期内异步变化。在步骤 \(t=3\) 仍然有效的 API 模式，到了步骤 \(t=45\) 可能已被弃用；初始化期间刷新的身份验证令牌可能在轨迹执行中途过期；或者，在智能体执行持续数小时的变基操作时，工程师可能向上游主干分支推送提交。
标准数据库事务概念，例如严格两阶段锁定（S2PL）或快照隔离（SI），无法简单地延伸到整个智能体轨迹。在智能体持续数分钟的推理解码循环期间一直持有数据库锁，会在生产服务中造成严重的锁竞争、饥饿和级联中止。反之，采用乐观并发控制时，如果提交时的验证检查失败，智能体就会面临较高的事务中止率，被迫对长时间的审慎推理轨迹执行成本高昂的回滚。设计能够处理异步、非平稳外部变更，同时又不使全局吞吐量停滞的分布式协同原语，仍是一个尚未解决的系统工程问题。
密集轨迹中的长时程信用分配
第三个数字系统挑战是：在由数百个相互依赖的动作组成的轨迹中，分配责任或贡献具有组合性难度。设想一个自主调试智能体试图诊断分布式流处理集群中的内存泄漏。执行轨迹包含数千次离散的工具调用：读取配置文件、运行网络诊断、挂接内核性能分析器、修改线程池分配，以及调整垃圾回收标志。
在步骤 \(t = 840\)，一次端到端负载测试因内存耗尽而崩溃。确定此前哪个动作引发了失败，是一个病态逆问题。失败究竟源于步骤 \(t = 42\) 引入的错误内核可调参数、步骤 \(t = 310\) 中被错误解析的指标日志，还是步骤 \(t = 2\) 形成的本身存在缺陷的架构假设？
粗略估算 0.8: 回溯搜索的组合成本
假设宿主运行框架仅在终止边界 \(t = T_{\max}\) 通过端到端集成测试检测到不变量被违反。如果监督器必须通过无引导的回溯搜索来确定导致失败的根本原因，则理论状态空间为：
\[\Omega_{\text{naive}} = B^{T_{\max}} = 4^{50} \approx 1.27 \times 10^{30} \text{ paths}\]
现在考虑一个经过专门设计的运行框架，它使用隔离的写时复制（Copy-on-Write）子卷，每隔 \(K = 5\) 步强制执行一次中间验证检查点。完整轨迹被划分为 \(M = T_{\max} / K = 10\) 个解耦阶段。每个阶段需要承担 \(t_{\text{snap}} = 15\text{ ms}\) 的 CoW 快照开销，并运行一套耗时为 \(t_{\text{verify}} = 1.2\text{ s}\) 的局部验证测试。
如果在阶段 \(m\) 出现不变量违反，监督器会将错误定位到局部窗口 \([(m-1)K, mK]\)。该阶段的局部搜索空间上界为：
\[\Omega_{\text{stage}} = B^K = 4^5 = 1{,}024 \text{ candidate trajectories}\]
评估这 1,024 条局部轨迹所需的时间最多为：
\[T_{\text{recovery}} = 1{,}024 \times (t_{\text{verify}} + t_{\text{snap}}) = 1{,}024 \times (1.200\text{ s} + 0.015\text{ s}) \approx 1{,}244 \text{ seconds}\]
通过在智能体运行时中设置离散的验证屏障和 CoW 回滚检查点，监督器将一个无法完成的 \(10^{30}\) 全局信用分配搜索，缩减为一个有界的局部搜索问题，其执行时间约为 {python} CombinatorialCostBacktrackingSearch.recovery_time_min_str。
在实践中，每隔几步对状态执行检查点操作会产生不可忽视的存储和执行开销。尽管 CoW 文件系统支持快速的指针操作，但内存中的进程状态（例如已打开的网络套接字、活动线程池和共享内存段）无法通过简单的磁盘快照进行检查点保存。如果智能体的中间动作修改了未纳入检查点的外部依赖项，回滚就会变得不可能，迫使运行时中止整条轨迹。
当一条长轨迹在最终检查时失败，找出导致失败的步骤就是一个逆问题。日志记录了一条路径，但要回答在哪一步采取何种不同动作才能成功，就需要考察智能体未选择的所有分支。举例而言，若每一步有四个候选动作，而失败直到一个五十步任务结束时才被检测到，那么该空间就包含 \(4^{50} \approx 10^{30}\) 条路径，远超任何回放预算。中间检查会改变这一计算结果。每五步进行一次检查，就能将失败限定在一个包含 \(4^{5} = 1,024\) 种备选路径的窗口内；按每次回放检查约需 1.2 s 计算，搜索大约需要二十分钟。回放与反事实分支探索（重放、事件取证复盘）使这种局部搜索在事后具备可行性，前提是窗口内的步骤仅涉及运行时能够恢复的状态。在多轮强化学习（可验证奖励强化学习）中逐轮进行信用分配则更为困难，因为这一信号必须能够在训练规模下获得，而不能依靠逐次进行事后分析。
执行器驱动的门槛：迈向物理具身
当智能体的动作空间从修改数字比特转向驱动物理物质时，基础系统契约就会彻底改变。隔离沙箱所提供的便利不复存在。在物理环境中，无论是自主配送无人机、机器人手术臂，还是先进半导体制造设施中的机器人工作单元，动作都发生于具体的物理情境中，持续相互耦合，并且在能量层面不可逆。
关键洞见（Brooks，1991）： Rodney Brooks 在其开创性论文《无需表征的智能》中指出，“世界本身就是它最好的模型。” 数字智能体在 token 上下文窗口中维护软件状态的复杂符号表征。在物理系统中，试图将连续的物理过程离散化为符号文本 token，不可避免地会遭遇严重的表征滞后与认知信息损失。
数字轨迹与物理具身约束
区分数字智能体与物理智能体的系统边界由七项核心架构权衡界定，概述见 表 9。
| 系统维度 | 数字智能体运行时 | 物理具身系统 |
|---|---|---|
| 状态空间（\(\mathcal{S}\)） | 离散的结构化文本、抽象语法树（AST）和 POSIX 文件系统状态 | 连续、动态、非线性的 \(SE(3) \times \mathbb{R}^n\) 相空间 |
| 时间语义 | 逻辑时间；推理解码期间执行暂停 | 连续的物理墙钟时间；惯性与动量持续起作用 |
| 动作可逆性 | 借助写时复制（CoW）快照、git 树和数据库回滚，成本接近于零 | 在热力学和机械层面不可逆；做功已消耗能量 |
| 控制延迟预算 | 灵活：每个自回归推理周期为 \(500\text{ ms}\) 至 \(30\text{ s}\) | 硬实时：控制回路的截止时限为 \(1\text{ ms}\) 至 \(20\text{ ms}\) |
| 可观测性模型 | 完全或大部分可观测的离散状态码、字符串和日志 | 部分可观测、含噪声且存在遮挡的传感器阵列（POMDP） |
| 故障影响范围 | 文件损坏、进程崩溃或 CI/CD 流水线运行失败 | 机械损毁、部件疲劳、建筑物火灾或人员死亡 |
| 验证屏障 | 确定性的编译器、静态检查工具和封闭隔离的单元测试套件 | 形式化控制屏障函数（CBF）、安全防护机制和物理触发装置 |
连续时间与审慎推理延迟
在数字领域，时间是逻辑性的，与墙钟所反映的现实时间解耦。当智能体暂停 15 秒，在多个模型检查点之间执行复杂的思维树搜索时，目标代码库不会退化。编译器会耐心等待下一次由智能体生成的 shell 调用。
在物理领域，时间是一个严格且连续的物理维度。一架在障碍物密布的森林中穿行的自主无人机，无法在其机载视觉—语言—动作（VLA）模型以自回归方式生成下一个 token 时暂停空气阻力和重力。如果推理流水线因内存总线争用或 KV 缓存驱逐而出现 300 毫秒的调度延迟，飞行器就会沿其动量向量在失控状态下移动数米。在物理系统中，较高的审慎推理延迟会直接降低系统稳定性与安全性。适用于软件生成的解耦异步推理循环，在没有确定性安全接管机制的情况下，与实时反馈控制存在根本性的不兼容。
理论基础： 在《部分可观测随机域中的规划与行动》中，Kaelbling 等 (1998年) 形式化了部分可观测马尔可夫决策过程（POMDP）的数学理论。数字智能体任务通常可以通过清晰的 POSIX 检查 API 接近完全可观测的马尔可夫状态，而物理系统则必须在传感器噪声和遮挡条件下，持续维护不可观测环境变量的概率分布（信念状态）。
不可逆执行动作的风险
数字智能体优化的核心特性——通过大规模试错探索进行强化学习（RLVR，详见 可验证奖励强化学习）——完全依赖于宿主能够以零物理成本将环境重置数百万次。针对软件缺陷进行训练的智能体可以触发十亿次段错误，而不会损坏宿主 CPU。
在具身系统中，物理世界中的试错探索受到物理磨损、能量成本和灾难性失效模式的约束。通过随机采样探索关节力矩的四足机器人，很快就会剪切损坏其齿轮箱、烧毁无刷电机绕组，或与附近结构发生碰撞。
因此，具身架构不能依赖端到端的无特权神经模型来直接控制执行器电流。系统边界要求采用分层的层级分解：必须将无特权的高层语义规划器与底层硬实时确定性控制器严格解耦。底层控制回路受形式化的控制屏障函数（CBF）和物理限位开关约束，无论高层神经规划器发出何种无效、高延迟或幻觉指令，都能维持系统稳定性并强制执行不变的安全包络。
这种根本性的关注点分离在 图 11 所示的分层安全屏障架构中得到形式化。该架构将控制层级分解为四个解耦的执行层，在统计推理与物理执行之间实施严格隔离：
- 第 1 层：无特权高层规划器（LLM / VLA）： 基础模型在较高的审慎推理延迟（\(200\text{ ms}\) 至 \(2{,}000\text{ ms}\)）下运行，不具备任何环境隐式权限，负责语义目标分解、任务排序和场景理解。其输出被严格视为不可信的候选动作轨迹，并暂存于内存托管区。
- 第 2 层：确定性安全屏障与屏障层： 这一具有控制权限的监督器以亚毫秒级延迟（\(< 1\text{ ms}\)）运行，依据形式化的运动学不变量、碰撞几何和控制屏障函数（\(h(x) \ge 0\)）评估候选轨迹。它拥有抢占式权限，可在生成任何物理信号之前，对错误的设定值进行过滤、限幅，或将其重新投影到可证明安全的状态边界内。
- 第 3 层：硬实时执行流水线（RTOS）： 高频反馈回路（如比例—积分—微分（PID）控制器和模型预测控制（MPC））通过 CAN 总线或 EtherCAT 等确定性现场总线调度，遵循小于 5 ms 的截止期限（\(< 5\text{ ms}\)），计算瞬时电机电流和关节力矩 \(u_t\)。
- 第 4 层：物理执行器与原子： 大功率无刷电机绕组、谐波齿轮箱和液压泵将电能转化为机械功。在这一层，状态变更进入不可逆的热力学形态（\(T_{\text{reversal}} = \infty\)），物理动量、热摩擦和结构应力无法通过软件回滚撤销。
对这些硬实时保证、跨吉赫兹流水线的多模态传感器融合、非线性控制不变量，以及将神经模型安全地落实到现实世界所必需的物理安全屏障的探讨，构成了物理具身智能体系统的核心课程内容。
在描绘数字智能体系统的架构顶峰，并明确数字保证让位于物理约束的边界之后，我们将在本书的最后直面那些经常导致生产部署失败的工程误解。当系统工程师未能认识到学习所得的统计近似与确定性运行控制之间的严格边界时，灾难性系统故障就不可避免。接下来，我们将探讨这些根本性的谬误与陷阱。
谬误与陷阱
将智能体系统部署到任务关键型生产环境中，会暴露出基础模型开放式生成能力与可信赖计算机系统所要求的严格不变式之间的根本矛盾。在经典系统架构中，性能提升和可靠性改进源于确定性抽象：严格的内存保护边界、形式化的进程隔离、原子提交协议以及定义明确的机器接口。当工程团队将随机性神经预测器引入这些架构时，他们常常陷入概念上的捷径——将统计上的流畅性误认为确定性的正确性，或将模型视为能够凌驾于系统工程原则之上的全能推理引擎。本节剖析四种普遍存在、会导致生产环境智能体部署偏离正轨的谬误与陷阱，分析其失效机制的根源，并形式化阐述相应的架构缓解措施。
谬误： 未来的基础模型将变得如此强大，以至于系统工程、隔离机制和验证框架都不再必要。
这一谬误源于一种外推式信念，即规模定律最终会将所有运行所需的软件压缩为单一的神经网络权重检查点。按照这一观点，模型参数数量的增加和后训练优化的进步将使自回归生成的错误率降至零，从而使运行时沙箱、基于能力的权限检查、预写日志和机械化验证器成为技术尚未成熟时留下的冗余产物。
这一推理的失效机制在于混淆了统计模式补全与确定性系统不变式的强制执行。自回归基础模型作为策略 \(\pi_\theta(a_t \mid \mathcal{H}_t)\)，以观测历史 \(\mathcal{H}_t\) 为条件，生成离散词元上的概率分布。即使前沿模型的规模扩展将单步错误率降低至很小的 \(\epsilon\)，需要数百次顺序工具调用的任务仍然面临 时间跨度拉伸：从纳秒指令到千秒级轨迹 的开环可靠性上限，因此，除非外部监督器介入以遏制错误传播，否则随机漂移必然导致最终偏离。
更为关键的是，扩大计算规模并不能解决混淆代理的结构性漏洞。由于基础模型将自然语言指令与不可信的第三方数据交织在同一个统一的注意力上下文中，无论参数规模如何，对抗性输入或含糊的环境观测都可能诱发提示注入。在语义层面，万亿参数模型无法免受指令与数据混淆的影响，正如未打补丁的操作系统内核在内存层面无法免受缓冲区溢出的影响一样。
架构防御遵循 Saltzer 和 Kaashoek 的模块化与最小权限原则。模型始终是一个不具备特权、非确定性且不拥有任何隐式权限的组件；进程隔离、文件系统权限、网络访问边界、状态转换有效性以及数据完整性均由宿主运行时强制保障，绝不交由模型负责。随着模型能力扩展、智能体获得更广泛的操作权限，对稳健的系统工程、密码学证明、确定性执行框架和形式化验证的需求只会变得更加迫切，而不会减弱。
陷阱： 将通过合成单元测试视为生产就绪的完整证明。
工程团队经常通过构建合成测试套件来验证智能体系统——使用干净的基准测试夹具、模拟工具接口和静态代码仓库快照来评估智能体。当智能体在这些隔离的测试框架中取得较高的通过率时，系统便被认定已具备生产部署条件。然而，一旦接入真实运行的基础设施，智能体的任务完成率就会骤降，并且往往伴随着资源消耗失控或工作区状态损坏。
这一隐蔽的失效模式源于合成评估框架在理想化、平稳的环境中评估智能体，从而掩盖了现实世界中的熵。在合成测试套件中，初始环境 \(\mathcal{S}_0\) 处于纯净状态，模拟 RPC 端点即时返回确定性响应，文件树结构井然有序，网络操作也从不遭遇部分数据包丢失或暂时性限流。生产环境则违背了上述每一项假设：文件树中包含过时的编译产物和此前崩溃留下的未提交锁文件，内部微服务在暂时性过载时返回格式错误的错误载荷，数据库事务则会遭遇死锁或读偏斜。
当仅在合成基准上接受训练或评估的智能体遇到不干净的环境状态——例如遗留的构建锁或未处理的 HTTP 503 响应——其上下文内恢复启发式策略会迅速退化。由于智能体从未接触过运行异常中充满噪声的长尾情况，它经常陷入病态的重试循环：反复执行相同的失败命令，凭空编造不存在的命令行标志以绕过意外错误，或输出灾难性的清理脚本，为满足眼前的编译目标而清空整个目录。
架构层面的缓解措施要求构建多层级的实证安全论证，以弥合合成断言与实际运行之间的认知鸿沟。第 1 层单元测试确认基本的语法合规性和正常的工具调用，而第 2 层验证必须让智能体接受配备专门故障注入框架的统计测试场基准测试。这些测试场会系统性地向执行沙箱注入非确定性的环境漂移、过期的套接字锁、乱序日志条目和网络延迟抖动。最后，第 3 层金丝雀部署关卡必须强制实施运行时熔断机制：限定资金预算和步骤预算，持续监控回滚频率，并在轨迹偏离正常错误恢复边界的任何智能体实例影响线上生产状态之前，将其隔离。
谬误： 自主智能体消除了对人类软件工程师的需求。
自主编码与运维智能体的出现，再次激活了历史上反复出现的一种论断：更高层次的软件抽象会使人类工程师过时。在这种叙事中，自然语言成为终极的规格说明语言：人类利益相关者向自主智能体描述需求，智能体则在无人干预的情况下合成、测试并部署整个软件制品。
这一谬误混淆了偶然复杂性与本质复杂性，这是 Fred Brooks 提出的一个基础性区分。偶然复杂性是指在物理计算环境中表达概念设计时产生的操作阻力：记忆编程语言语法、配置构建工具链、解决依赖冲突、编写重复的样板接口，以及机械地重构方法签名。自主智能体擅长压缩偶然复杂性，因为这些操作对应于其预训练分布中的高密度统计相关性。
相反，本质复杂性涵盖软件工程中根本性的智力劳动：构建领域抽象、定义明确无歧义的系统边界、解决相互冲突的业务需求、为分布式状态选择一致性模型，以及建立能够保证故障条件下正确性的形式化不变量。自主智能体既不承担领域责任，也不具备对业务权衡的内在理解。当人类工程师放弃架构监督时，承担功能实现任务的智能体会依据其能够观察到的狭窄验收标准进行局部优化。为了让失败的集成测试通过，智能体会悄然绕过安全中间件、跨服务边界复制有状态组件，或将特定环境的假设硬编码到共享库中。由此产生的代码库会迅速出现架构腐化：尽管各个单元都能通过局部检查，整个系统却在结构上变得不协调、难以维护且脆弱。
架构层面的防御措施是将自主智能体组织为效能倍增器，并使其严格在由人类治理的架构边界内运行。人类软件工程师必须将其主要职责从手动生成代码提升为系统架构、形式化规格说明和不变量设计。人类定义由五个部分组成的任务契约，将智能体运行框架的执行范围限定在安全沙箱内，并依据系统级一致性模型验证智能体合成的轨迹，从而长期维护软件系统的概念完整性。
陷阱： 尚未充分尝试提示上下文与工具重设计，就默认采用多智能体群体或模型再训练。
当智能体系统的任务完成表现不佳，或在复杂推理基准测试中反复失败时，系统团队往往急于部署复杂的多智能体架构，例如点对点群体、民主投票协议和分层辩论委员会，或采用涉及监督微调（SFT）和可验证奖励强化学习（RLVR）的昂贵模型适配方案。这两种方法都会消耗大量工程时间和资金，却往往无法解决根本的失效模式。
这种过早升级的失效机制在于，通过增加架构复杂性来弥补底层接口缺陷。多智能体群体会引入严重的分布式协同开销：在不受约束的拓扑中，\(N\) 个智能体之间的通信开销按 \(O(N^2)\) 增长，上下文窗口迅速被冗余的对话客套话填满，而幻觉则在未经验证的点对点交互中以乘法方式累积。同样，对上游模型进行微调会消耗大量 GPU 计算资源，将运行假设固化到静态权重中，形成一个僵化的检查点；随着外部 API 演变，其性能会下降，而运行时可见性问题依然完全没有得到解决。
对失败智能体轨迹的实证剖析表明，绝大多数运行错误并非源于模型固有的推理能力不足，而是源于模型与系统接口处的信息匮乏。智能体失败的主要原因包括：
- 提示上下文遗漏了关键环境状态，截断了必要的诊断日志，或以无关的观测历史污染了工作记忆。
- 工具定义在语义上含糊不清、缺乏正交性，或迫使模型推断本应由运行时处理的复杂参数依赖关系。
- 工具执行端点返回缺乏有效信息的错误消息（例如，返回通用的
Exit Code 1，而非具体的编译器错误诊断），导致模型无法形成有效的纠错假设。
架构层面的缓解措施是严格遵循系统干预阶梯。系统工程师必须全面评估并优化较低层级的干预措施，然后才能上升到复杂度更高的层级。首先，团队必须改进上下文内的状态管理，剪除过时的观测词元，并用权威的系统状态充实提示。其次，必须重新设计工具接口：将复合操作分解为正交的原子 RPC 端点，并提供明确的模式定义和信息丰富的结构化错误返回。第三，必须实现确定性的运行时防护机制，以拦截并修复可预测的执行错误。只有在能够证明这些开销低、可检查性强的系统机制已被穷尽之后，工程团队才应考虑模型微调、可验证奖励强化学习，或针对相互隔离的异构安全域采用多智能体委派。
在审视了导致生产部署不稳定的运维谬误和架构陷阱之后，我们已准备好将本卷完整的概念架构综合为一份一体化的运维台账。现在，我们将这些设计原则提炼为统一的结构性总结，将每个子系统与支配可靠智能体设计的基础工程不变量联系起来。
总结
系统工程与学习模型之间的永久边界由问责责任界定：无特权的神经模型 \(\pi_\theta\) 在离散词表上计算推测性的下一词元概率分布，而确定性的宿主运行时则支配状态转换、资源分配和物理副作用，将统计采样转化为可靠的计算。自主智能体既不是被赋予环境内隐行动权限的单体神经网络，也不是由脆弱的控制分支驱动的传统确定性程序。它是一个经过工程设计的反馈回路，通过受到严格中介控制的接口，将随机神经生成器与权威执行环境耦合起来。计算引擎在不具有任何环境内隐权限的条件下评估候选续写；内存层次结构在短暂存在的物理 KV 缓存帧、权威工作区产物和持久化预写事务日志之间对逻辑上下文进行虚拟化；执行框架依据形式化能力策略拦截、净化并评估工具调用；监督器通过确定性编译器和测试框架验证状态不变量；集群编排器则在异构执行域中分配、监控并隔离并发轨迹。这条流水线中的每一次转换都可追溯到明确的任务契约 \(\mathcal{C}\)，确保系统正确性建立在可观测、可审计的验收标准之上，而非模型无法验证的内部表征之上。
这种分工解决了智能体机器学习系统的核心架构困境。根据端到端论证，分布式系统低层的功能若缺少高层知识与验证，就无法完全满足应用需求。在智能体架构中，基础模型充当无特权、尽力而为的功能引擎，能够进行句法解析、语义转换和推测性规划。然而，它无法保证语义正确性、事务原子性或运行安全。试图仅通过模型对齐或提示工程来实现这些保证，等于将系统完整性委托给一个无法权威访问环境状态的组件，从而违反端到端原则。可信赖性必须在神经网络权重之外建立：依靠控制文件系统和网络操作的运行时引用监控器、隔离推测执行的沙箱，以及依据实证真值检查状态转换的机械化验证器。
要点回顾: 偶然复杂性缩减，本质不变量依然存在
- 候选计算与权威执行： 模型计算候选续接内容；运行时掌控随后发生的决策与效应。 模型不具有任何环境隐式权限。词元流中输出的工具调用和代码修改都是不具约束力的提案，在内存中托管，直到独立的宿主监督器验证其模式、检查安全策略，并将其派发到隔离的执行环境。
- 跨内存层次的状态分层： 逻辑上下文、物理 KV 状态和持久记录具有不同的所有者、生命周期和失效规则。 提示上下文窗口是当前工作状态的临时缓存，存在高度争用；GPU KV 缓存帧是由硬件管理的页面，受前缀共享和淘汰策略支配；持久工作区产物与仅追加的预写日志构成轨迹的权威事实依据。混淆这些层次会破坏可复现性、泄漏上下文，并耗尽内存带宽。
- 适度中介与可逆执行： 行动需要权限、可观测的结果，以及与权限和可逆性相称的恢复计划。 对外部系统执行的副作用必须根据其运行影响范围加以调节。只读探查所需的中介最少，但读取权限仍可能泄漏其触及的信息；而破坏性或不可逆的修改则需要显式能力令牌、人在回路中的审批，以及 Saga 补偿事务，以便在推测性轨迹遭遇不可恢复故障时保持系统一致性。
- 基于证据的系统干预升级： 应依据任务证据选择干预措施，并根据已认可的结果和总成本加以衡量。 系统工程师必须以实证为准绳，沿系统干预阶梯逐级推进，在承担监督微调、可验证奖励强化学习（RLVR）或多智能体委派带来的运行复杂性与资本成本之前，充分用尽提示优化、工具模式细化和确定性运行时防护手段。
- 契约透明与边界闭合： 完整的系统应明确其任务契约、限制和残余不确定性。 可信赖性要求阐明由五个部分组成的任务契约 \(\mathcal{C}\)，强制执行实际运行时间、轮次和词元数上限（\(T_{\max}\)、\(H_{\max}\)、\(M\)），并通过多层安全论证证明安全性；这些论证结合了机械验证器、使用留出数据的实证评估环境，以及持续的金丝雀遥测。
让所有子系统在同一条轨迹上运行，使三项原则更加清晰。由于在任何有限温度下进行采样，在任何时间跨度内都存在非零的违规概率，因此训练无法满足不变量闭合原则（不变闭包原则）；无论模型变得多么强大，闭合仍须依靠机械机制。Saga 注册阶段和前沿分析表明，枢轴边界（原则 14）处于一个渐变谱上：沙箱写入可逆，外部数字行动至多可补偿，而物理执行既不可逆，也不可补偿。Brooks 分析表明，只有在有人明确说明检查必须覆盖哪些内容之后，验证不对称性（原则 3）才能发挥效益，而作出这一说明仍是机器留给工程师的工作。
Systems Perspective 0.1: 架构师的责任：从 Wilkes 到软件 3.0
基础模型提供通过学习获得的计算能力——模式补全、归纳泛化和推测性综合——而外围计算机系统则提供状态选择、受控交互、监督、事务恢复，以及证明任务完成的实证证据。将这些职责视为一条统一且可问责的轨迹，是智能体机器学习系统的核心准则。
当我们跨越数字前沿、展望具身智能体的行动能力时，这一系统契约将迎来终极考验。在数字领域，沙箱中的执行可以暂停、设置检查点、进行快照隔离，并以微秒级粒度回滚。在物理世界中，执行发生在连续的动力学时间中，动力学作用力无法通过补偿性数据库事务撤销，而延迟则成为关乎安全的截止期限。本书确立的架构原则——无特权计算、分层内存、经中介控制的权限，以及确定性的端到端验证——构成了下一代具身物理自主系统必须依托的基础。