机器人 × Agent 技术教程：给机器人研究者

0. 导读：核心问题地图

这份教程把调研页里的工作组织成一套技术框架。调研页回答"有哪些工作"，教程回答"这些系统在解决什么问题、核心机制是什么、设计上该怎么取舍"。读者设定是机器人方向的研究者：熟悉控制、规划、强化学习和模仿学习，但没有系统接触过 LLM agent。

0.1 核心问题

第 12 章把这些串成一条从零搭建 agentic 机器人系统的路线。只想抓主线的话，读第 1、2、5、6、11 章。

0.2 约定

• 代码是说明性骨架，用来讲清结构；其中的模型调用、工具与机器人接口都是占位，示例数值为示意。
• 引用的结果都来自论文摘要或原文，已逐条核对；不同论文的基准、机器人与设置不同，数字不能横向比较。
• 记号：$s$ 为环境状态，$o$ 为观测，$h_k$ 为第 $k$ 个决策点的交互历史，$\omega$ 为选项（一个可调用的能力：技能、程序或 VLA 指令），$\mu$ 为 agent 在选项上的策略，$\pi_{\omega}$ 为选项内部的策略，$\beta_{\omega}$ 为选项的终止条件。

1. 问题设定：agent 是任务层的闭环控制器

1.1 从 ReAct 循环说起

LLM agent 的基本结构是一个循环（ReAct）：在第 $k$ 步，模型根据目前的历史产生一段推理，再输出一个结构化的动作——调用某个工具、执行一段程序——外部系统执行它，把结果作为新的观测返回，循环继续。围绕这个循环的软件（能调用哪些工具、看到什么、怎么检查结果、记住什么）统称为外壳（harness）。

放到机器人上，最关键的变化是：一次"动作"会在物理世界里持续一段时间。调用"把杯子放进水槽"这个能力，背后是一个技能或 VLA 跑上几秒到几十秒，期间机器人与环境持续交互，结束时可能成功、失败或超时。agent 不再是一个"一问一答"的程序，而是一个任务层的闭环控制器：它的动作是"启动哪个能力、带什么参数"，它的传感器是能力结束时返回的结果和图像，它的控制周期以秒计。

1.2 形式化：选项框架下的半马尔可夫决策

强化学习里的选项（option）恰好描述了这种结构。一个选项 $\omega = (I_{\omega}, \pi_{\omega}, \beta_{\omega})$ 包括：可以启动它的状态集合 $I_{\omega}$，它内部的策略 $\pi_{\omega}$（一个技能、一段程序或一个以语言指令为条件的 VLA），以及终止条件 $\beta_{\omega}(s) \in [0, 1]$。agent 是选项上的策略 $\mu(\omega \mid h_k)$，只在选项终止时做决策，所以整个系统是一个半马尔可夫决策过程：

其中 $\tau$ 是选项 $\omega$ 执行的步数（随机变量），$h'$ 是它终止时的交互历史。

Hi-VLA 的系统研究正是在这样一个"选项式控制框架"下统一了各种分层 VLA agent，再逐一比较设计选择。这个视角把一个 agentic 机器人系统拆成三件职责，本教程后面的章节基本按这三件事展开：

1. 选择：在当前状态下启动哪个选项——它可行吗（$I_{\omega}$）、有用吗、成功率多大？这是 grounding 问题（第 2 章）。
2. 执行：选项内部怎么实现——程序（第 3 章）还是 VLA（第 4 章）？两层之间用什么接口（第 5 章）？
3. 终止与判定：选项什么时候该结束、结束时成功了没有、失败的原因是什么——这是 $\beta_{\omega}$ 和成功判定，在物理世界里需要专门构造（第 5、6 章）。

1.3 时间尺度：agent 为什么只能待在选项层

Anthropic 的评测估计，直接实时控制机器人大约需要 83 Hz 的决策频率，而前沿模型的推理只有 0.2–0.4 Hz，差了两三个数量级（Claude plays robotics）。另一组数字更直观：让 GPT-6 Astra 直接控制 30 秒的步态，需要调用模型 250 次、每次约 40 秒（Galbot 的系统评测）。

因此 agent 只能在选项层做决策，选项内部的高频控制必须交给 VLA、学习策略或解析控制器。同一项 Anthropic 研究比较了 12 个模型、4 种接口（直接给力矩、写控制器、训练 RL、监督 VLA）：接口越高层，模型的提升越稳定；让模型直接控制力矩，在操作基准上几乎做不成任何事。

1.4 三个设计轴

几乎所有 agentic 机器人系统的差别，都可以归到三个设计轴上：

1. 接口的抽象层级——agent 的"动作"是什么。从低到高：直接给关节力矩、写控制器代码、调用参数化技能、给 VLA 下语言指令。抽象越高，模型越容易用好，但表达力越受限于预先提供的能力；抽象越低，表达力越强，但对模型的要求越高。CaP-X 在 12 个模型上发现了一致的趋势：人类设计的抽象越多，表现越好；抽象去掉得越多，表现越差（第 3 章会讲怎么用测试时的计算把差距补回来）。
2. 状态表示——agent 看到什么。原始图像信息全，但模型难以从中可靠地读出几何关系；结构化表示（场景图、物体列表）可检查、可推理，但依赖感知模块的质量（第 2、6 章）。
3. 结果验证——如何知道一个选项该结束了、成功了没有。软件里这是免费的：程序有返回值、测试有退出码。物理世界不提供这些，必须专门构造成功检测与终止判断（第 5、6 章）。

1.5 小结

• 机器人上的 agent 是任务层的闭环控制器：动作是带参数的能力调用，观测是调用结束时的结果，周期以秒计。
• 选项框架把系统拆成"选择、执行、终止与判定"三件职责，后面各章分别处理。
• 推理频率与控制频率差两三个数量级，agent 只能在选项层决策；接口抽象层级、状态表示、结果验证是三个主要设计轴。

1.6 自测

2. Grounding：让语言计划物理可行

2.1 问题：常识不等于可行

问 LLM "怎么清理洒在桌上的饮料"，它会给出一套合理的步骤，却不知道眼前这台机器人有没有抹布、够不够得着、手里是不是已经拿着东西。用第 1 章的语言说，LLM 知道哪些选项"有用"，但不知道它们在当前状态下是否可启动、能否成功。grounding 要解决三个子问题：

1. 可行性：当前状态下，哪些选项能成功执行？
2. 状态表示：把物理世界的哪些信息、以什么形式交给模型？
3. 不确定性：模型什么时候其实不知道该做什么，应该停下来问人？

2.2 有用 × 可行：SayCan 的分解

SayCan 把"选哪个技能"分解成两个因子的乘积。给定指令 $i$、目前已执行的步骤 $h$ 和当前状态 $s$，对技能库里每个技能 $\omega$（带一句语言描述 $\ell_{\omega}$）打分：

• 第一项是 LLM 给"下一步做 $\ell_{\omega}$"的概率（直接用 token 似然打分）——它衡量有用；
• 第二项来自技能自己的价值函数：从状态 $s$ 执行这个技能能成功的概率——它衡量可行。

选分数最高的技能执行，把它追加到 $h$，循环直到选出"完成"。两个设计值得注意。其一，LLM 只在一个封闭的技能集合上打分，而不是自由生成文本，从根本上排除了"幻觉出不存在的动作"。其二，可行性来自在机器人自己的数据上学到的价值函数，这就是"grounding"的字面含义：把语言知识绑定到这台机器人、这个状态上。代价是每个技能都需要一个可靠的价值函数，而且技能库决定了能力上限。

def saycan_step(llm, instruction, history, state, skills, value_fns):
    """SayCan 的一步决策：LLM 的有用性 × 价值函数的可行性。
    llm.loglik(prompt, text) 返回 text 在 prompt 之后的对数似然；value_fns[name](state) 返回成功概率。"""
    prompt = f"任务：{instruction}\n已完成：{'; '.join(history)}\n下一步："
    scores = {}
    for name, desc in skills.items():
        useful = math.exp(llm.loglik(prompt, desc))
        feasible = value_fns[name](state)
        scores[name] = useful * feasible
    return max(scores, key=scores.get)

2.3 闭环：把执行结果写回上下文

SayCan 只在选择时看一次状态，执行后不检查结果。Inner Monologue 把三类反馈作为文本写回 LLM 的上下文：成功检测（"抓取失败"）、场景描述（"桌上有一个红色的碗"）和人的反馈（"不是那个"）。LLM 由此在每一步之后重新规划：重试、换一种方法、或询问。实验显示，这种闭环的语言反馈显著提高了长时程指令的完成率。今天所有 harness 里的"观察 → 推理 → 行动"循环，都是这个思路的延续；第 6 章的"评估即退出码"则是把"成功检测"做成了一个标准化的接口。

2.4 结构化状态：场景图

原始图像信息完整，但模型难以从中可靠地读出物体之间的几何与语义关系，而且大场景放不进上下文。三维场景图把环境表示成节点（楼层、房间、物体、资产）与边（包含、相邻、在上面），是一种紧凑、可检查、可推理的状态表示。

• ConceptGraphs 构建开放词汇的三维场景图：用二维基础模型检测与描述物体，再经多视角关联融合到三维，不需要收集三维数据或微调模型。
• SayPlan 解决"场景太大放不进上下文"的问题：先把层级化的场景图折叠成很小的表示，让 LLM 做"语义搜索"——逐步展开与任务相关的子图；用经典路径规划器负责导航，缩短 LLM 需要规划的步数；再用一个场景图模拟器检查计划的可行性，把不可行的动作反馈给 LLM 迭代修正。它在跨 3 层楼、36 个房间、140 个物体的环境里完成了长时程任务规划。

结构化表示的代价是：它的正确性完全取决于感知模块。第 8 章会看到一个典型的失败——分割模型能找到"架子"，却分不出"最上层的架子"——这类关系理解上的错误，会让上层的规划永远无法成功。

2.5 知道自己不知道：用共形预测决定何时求助

LLM 的置信度往往是"自信地错"。指令有歧义时（"把碗放进微波炉"，而桌上有两个碗），正确的做法是停下来问人，但问得太多又失去了自主性。KnowNo 用共形预测给出了有统计保证的折中。

把每一步规划写成选择题：LLM 先生成若干候选的下一步，再用 token 似然给每个候选打分 $p(y \mid x)$。在一个带正确答案的校准集上计算非一致性分数 $\kappa_i = 1 - p(y_i^* \mid x_i)$，取分位数

部署时，若预测集合 $C(x)$ 只有一个选项，就直接执行；若有多个，就把这几个选项交给人选择。共形预测保证正确答案落在集合里的概率至少为 $1 - \varepsilon$（在校准数据与测试数据可交换的前提下）。KnowNo 把这一保证推广到多步规划，在满足给定任务完成率的同时，尽量减少求助次数，而且不需要微调模型。

import numpy as np

def calibrate(cal_scores, eps=0.15):
    """cal_scores：校准集中每个问题上，正确选项的 LLM 概率 p(y*|x)。返回阈值 q̂。"""
    kappa = 1.0 - np.asarray(cal_scores)
    n = len(kappa)
    level = min(1.0, np.ceil((n + 1) * (1 - eps)) / n)
    return float(np.quantile(kappa, level, method="higher"))

def act_or_ask(option_probs, q_hat):
    """option_probs：{候选下一步: p(y|x)}。集合大小为 1 就执行，否则请人从集合里选。"""
    pred_set = [y for y, p in option_probs.items() if p >= 1.0 - q_hat]
    if len(pred_set) == 1:
        return "execute", pred_set[0]
    return "ask_human", pred_set or list(option_probs)

2.6 小结

• grounding 的核心是给"有用"配上"可行"：SayCan 用在机器人数据上学到的价值函数衡量可行性，并把 LLM 限制在封闭技能集合上打分。
• 闭环的文本反馈（成功检测、场景描述、人的纠正）把一次性的计划变成任务层的反馈控制。
• 结构化场景表示让大场景可检索、可检查，但把正确性押在了感知模块上。
• 共形预测给"何时求助"提供了统计保证：预测集合多于一个选项时才问人。

2.7 自测

3. 代码即策略：程序作为动作空间

3.1 问题：agent 的"动作"应该是什么

第 2 章的 agent 在一个固定的技能集合上做选择，能力上限就是技能库。另一种思路是让模型直接写程序：程序调用感知 API（检测、分割、位姿估计）与控制 API（移动到、抓取、施力），用循环、条件和数值计算把它们组合起来——程序本身就是策略。它的好处来自"程序"这种表示：

• 精确：可以写出具体的坐标、速度、阈值，而不只是选一个离散技能；
• 可组合：循环、条件、函数调用，天然表达长时程与反应式行为；
• 可检查、可复用：写出来的东西能读、能测试、能存进技能库。

它面临三个核心问题，正是本章的三节：表达力从哪来（3.2–3.3）、API 抽象该多高（3.4）、运行时延迟怎么办（3.5）。

3.2 Code as Policies：程序的组合能力

Code as Policies 的做法是少样本提示：给模型几个"语言指令（写成注释）→ 策略代码"的示例，它就能为新指令重新组合 API 调用。几个关键机制：

• 分层代码生成：遇到尚未定义的函数，就递归地让模型再写这个函数。复杂行为因此被分解成小函数，每一个都更容易写对。
• 借助第三方库做几何推理：调用 NumPy、Shapely 计算距离、包围盒、排列，模型不必"心算"空间关系。
• 行为常识：把"快一点"这种模糊描述映射成具体的速度数值。
• 两类策略：既能写反应式策略（例如阻抗控制器），也能写基于路点的策略（基于视觉的抓放、轨迹控制）。

# 指令：把所有方块按颜色排成一列，间隔 5 厘米，从桌子左边开始。
# ——以下是 LLM 生成的策略代码（示意），只用到提供的感知与控制 API。
blocks = detect_objects("block")                      # 感知 API：返回 [(name, xyz, color)]
by_color = sorted(blocks, key=lambda b: b.color)
x0, y0 = table_bounds().left + 0.05, table_bounds().center_y
for i, b in enumerate(by_color):
    target = (x0 + 0.05 * i, y0, b.xyz[2])
    pick_and_place(b.name, target)                    # 控制 API：未定义时递归生成其实现

3.3 写"目标"而不是写"动作"：价值图与关键点约束

直接写动作序列，要求模型把几何与运动学也算对，这恰恰是它的弱项。另一种分工是：模型只写"要满足什么"，数值优化器负责"怎么满足"。

VoxPoser：组合三维价值图。 VoxPoser 让 LLM 写代码调用 VLM，在观测空间里组合出三维的价值图——例如"抓手柄"产生一个吸引区域，"别碰花瓶"产生一个排斥区域——再交给基于模型的规划器，零样本地合成稠密的 6 自由度末端轨迹。规划是闭环的，对扰动有鲁棒性；对接触丰富的场景，还能从在线经验中学一个动力学模型。

ReKep：关系关键点约束。 ReKep 把约束写成 Python 函数：输入环境中一组三维关键点（例如杯柄、壶嘴、目标位置），输出一个数值代价。一个任务被表示成按阶段排列的约束序列，每个阶段包括"阶段结束时要满足的子目标约束"和"阶段过程中要一直满足的路径约束"：

其中 $e_{1:T}$ 是末端位姿序列，$k(\cdot)$ 表示关键点随末端位姿的位置（被抓住的物体上的关键点会随手一起动）。求解器以分层方式实时优化 $\mathrm{SE}(3)$ 中的末端位姿，形成感知-动作闭环；约束函数本身由视觉基础模型与 VLM 从自然语言和 RGB-D 观测自动生成，不需要任务专门的数据或环境模型。

3.4 抽象该多高：脚手架与测试时计算

代码即策略的表现，强烈依赖提供给模型的 API 有多"高级"。CaP-X 系统地研究了这个问题：它的 CaP-Bench 在不同的抽象层级、交互方式与感知设置下评测了 12 个模型，发现一致的趋势——人类设计的抽象越多，表现越好；去掉这些先验，表现随之下降，暴露出对设计者脚手架的依赖。同时，这个差距可以靠增加 agent 在测试时的计算来弥补：多轮交互、结构化的执行反馈、视觉差分（比较动作前后的图像）、自动技能合成与集成推理，即使 agent 只能用低层原语，也能显著提高鲁棒性。在此基础上，CaP-RL 用可验证的奖励做强化学习，提升成功率并能以很小的差距迁移到真机。

OpenRUA 走到了另一个极端："零抽象"——只给 Claude Code（Claude Opus 5）一个 ROS 2 终端和文档，不提供任何定制的原语或工作流，感知变成文件读写，操作变成写代码。结果是 CaP-Bench 上 99.0%、LIBERO-PRO 上 87.0%；在 96.8% 的回合里，agent 自发地写程序处理原始传感器数据、算出度量尺度的测量值。

两者并不矛盾：OpenRUA 用的是最强的编码 agent，并且把机器人成熟的原生软件栈（ROS 2）当成了抽象层；CaP-X 说明，模型较弱、或接口不够成熟时，人设计的抽象仍然必要。合适的抽象层级取决于模型的能力，而成熟的原生接口可以替代很多定制 API。

3.5 延迟：把写代码移到训练期

运行时多轮生成、执行、修改代码，延迟对实时控制来说太高。一个有效的解法是把代码生成从部署期挪到训练期：

• RHO：训练期让带工具的编码 agent 搜索可解释的、多文件的策略仓库（"仓库即策略"），用环境奖励与执行结果做反思反馈，不需要遥操作示范；部署时单轮执行，不再改代码。在扰动过的抓放基准 LIBERO-PRO 上达到 45.0%，而 π0.5 平均 12.83%、OpenVLA 为 0%。
• RACaP：进化阶段写代码，把可复用的物理机制沉淀成类型化的 Policy API；部署时只用 ReAct 循环调用这些冻结的 API，靠工作记忆、长期经验记忆与视觉反馈选择动作、验证结果、从失败中恢复，不改源代码。再用拒绝采样微调，把大模型的 ReAct 决策蒸馏到一个 8B 的视觉语言模型，单次决策提速 13.2 倍，重复的物理调用从 16 次降到 4 次。

原则是：把可复用的机制（代码）与运行时的决策（选择与参数）分开——前者离线进化、充分验证，后者轻量、快速。

3.6 小结

• 程序作为动作空间带来精确性、可组合性与可检查性；分层代码生成与第三方库让模型能处理复杂的几何与逻辑。
• 让模型写目标与约束、让优化器求数值，是比"让模型直接输出动作"更稳健的分工。
• 抽象层级是核心取舍：弱模型需要脚手架，测试时计算可以部分替代脚手架，强模型配合成熟的原生接口可以零抽象。
• 运行时写代码太慢，就把代码生成移到训练期，部署时只做轻量的选择与参数化。

3.7 自测

4. VLA：执行器的结构与实时执行

4.1 问题：把视觉语言模型变成控制器

视觉-语言-动作模型（VLA）是选项内部最常用的执行器：输入图像与语言指令，输出机器人动作。它想继承视觉语言模型在网络数据上学到的语义知识，但要跨过三道坎：

1. 输出形式不匹配：语言模型输出离散 token，机器人需要高频、连续、多维的动作；
2. 动作分布多峰且高频：灵巧、双臂任务的动作维度高、频率高，同一情形下可以有多种合理动作；
3. 推理慢于控制：大模型一次前向要几十到几百毫秒，控制却要求每几毫秒到几十毫秒一个动作。

4.2 动作的表示：离散 token、压缩 token 与流匹配

按维度、按时间步分箱（RT-2）。 RT-2 把每个动作维度量化成若干个箱，用文本 token 表示，和视觉问答等网络数据一起协同微调视觉语言模型——动作被当作"另一种语言"。这第一次说明了网络规模的预训练能迁移到控制：对新物体、训练数据里没有的指令有明显更好的泛化。

压缩后的 token（FAST）。 逐维逐步分箱在高频的灵巧数据上表现很差：相邻时间步的动作高度相关，每个 token 几乎不带新信息，自回归模型学到的主要是"复制上一个 token"。FAST 借鉴图像压缩，先对动作块的每一维做离散余弦变换，再量化和压缩：

平滑的动作轨迹能量集中在低频系数上，量化后大部分高频系数为零，再经字节对编码压缩，得到短而信息密集的 token 序列。这让自回归 VLA 能够学会原本"完全学不会"的高频灵巧任务；与 π0 结合后可以扩展到 1 万小时的机器人数据，性能与扩散式 VLA 相当，训练时间最多缩短 5 倍。基于 100 万条真实轨迹训练的通用版本 FAST+ 可以直接当黑盒 tokenizer 使用。

import numpy as np
from scipy.fft import dct

def fast_like_tokens(chunk, gamma=10.0):
    """FAST 式动作压缩的前半部分（示意）：逐维 DCT → 缩放取整 → 按低频优先展平。
    chunk: (H, D) 动作块。之后再用 BPE 把整数序列压成 token（此处省略）。"""
    coeffs = dct(chunk, axis=0, norm="ortho")          # 每一维沿时间做 DCT
    q = np.round(gamma * coeffs).astype(int)            # 量化：高频系数大多变成 0
    return q.T.reshape(-1)                              # 先维度后频率展平（示意）

连续动作专家 + 流匹配（π0）。 π0 不把动作离散化，而是在预训练视觉语言模型之上接一个动作专家，用流匹配直接生成连续的动作块：从噪声 $A_0$ 出发，沿学到的速度场 $v_{\theta}(A_s, s, o)$ 积分几步得到动作，训练目标是 $\mathbb{E}\lVert v_{\theta}(A_s, s, o) - (A_1 - A_0)\rVert^{2}$，其中 $A_s = (1-s)A_0 + s A_1$。连续生成天然适合高频、多峰的动作分布，VLM 部分负责语义与视觉理解。

4.3 泛化来自哪里：协同训练与更丰富的条件

协同训练。 π0.5 的结论是，跨场景泛化主要来自异构数据的协同训练：多种机器人的数据、高层语义（子任务文本）预测、网络数据、物体检测等，组合成"混合多模态"的训练样本；同一个模型先解码出子任务文本，再生成动作。它首次展示了端到端学习的系统在完全陌生的家庭里完成长时程、灵巧的任务（打扫厨房和卧室）。

更丰富的条件 = 更多可用的数据 + 更强的可操控性。 π0.7 在训练时不仅以语言指令为条件，还以描述"用什么方式做"的多模态信息为条件——任务表现的元数据、子目标图像等。这样，次优的自主数据、失败数据、非机器人来源的数据都能用上（只要在条件里标注它们是什么），部署时又可以通过上下文精确地"操控"模型采用哪种策略。Gemini Robotics 1.5 则让 VLA 在动作之间穿插多层次的自然语言推理（"先思考再行动"），并用"运动迁移"机制从多种机器人的异构数据中学习。

4.4 实时执行：动作块与推理延迟

VLA 一次预测未来 $H$ 步的动作块，执行其中前 $h$ 步再预测下一块。推理需要 $d$ 个控制步的时间时，有两种朴素做法，都不好：

• 同步执行：等推理完再动——机器人周期性地停顿；
• 朴素异步：一边执行一边推理，新块到了就切换——新块是从"推理开始时"的观测算出来的，与此刻已经执行到的动作不连续，在块边界产生跳变，常常把系统带出训练分布。

实时分块（RTC）的做法是：在执行当前块的同时生成下一块；推理期间必然会被执行的那 $d$ 个动作，在新块里直接冻结为当前块对应的动作；其余部分在生成时补全（inpainting），使之与冻结的部分平滑衔接。它在推理阶段实现，适用于任何扩散或流匹配 VLA，不需要重新训练；在延迟明显的情况下，仍能完成点火柴这类精细任务。

def rtc_next_chunk(policy, obs, current_chunk, start, delay):
    """RTC 的核心一步（示意）：在执行 current_chunk 的同时于后台调用。
    start：发起推理时 current_chunk 已执行到的位置；delay：推理需要的控制步数。
    推理期间注定会被执行的动作 current_chunk[start:start+delay] 作为新块的前缀冻结，
    模型在去噪时只补全其余部分，使新块与已执行的轨迹平滑衔接。"""
    frozen = current_chunk[start:start + delay]
    new_chunk = policy.sample(obs, frozen_prefix=frozen)   # 前缀固定的引导式去噪
    return new_chunk[delay:]                               # 推理结束的那一刻，从这里接着执行

4.5 当 VLA 成为 agent 的工具

当一个 agent 来调用 VLA 时，VLA 的设计目标多了两个：可操控——精确地执行 agent 给出的子指令，而不是自顾自地做"最常见的事"；可终止——知道什么时候完成、能汇报进度。VLAs-as-Tools 把这两点做进了接口与训练：一族专门化的 VLA 工具，每个只执行一个有界的子任务，接口显式地暴露工具选择和执行中的进度反馈，agent 因此可以由事件触发重新规划，而不必持续轮询；再用"与调用对齐的后训练"提高 VLA 对调用的遵循度。在五个仿真基准上，它让 π0.5 的成功率平均提高 8.9 个百分点。π0.7 的"可操控"、第 5 章的终止规则，都是同一方向。

4.6 小结

• 动作表示是 VLA 的核心设计：逐维分箱简单但学不好高频动作；压缩 token 保留自回归框架；流匹配动作专家天然处理连续、多峰、高频。
• 泛化主要来自异构数据的协同训练；条件信息越丰富，能用的数据越多，模型也越可操控。
• 推理延迟不可避免，动作块的异步执行需要处理块边界的连续性：冻结必然执行的部分、补全其余部分。
• 作为 agent 的工具，VLA 需要可操控、可终止、能汇报进度。

4.7 自测

5. 分层接口：层与层之间传什么、多快、何时交接

5.1 问题：分层系统的四个接口问题

几乎所有实用系统都是分层的：上层的 VLM 或 agent 负责理解与规划（"System 2"），中层的 VLA 或学习策略负责视觉运动控制（"System 1"），底层的解析或学习控制器负责高频的平衡与跟踪（"System 0"）。分层本身不新鲜，难的是接口。每一对相邻的层之间都要回答四个问题：

1. 向下传什么：语言子目标、潜变量、路径、子目标图像，还是离散化的动作？
2. 多快：上下层的频率差一个到两个数量级，怎么衔接？
3. 何时交接：下层什么时候算完成、什么时候该把控制权交还给上层？
4. 向上报什么：成功、失败、进度、异常，以什么形式？

5.2 向下传什么：接口类型的取舍

两个实证结论帮助取舍。VLA-OS 在统一的架构上做了受控比较：以视觉为依据的规划表示通常优于语言规划表示，分层范式在任务表现、泛化与扩展性上通常不差于或优于其他范式——几何意图用几何表达，低层策略更"听话"。HAMSTER 的二维路径接口让高层 VLM 可以跨越很大的领域差距（本体、动力学、外观、任务语义都不同）迁移：真机上沿七个泛化维度平均比 OpenVLA 高 20 个百分点。

一般规律是：接口越接近下层的"原生语言"，下层越容易执行；越接近人类可读的语言，越容易检查和与 agent 对接。潜变量表达力最强，但一旦出问题几乎无从诊断；agent 驱动的系统通常偏向语言、路径或原语这类可检查的接口。

5.3 多快：频率栈与控制权

频率差决定了上层只能以"目标"或"条件"的形式影响下层，而不能逐步干预。于是一个实际问题是：谁有权打断谁。Critic in the Loop 在大脑（VLM）和小脑（VLA）之外加了一个轻量的视觉"评审"：常规子任务由 VLA 快速闭环执行；评审检测到停滞或失败等异常时，才触发昂贵的 VLM 重新规划；再配以人为规定的规则打破无限重试。这样既减少了 VLM 调用，又提高了分布外场景下的鲁棒性。

5.4 何时交接：终止规则与"链式状态"问题

Hi-VLA 的系统研究把分层 VLA agent 统一到选项式控制框架下比较设计选择，结论之一是：终止规则与 VLA 的可操控性、规划器的大小同样重要。常见的终止方式有：固定时间预算、学到的成功检测器、由 VLM 看图判断、以及由下层主动汇报进度（第 4.5 节的 VLAs-as-Tools）。终止太早，子任务没做完；太晚，下层可能已经把事情做坏，或者在原地无效地重复。

更隐蔽的问题出现在组合时。一项诊断研究把同一批 VLA 技能放在两种初始状态分布下评测：从干净的"技能边界快照"出发时，导航、抓取、放置、开门等技能的成功率在 77–100%；但把技能串起来、让每个技能从上一个技能结束的状态出发时，组合起来的任务仍然频繁卡住。失败被归因于三类：下一个技能的"就绪性"（起始状态不在它的能力范围内）、目标的指代与定位、以及控制执行。

用选项的语言说：技能 $\omega_j$ 训练时的起始分布（干净的示范起点），与它在组合中实际遇到的起始分布（$\omega_{j-1}$ 的终止状态分布）不同——这是选项之间的协变量偏移，与第 3 章 DAgger 讨论的误差累积是同一类问题。对策也类似：

1. 在链式状态上收集数据、训练技能（让 $\omega_j$ 见过 $\omega_{j-1}$ 留下的"烂摊子"）；
2. 启动前检查前置条件（$I_{\omega}$），不满足就先做一个"整理"动作或换一个技能；
3. 结束后检查后置条件，确认交给下一个技能的状态是合格的。

def run_option(agent, option, robot, budget_s, detector):
    """执行一个选项并产生"退出码"（示意）：前置检查 → 执行 → 终止判断 → 后置检查。"""
    if not option.precondition(robot.observe()):
        return {"code": "NOT_READY", "obs": robot.snapshot()}       # 交回上层：先整理或换技能
    handle = option.start(robot)
    t0 = robot.clock()
    while robot.clock() - t0 < budget_s:
        status = detector(robot.observe(), option.goal)              # 成功检测器 / 进度信号
        if status in ("SUCCESS", "FAILED", "STALLED"):
            break
    else:
        status = "TIMEOUT"
    handle.stop()
    if status == "SUCCESS" and not option.postcondition(robot.observe()):
        status = "POST_FAIL"                                         # 看似成功，但交接状态不合格
    return {"code": status, "obs": robot.snapshot()}

5.5 有多个执行器时：路由

同一个子任务常常有多个可用的执行器（不同的 VLA、专用策略、解析技能），没有一个在所有情况下都最好。RoboRouter 不做训练，而是为任务构建语义表示、检索相似任务的历史执行记录，预测哪个策略最合适，并用结构化的反馈修正后续的路由；接入一个新策略只需一次轻量评估。与单独使用各个策略相比，它让平均成功率在仿真中提高 3 个百分点以上、在真机上提高 13 个百分点以上。

5.6 小结

• 分层的难点在接口：传什么、多快、何时交接、报什么。
• 接口越接近下层的原生表示越好执行，越接近人类语言越好检查；以视觉为依据的计划通常优于纯语言计划。
• 频率差决定了上层只能以目标或条件影响下层；需要明确的机制（如轻量评审）来决定何时把控制权交还上层。
• 终止规则与 VLA 的可操控性同样关键；技能组合的主要隐患是"链式状态"带来的协变量偏移，需要在链式状态上训练并检查前后置条件。

5.7 自测

6. Harness 工程：外壳决定上限

6.1 问题：为什么同一个模型，换个外壳就差几十个点

编码 agent 的经验是：agent 能做到什么，不只取决于模型，还取决于包在模型外面的软件——它能看到什么、能调用什么、怎么检查结果、怎么积累经验。机器人上这一点同样成立，而且更明显：

• Physical Agency 不收集新数据、不做后训练，只用一个闭环的"物理 agent 编排器"调度现有的 VLA 与参数化技能（规划、分解子目标、下达指令、从低层观测跟踪与验证结果、失败后恢复），就把 LIBERO-PRO 上的最好成绩从 12.8% 提到 53.3%；
• ROSClaw 在同一套执行层上比较不同模型，提出越界动作的比率最多相差 4.8 倍；它与另一框架的对照实验也表明，执行层的设计本身——而不仅是提示词——显著影响结果。

为什么外壳在机器人上这么重要？Thea 给出了一个清楚的解释：软件世界免费提供两种能力，物理世界都不提供——读取世界的状态（软件里读文件、查变量即可），以及判定一个动作的结果（软件里有返回值和退出码）。harness 的主要工作，就是把这两种能力造出来。按 Towards Agentic Robots 的划分，harness 的功能包括编排、记忆、监控与恢复、技能、基础设施与分层（第 5 章）。本章按"读状态 → 判结果 → 积累技能 → 接口与基础设施"的顺序讲。

6.2 读取状态：场景图即上下文，记忆要先验证再使用

Thea 的做法是场景图即上下文：维护一个持久的、符号化的世界表示（物体、位置、关系、状态），作为 agent 每一步的上下文，而不是每次都让模型从原始图像里重新理解世界。

长时程任务还需要记忆：把交互中得到的知识留下来。两个设计要点：

1. 记忆要锚定在空间里的物体上，并记录交互结果。 MessyMem 维护一个空间锚定的三维场景图，在物体条目上附加通过交互学到的属性与结果（"这个抽屉是锁着的""这个杯子上次没抓住"），并链接视觉关键帧以便细粒度回忆。在连续 3 小时以上、25 个任务的仿真中，它的任务进度达到 80.0%，比最强的消融高 14.8 个百分点、比最强的外部基线高 28.9 个百分点，并能从数千个关键帧、一个多小时之前的记录里检索到相关证据。
2. 先验证，再使用。 物理条件会变（另一个人可能已经把抽屉打开了），直接照搬过去的经验很危险。PhysMem 先把经验抽象成假设，用针对性的交互在新观测上检验，通过之后才把它提升为指导后续决策的知识。在一个受控的砖块插入任务上，这种"有原则的抽象"成功率 76%，直接检索经验只有 23%。

记忆的维护还需要增、改、删操作（HiMe）——过时的记忆比没有记忆更有害。

6.3 判定结果：评估即退出码，监控与恢复

Thea 的第二个设计是评估即退出码：每个能力调用结束时，由专门的评估模块判断三件事——该不该终止、是否成功、失败的话原因是什么——并以结构化的形式返回给 agent，就像程序的退出码。这把第 1 章的"终止与判定"职责标准化成了接口。

监控可以发生在执行之前、之中和之后：

• 执行中：DoReMi 让 LLM 在规划时同时为下一个技能写出"执行期间应保持的约束"，再由 VLM 持续检查；一旦约束被违反，立刻停下并重新规划，而不是等技能跑完才发现。
• 执行后：REFLECT 把机器人的经历按传感器、事件、子目标三个层次汇总成文本，用来解释失败原因并生成纠正计划。
• 恢复的层次：LIBERO-RECOVER 把失败恢复分成四级——重试动作、调整动作、恢复物体状态、恢复环境——并指出现有模型的基准成功率与真实可靠性之间的差距，很大程度上就在恢复能力上。

6.4 技能：能力如何进入、演化与退出

技能库是 harness 的长期资产。一个技能从产生到被信任，应当有清楚的生命周期：写出 → 测试 → 凭证据晋升 → 使用中持续计分 → 失效时降级或退役。

• 从纠正中学：DROC 能响应任意形式的语言纠正（无论针对高层计划还是低层原语），从一系列纠正中蒸馏出可泛化的知识存进知识库，再按文本与视觉相似度检索到新任务中——同样的纠正不必说第二次；首轮只需要直接写代码方法一半的纠正次数。
• 从视频中补全：Uni-Skill 从大规模无结构的机器人视频构建分层的技能目录，规划器需要某个技能而技能库里没有时，从目录中检索示例作为语义监督与轨迹参考，少样本地推断出新技能。
• 从验证过的修复中沉淀：ASPIRE 把通过验证的修复沉淀成可复用的技能（第 8 章）。

第 8 章会看到，技能库最大的风险是"没有证据就晋升"——一个在某次测试中碰巧通过的技能，会在之后的所有任务里制造问题。

6.5 工具与基础设施：接口标准化

• 把机器人接到 agent 上：ROS MCP Server 只需在机器人端启动 rosbridge，Claude Code、Codex、Gemini CLI 等 MCP 客户端就能发现并调用 ROS 的 topic、service 与 action；RoboNeuron 直接从 ROS 的消息模式自动生成 agent 可调用的工具。
• 把执行层做成与模型无关的：ROSClaw 提供能力的动态发现、多模态观测的标准化、执行前在可配置安全包络内的动作校验、以及结构化的审计日志；更换模型后端或机器人平台只是改一份配置。
• 一次只调用一个工具：ETA 的循环是"规划器每次只选一个工具调用 → 接口控制执行 → 世界返回结果与新观测"，便于验证每一步、调整计划，并把成功与失败的交互都变成可复用的经验；作为 Codex 的插件时，它只暴露 observe、mark_point、move_to 三个工具。
• 语义化的离散动作：Show-Harness 暴露一组紧凑的、模型容易推理的离散语义动作单元，再由与本体相关的解释器确定性地把它们落实为具体动作——闭源前沿模型可以零样本控制机器人，小的开源模型只需几个 GPU 小时的微调。

工具化也有边界。Embodied Tool Protocol 整理了 100 多个经过验证的具身工具：把能力外化为工具，在 EB-ALFRED 和 EB-Navigation 上平均分别提升 31% 和 36%；但提升主要来自认知与感知类工具，执行类工具的增益有限；而且"何时调用、调用哪个、怎么调用"对所有模型仍然是难题。

6.6 一个最小的 harness

def harness_loop(model, tools, scene_graph, memory, gate, task, max_steps=50):
    """最小 harness（示意）：场景图作上下文 → 模型一次选一个工具 → 执行前安全校验 →
    执行并得到退出码 → 更新场景图与（验证后的）记忆。tools[name] 返回 {"code", "obs"}。"""
    history = []
    for _ in range(max_steps):
        context = {"task": task, "scene": scene_graph.summary(),
                   "memory": memory.retrieve(task, scene_graph), "history": history[-10:]}
        call = model.choose_tool(context, tool_specs=[t.spec for t in tools.values()])
        if call.name == "finish":
            return call.args
        ok, reason = gate.check(call, scene_graph)          # 执行前的安全与可行性校验（第 11 章）
        if not ok:
            history.append({"call": call, "code": "REJECTED", "reason": reason})
            continue
        result = tools[call.name](**call.args)               # 内部：前置检查 → 执行 → 终止判定 → 后置检查
        scene_graph.update(result["obs"])
        history.append({"call": call, "code": result["code"]})
        if result["code"] != "SUCCESS":
            memory.propose(call, result)                     # 先作为"待验证的假设"记录，验证后才晋升
    return {"status": "BUDGET_EXHAUSTED", "history": history}

6.7 小结

• harness 能把同一个模型的表现拉开几十个百分点；它的核心任务是造出物理世界不提供的两种能力：读取状态与判定结果。
• 状态用场景图这类持久、结构化的表示；记忆要锚定在物体上，并且先验证再使用。
• 结果判定要标准化为"退出码"，监控要覆盖执行前、中、后；恢复能力往往是基准成功率与真实可靠性之间的差距所在。
• 技能库需要证据驱动的生命周期；接口与执行层应当与模型无关，安全校验放在执行之前。

6.8 自测

7. 外环：用大模型生成奖励、任务、场景与数据

7.1 问题：生成很便宜，验证很贵

前几章的 agent 在线上（任务执行时）工作。另一类用法在线下：让大模型生成训练所需的东西——奖励函数、课程、仿真任务、场景、示范数据——再用它们训练策略。设生成物为 $G$，用它训练出的策略为 $A(G)$，任务适应度为 $F$，外环要解

这里的核心矛盾很清楚：生成一个候选只要几秒，验证它却要一次训练或一次仿真评估；而一个有缺陷的生成物（奖励有漏洞、场景物理不合理、示范不可行）会被下游悄无声息地吸收，直到真机上才暴露。所以这一章的主线不是"怎么生成"，而是"怎么在生成与使用之间放上可靠的校验"。

7.2 奖励：语言与控制之间的中间接口

低层动作依赖具体硬件，在大模型的训练语料里很少；奖励函数却语义丰富、又能被优化器直接优化，是语言与控制之间天然的中间层。

• 奖励参数 + 实时优化器。 Language to Rewards 让 LLM 把指令或纠正翻译成奖励的参数，交给 MuJoCo MPC 实时优化出行为，用户能立刻看到结果、再用语言修改——形成交互式的行为创作。
• 奖励代码 + 进化搜索。 Eureka 以环境源代码为上下文生成奖励代码，每轮采样多个候选、并行训练，再把各奖励分量在训练中的曲线写成文字反馈（"奖励反思"），让 LLM 有针对性地改进（算法细节见灵巧手教程第 11 章）。
• 奖励 + 域随机化。 DrEureka 只需要目标任务的物理仿真，就同时构造奖励函数与域随机化分布，用于 sim2real；在四足运动与灵巧操作上达到与人工设计相当的水平，还解决了四足在瑜伽球上平衡行走这样的新任务。
• 课程。 CurricuLLM 先用自然语言生成一串有助于目标任务的子任务，再把每个子任务翻译成可执行的任务代码（奖励与目标分布），评估后迭代。

7.3 任务、场景与数据：生成式仿真

这些系统的结果都依赖校验：SceneSmith 生成的物体比之前的方法多 3–6 倍，同时物体间碰撞少于 2%、96% 的物体在物理仿真中保持稳定；ARSTAG 生成的示范让 π0.5 在双臂真机上 7 个任务的平均成功率达到 74.6%，消融显示与任务一致的随机化显著提升了鲁棒性，且策略性能随生成数据量增加而提升；Gemini 4 Argon 从视频或草图生成 MuJoCo 孪生，用其仿真数据把真机成功率从 56% 提到 75%。

7.4 编排真实数据采集

生成也可以发生在真实世界：AutoRT 用 VLM 理解场景、用 LLM 为一支机器人舰队提出多样而新颖的指令，在多栋楼里让 20 多台机器人采集了 7.7 万条真实回合（遥操作与自主策略都有）。它的关键设计是让基础模型同时推理自主程度的取舍（这条指令该交给自主策略还是人来遥操作）与安全——一套写成自然语言的"机器人宪法"规则在提出指令时过滤不安全或不合适的任务。

7.5 共同原则：每个生成物都要过关卡

def generate_and_gate(generator, gates, consume, n_candidates=16, rounds=5):
    """生成-校验-使用的通用骨架（示意）：只有通过全部关卡的生成物才进入下游。
    gates：按代价从低到高排列的检查函数，每个返回 (passed, feedback)。"""
    accepted, feedback = [], ""
    for _ in range(rounds):
        for cand in generator.sample(n=n_candidates, feedback=feedback):
            for gate in gates:                         # 便宜的检查放前面，昂贵的放后面
                passed, info = gate(cand)
                if not passed:
                    feedback += f"\n[{gate.__name__}] {info}"
                    break
            else:
                accepted.append(cand)
        if accepted:
            return consume(accepted)                    # 例如：用通过校验的数据训练策略
    return None

关卡要按代价从低到高排列：能不能运行（毫秒级）→ 物理是否合理（秒级）→ 训练后任务是否达成（小时级）→ 真机（天级）。便宜的关卡尽早拦下大部分坏候选，昂贵的关卡只留给少数候选。

7.6 小结

• 外环生成的核心矛盾是"生成便宜、验证昂贵"；缺陷会被下游悄无声息地吸收。
• 奖励是语言与控制之间天然的中间接口，可以配合实时优化器（交互）或进化搜索（离线）使用，并能扩展到域随机化与课程。
• 生成式仿真覆盖任务、场景、示范和整套 RL 工程；它们的效果都取决于校验。
• 每个生成物都要按代价从低到高过一串关卡，再进入下游。

7.7 自测

8. 编码 agent 自动化研发与自我改进

8.1 问题：软件里的自我改进循环，为什么不能直接搬到机器人上

编码 agent 在软件上已经能形成"写代码 → 运行测试 → 读报错 → 修改"的自我改进循环。这个循环之所以可靠，靠的是软件世界的三个性质：执行便宜且可重复（随时可以重跑）、判定可靠（测试要么过要么不过）、状态可回滚（版本控制）。机器人研发恰好三样都缺：

1. 每次物理试验都要复位场景，代价高、还会引入新的随机性；
2. 成功与否需要感知来判定，判定本身会出错；
3. 训练出的策略、数据管线、采集流程这些"工具"本身就经常失败，而且失败是静默的。

所以这一章的核心问题是：怎么让一个以物理试验为评估的外环，像软件循环一样可重复、可信、可累积。

8.2 可重复的物理反馈回路

ENPIRE 的出发点是一个判断：自动化机器人研究缺的不是更强的模型，而是一个可重复的真实世界策略改进回路——复位场景、执行策略、验证结果、改进下一轮。它把这个回路做成编码 agent 可用的 harness，包括四个模块：

这个闭环把真实世界的操作学习变成一个可控的优化过程，既减少了人的参与，又能对训练配方与 agent 变体做公平的消融。在它的支持下，前沿编码 agent 能自主地把策略训练到 99% 的成功率——任务包括整理插针盒、系扎带、使用工具——派出 agent 团队、使用多台机器人时还会更快。

8.3 证据门控：别让"碰巧通过"进入系统

外环里最危险的事是错误晋升：一个候选在几次评估中碰巧表现好，被当作改进采纳，之后所有工作都建立在它上面。AgenticRobotics 把编码 agent 的"主 agent + 子 agent + 工具"架构移植到"训练—评估—改进"循环上，并针对"机器人工具经常失败"这一点做了一系列控制平面的设计：

• 不可变的目标：评估目标在循环开始时固定，agent 无权修改；
• 由控制器而非 agent 负责测量：agent 提出候选，测量由独立的控制器完成并记录；
• 按提交记录的崩溃恢复：任何时刻中断，状态都可以从记录中恢复，不丢失、不重复；
• 按证据分级的技能库：每个工具与技能的质量来自调用记录，背后的产物一变，旧的质量评估即失效；
• 签名的校验器：防止产物被篡改。

它报告的效果正是"门控"本身的价值：每次运行的错误晋升率从未加固时的 0.005–0.021 降到 0.001；在"随时可以停止评估"的情况下，决策仍然统计有效；在强制杀进程的注入测试下没有丢失或重复的副作用；六类产物篡改全部被检出。作者也坦率说明：这些机制让操作者可以离开，而不是让循环比人挑出更好的检查点——在他们测量的那条实验线上，它并没有。

随时有效的比较。 评估真机策略时，人们常常"看着结果决定要不要再测几次"——这种可选停止会让普通的置信区间失效。一个简单的修正是使用对所有时刻同时成立的置信界：对第 $t$ 次试验后的经验成功率 $\hat{p}_t$，取 $\alpha_t = \alpha / (t(t+1))$（它们的和等于 $\alpha$），由 Hoeffding 不等式加并集界，

于是无论何时停止，"候选的下界高于现任的上界"这一判断的错误率都不超过 $\alpha$。这只是最朴素的构造，更紧的方法（基于下注的 $e$ 过程、置信序列）思路相同。

import math

def anytime_bound(successes, trials, alpha=0.05):
    """对所有时刻同时成立的成功率置信区间（Hoeffding + 并集界，α_t = α/(t(t+1))）。"""
    t = max(trials, 1)
    a_t = alpha / (t * (t + 1))
    r = math.sqrt(math.log(2 / a_t) / (2 * t))
    p = successes / t
    return max(0.0, p - r), min(1.0, p + r)

def should_promote(cand, incumbent, alpha=0.05):
    """只有当候选的下界高于现任的上界时才晋升；评估可以在任何时刻停止。"""
    lo_c, _ = anytime_bound(*cand, alpha=alpha / 2)
    _, hi_i = anytime_bound(*incumbent, alpha=alpha / 2)
    return lo_c > hi_i

8.4 改进为什么不会自动累加

一项 123 轮的自我改进实验给出了迄今最有价值的反面证据。系统观察机器人失败、找出缺失的能力、写新技能或安装外部模型、在仿真中测试每一处改动，然后重复，全程没有人写机器人代码。好消息是 agent 能自己发现能力缺口——它注意到目标物体不在视野内，于是去找一个主动视角的模型、调试它、部署了一个可用的搜索技能。坏消息是：改动一直通过测试，目标任务（把调料放到冰箱最上层的架子）却始终没有成功。论文认为瓶颈很少在 agent 本身，而在它周围的三样东西：

1. 串联的感知模块不理解关系。 分割模型能找到"架子"，却找不到"最上层的架子"；agent 不断用更多的几何规则去补，永远不收敛——它需要的是另一类模型，而不是更多规则。
2. 技能链把学习锁定在第一步。 长任务大多在早期失败，证据和修复都堆积在第一步，后面的技能很少被执行到、测试到或改进到。
3. agent 学到什么由 harness 决定。 agent 精确地优化了评估器所测量的东西，包括评估器出错的地方；薄弱的测试和误导性的记忆，让大量活动变成了原地踏步。

这三条对应着三条设计建议。第一，感知失败时先问"是不是模型类别不对"，而不是继续堆规则。第二，分阶段评估：从每个技能的前置状态直接启动它，单独测量后面的技能，而不是只看整条链的结果（与第 5.4 节的"链式状态"问题互为表里）。第三，把评估器当作需要加固的系统组件：独立于 agent、可审计，并定期用人工检查它的判定。

8.5 现状：编码 agent 做机器人工程

• Project Fetch 第二阶段：Claude Opus 4.7 在 Claude Code 中独立完成机器狗编程任务，4 项共同任务用时 9 分 35 秒，最快的人类团队用了 181 分钟（约 19 倍）；但它仍没能完成自主"取回"球。
• ASPIRE：闭环执行引擎提供细粒度的多模态执行轨迹，让 agent 自己诊断失败、合成修复、验证结果；验证过的修复沉淀进技能库；进化搜索生成多样的程序。用 Claude Opus 5.5 时，在 LIBERO-Pro 的 80 个任务上平均成功率 99%，并能在真机上解魔方，效率随经验提升。

这些结果说明，编码 agent 已经能胜任"写代码、调试、在已有流程里迭代"；能否真正自主地推进一个研究问题，取决于前面三节的东西：可重复的回路、可信的评估、分阶段的证据。

8.6 小结

• 软件自我改进循环依赖便宜可重复的执行、可靠的判定与可回滚的状态；机器人研发需要把这三样专门造出来。
• 可重复的物理回路（复位、执行、验证、改进）是自动化的前提。
• 门控比搜索更重要：不可变的目标、独立的测量、可恢复的状态、按证据分级的技能、随时有效的统计比较。
• 改进不累加的主要原因在 agent 之外：感知的关系理解、技能链的前端偏置、评估器的漏洞。

8.7 自测

9. 从经验中变好：VLA 与规划器的 RL 后训练

9.1 问题：给大模型做 RL 难在哪里

预训练加模仿得到的 VLA 能"开箱即用"，但要达到真实部署所需的可靠性和速度，还要从自己的部署经验中继续学习。对大 VLA 做 RL，有几个特有的困难：

1. 似然不可算：流匹配与扩散策略的动作对数似然 $\log \pi(a \mid o)$ 没有闭式，而 PPO 一类策略梯度方法需要它；
2. 模型大、数据贵：全量微调几十亿参数，用的却只是几十到几千条真机轨迹；
3. 数据异构：示范、自主执行、人的干预混在一起，质量参差，奖励往往只有稀疏的成败；
4. 延迟：大模型推理慢，选动作时用的观测到执行时已经过时，RL 学到的东西要在这种延迟下仍然成立。

围绕第 1 点，现有方法大致分三条路：绕开似然、让似然可算、用 $Q$ 学习配一个小的可训练部分。

9.2 绕开似然：以优势为条件

π*0.6 的 RECAP 用的是"以优势为条件的策略"：先在所有数据上学一个价值函数，算出每个样本的优势 $A(o, a)$，再训练策略以一个"改进指示" $I = \mathbf{1}[A(o, a) > \varepsilon]$ 为额外条件；部署时把条件固定为 $I = 1$。

为什么这能改进策略？设数据中动作的分布为行为策略 $\pi_{\beta}(a \mid o)$，由贝叶斯公式，

当 $I$ 是 $A > \varepsilon$ 的指示函数时，这正是把行为策略限制在"优于平均"的那部分动作上——一步策略改进。RECAP 的训练目标同时包含无条件项与有条件项，$\min \mathbb{E}[-\log \pi_{\theta}(a \mid o, \ell) - \alpha \log \pi_{\theta}(a \mid I, o, \ell)]$，阈值 $\varepsilon_{\ell}$ 按任务设定，用来在正则与最优性之间权衡；训练时随机丢弃指示 $I$，因此推理时既可以直接以 $I = 1$ 采样，也可以像无分类器引导那样把有条件与无条件模型组合起来，进一步锐化分布。它不需要对数似然的梯度，只需要普通的条件生成训练，所以对流匹配 VLA 同样适用；而且能把示范、自主执行数据、执行中的人工干预统一放进同一个训练过程。RECAP 先用离线 RL 预训练一个通用 VLA，再通过真机数据专门化到下游任务；在最难的任务上，任务吞吐量提高到两倍以上、失败率大约减半，能在真实家庭里叠衣服、可靠地组装纸盒、用专业咖啡机做浓缩咖啡。

9.3 让似然可算：把去噪过程也当作 MDP

πRL 的思路是直接解决似然问题，给出两种构造：

• Flow-Noise：把去噪过程建模成一个离散时间的 MDP，并引入一个可学习的噪声网络，使每一步去噪都是一个有显式密度的随机转移，从而可以精确计算动作的对数似然；
• Flow-SDE：把确定性的 ODE 采样转换成 SDE，在去噪中注入随机性以便探索，并把"去噪"与"智能体-环境交互"组成一个两层的 MDP。

有了似然，就可以对 π0、π0.5 这样的流匹配 VLA 直接做在线策略梯度，在分布内与分布外都得到显著提升。

9.4 Q 学习 + 小的可训练部分

另一条路是保留大模型作为"行为先验"，只训练一个小部分，并用 $Q$ 学习提供改进方向：

• RL Token：让 VLA 额外输出一个紧凑的"RL token"——保留与任务相关的预训练知识、又适合作为在线 RL 的接口——再在它上面训练一个小的 actor-critic 头来修正动作，同时把学到的策略锚定在 VLA 附近。在拧螺丝、系扎带、插充电器、插网线四个真机任务上，几分钟到几小时的练习就让最难阶段的速度提高到最多 3 倍，成功率显著提升，有些任务甚至超过人类遥操作的速度。
• Learning While Deploying：在机器人舰队规模上做离线到在线的持续后训练。为了从异构、稀疏奖励的舰队数据里稳定学习，它用分布式的隐式价值学习估计价值，再用"伴随匹配"的 $Q$ 学习从流匹配动作生成器中提取策略；在 16 台双臂机器人、8 个真实任务上验证。
• 实时 VLA 的 RL：针对延迟，把"慢而有表达力的动作生成"与"快而反应式的动作编辑"分开——大 VLA 提出动作块，一个轻量的编辑策略根据最新状态快速修改动作，RL 训练的就是这个编辑策略。

一般的形式可以写成"以先验动作为锚的 actor 目标"（示意）：

$\lambda$ 控制离先验多远：太小会丢掉预训练的行为、在少量数据上过拟合，太大则学不到改进。

9.5 人的干预：信用分配要小心

人在执行中接管时，一段轨迹里混着策略的动作和人的动作。如果接管后任务成功了，朴素的价值学习会把这次成功也归功于接管之前的策略动作——而恰恰是那些动作让人不得不接管。TORL-VLA 用一个"干预截断"的 critic 防止这种错误的信用分配：干预之后的成功不回传给干预之前的策略动作。规模化的人工监督本身也要设计：HELP 让两名分工明确的操作员同时监督 12 台机器人——一名遥操作员负责高价值的远程干预和恢复示范，一名现场操作员负责监控、触发接管和物理复位——以提高单位人力的改进效率。

9.6 规划器的 RL：多轮工具调用的后训练

不只 VLA，agent 的规划器也可以后训练。AgenticRoboRL 的出发点是：编码 agent 的进步很大程度来自对模型本身的后训练，而机器人规划器还只依赖更好的 harness 和外部记忆。它的配方是监督微调 + 多轮强化学习；由于不同 harness 的执行机制不同（调用 VLA 技能、或生成控制代码），它用与 harness 相关的适配器把记录下来的规划器交互与任务结果对应起来，从而在固定执行组件的前提下共用一条 RL 训练管线。在 LIBERO-PRO 上，一个 9B 的规划器在不用外部记忆的情况下从 18.1% 提到 71.0%，接近使用外部记忆的 Codex（GPT-5.5）的 72.1%。代码即策略一侧，CaP-RL 用可验证的奖励做强化学习，提升成功率并能以很小的差距迁移到真机。

这里的奖励就是"执行完整个 harness 之后任务是否成功"，信用要分配到多轮的工具调用上——与第 8 章的教训一致，奖励（评估器）的可靠性决定了 RL 学到的是真本事还是评估器的漏洞。

9.7 小结

• 对流匹配或扩散 VLA 做 RL，核心障碍是似然不可算：可以以优势为条件绕开它（RECAP），把去噪过程建成有密度的 MDP 让它可算（πRL），或用 $Q$ 学习训练一个小头或编辑策略、并锚定在先验附近（RL Token、LWD、实时编辑策略）。
• 以优势为条件等价于把行为策略限制在优于平均的动作上，是不需要策略梯度的一步策略改进，能统一使用示范、自主数据与干预。
• 有人工干预的数据要防止错误的信用分配；人工监督的组织方式本身决定了后训练的效率。
• 规划器同样可以做多轮 RL 后训练；它学到什么，取决于任务结果判定的可靠性。

9.8 自测

10. 前沿模型直接当策略：能力边界与评测方法

10.1 问题：通用模型不经机器人训练，能走多远

2026 年下半年，GPT-6 Astra、Claude Opus 5 / 5.5、Gemini 4 Argon 等通用前沿模型开始被直接用作机器人策略：不做任何机器人专用训练，通过写代码、调用工具，甚至直接输出数值动作来完成任务。这带来两个问题：

1. 能力边界：它们在哪些方面已经可用，哪些方面还差得远？
2. 评测本身：同一个模型换一种接口或 harness，结果可以差几十个百分点；样本量、协议、成本口径各不相同——怎样的评测才能回答"模型本身怎么样"？

10.2 模型扮演的角色

同一个模型可以处在控制层级的不同位置（第 1 章的接口抽象层级）：

Astranomy 在同一个基准上比较了同一个模型的三种角色（直接策略、Codex 中的 agentic 策略、编排基础模型的监督者），并同时统计延迟与 token 成本；Anthropic 的评测比较了 12 个模型在 4 种接口下的表现。两者的共同结论是：角色与接口是影响结果的头号变量。

上下文学习者值得多说一句：RoboICL 把"示范上下文"（已有的示例）与"交互记忆"（模型自己的动作与观测结果）分开，用同一种"观测—动作—回执—观测"的格式书写，并用固定的锚点保留早期的交互、用最新的交互支持即时修正；GPT-Policy 用一个"上下文编译器"整理示范与反馈，让模型提出工具动作，再由带约束的控制器验证并执行——它还发现，没有动作标签的人类视频示范也有帮助。

10.3 结果怎么读：能力高度两极化

几条规律：

1. 两极化：语义理解、任务规划、感知处理已经很强（RobotWorld 里 agent 能自己搭出图像分割、相机标定、空间估计、基于动力学的计算这样的工作流）；高精度、动力学、长时程、主动获取信息仍然很弱。RoboDojo 的研究也指出 Astra 的能力"强烈两极化"。
2. 代码是目前最有效的接口：同样是前沿模型，作为编码 agent 走原生接口（OpenRUA）远好于直接输出数值动作。
3. 代价：延迟、token 成本与执行时间仍高出专用策略一到两个数量级。SenseNova 的大规模评测在允许从训练示范做上下文学习、并大幅增加执行步数的统一协议下得到了前所未有的结果，同时列出了接下来的方向：上下文学习的通用性、成本与执行时间、物理状态的验证、从不可逆失败中恢复，以及长时程能力。

10.4 评测方法：控制变量，并报告完整的代价

1. 固定 harness 再比较模型。 比较模型时，接口、工具、后处理、交互预算都要相同（RoboDojo 的比较强调"同样的后处理"；ROSClaw 用跨框架的对照协议，证明执行层设计本身会改变结果）。反过来，比较 harness 时要固定模型。
2. 说清楚样本量与协议。 每个任务的回合数决定了置信区间的宽度：10 个回合时，一个观测成功率 50% 的任务，95% 置信区间大约是 24%–76%。
3. 测鲁棒性，而不只是标准设置。 LIBERO-PRO 在物体、初始状态、指令、环境四个维度上加入合理的扰动后，标准设置下超过 90% 的模型跌到 0%——它们记住了训练集里的动作序列和布局，而不是理解了任务。
4. 测失败之后发生了什么：恢复能力（LIBERO-RECOVER 的四级恢复）、主动获取信息（RoboQuest）。
5. 报告完整的代价：token 数、每次决策的延迟、端到端的执行时间，以及（真机上）人工干预与复位次数。
6. 仿真与真机都要有。 RoboDojo 同时包含 42 个仿真任务与 18 个真机任务：仿真提供可扩展、可复现的反馈，真机暴露部署时的问题。

import math

def wilson_interval(successes, n, z=1.96):
    """成功率的 Wilson 置信区间：小样本下比正态近似可靠。例：wilson_interval(5, 10) ≈ (0.24, 0.76)。"""
    if n == 0:
        return 0.0, 1.0
    p = successes / n
    denom = 1 + z * z / n
    center = (p + z * z / (2 * n)) / denom
    half = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / denom
    return center - half, center + half

10.5 小结

• 前沿模型可以扮演直接策略、编码 agent、编排者、上下文学习者等不同角色；角色与接口是结果的头号变量，编码 + 原生接口目前最有效。
• 能力高度两极化：语义、规划、感知强；精度、动力学、长时程、主动探索弱；延迟与成本仍高一到两个数量级。
• 可信的评测要控制变量（固定 harness 比模型）、报告样本量与置信区间、测扰动鲁棒性与恢复能力，并报告完整的代价。

10.6 自测

11. 安全：闸门放在模型外面

11.1 问题：两类失败来源

当语言模型能驱动有物理接触能力的机器人时，失败可能来自两个方向。

有攻击者时。 RoboPAIR 是第一个专门越狱 LLM 控制的机器人的算法，它诱导的不是有害文本，而是有害的物理动作。三种设定全部被攻破：白盒（完全访问一个自动驾驶 LLM）、灰盒（部分访问一台配 GPT-4o 规划器的地面机器人）、黑盒（只能查询一台集成了 GPT-3.5 的商用四足）。BadRobot 则展示了通过普通语音交互就能利用的三类弱点：机器人系统里的 LLM 被操纵、语言输出与物理动作不一致、世界知识的缺陷导致无意的危险行为。

没有攻击者时也会出事。

• SafeHarness 给编码 agent 的每个操作任务配了一个"绝对不能碰"的障碍物：agent 在大多数情况下仍然撞了上去。它在推理里提到了障碍物，提示词也明确禁止触碰——问题不在感知或指令，而在规划：约束从未成为优先级，agent 把完成任务当成唯一目标。
• GuardianBench 揭示了"潜在的情境风险"：良性的指令和安全的场景，组合起来才变得危险。它固定场景、只换指令，构造了 3024 个"安全/不安全"成对样本；主流 VLM 的判断对指令不敏感，倾向于两种指令都批准，成对准确率平均只有 24.1%。
• ROSClaw 在同一套执行层上发现，不同模型提出越界动作的比率最多相差 4.8 倍。

结论很清楚：模型不能是最后一道防线。安全检查必须放在模型之外，并且分层。

11.2 分层防线

几个系统的关键设计：

• SafeGate 参照服务机器人安全标准 ISO 13482，从自然语言命令中抽取与安全相关的结构化属性，用确定性的闸门决定放行或拒绝；通过闸门的命令再被分解成"任务安全契约"——不变量、守卫条件和中止条件——在执行期间持续检查，因为开始时看似安全的命令也可能在执行中进入不安全的状态。
• RoboGuard 分两阶段：先由一个"信任根"LLM——与用户的提示隔离，不受恶意输入影响——用思维链把预先定义的安全规则结合当前环境，生成情境化的安全规范（例如时序逻辑约束）；再用时序逻辑控制综合，在满足规范的前提下尽量少地违背用户的意图，解决规范与可能不安全的计划之间的冲突。在考虑最坏情况越狱攻击的仿真与真机实验中，它把不安全计划的执行率从 92% 以上降到 3% 以下，且不影响安全计划的完成，对自适应攻击也具有鲁棒性。
• CORE 让 VLM 直接从视觉观测持续推理随情境变化的安全规则（同一条走廊，拥挤与空旷时、紧急与正常时要求不同），把规则落实为空间上的安全集，再用控制屏障函数强制执行，不需要预先的地图或安全规范。

11.3 形式层：时序逻辑规范与运行时监视器

很多安全规则天然是时序的："拿着刀时不能靠近人""开门之前不能进入房间""任何时候都不能把水倒在电器上"。用线性时序逻辑（LTL）写出来就是 $\mathbf{G}\,(\mathit{holding\_knife} \to \lnot\, \mathit{near\_person})$、$(\lnot\, \mathit{enter\_room})\ \mathbf{U}\ \mathit{door\_open}$、$\mathbf{G}\, \lnot\, \mathit{pour\_on\_appliance}$（$\mathbf{G}$ 为"始终"，$\mathbf{U}$ 为"直到"）。Safety Chip 把专家验证过的 LTL 约束编译成自动机，在执行前剪掉会导致违规的动作。对"安全性质"（坏事永远不发生）而言，监视器只需要维护自动机的当前状态，检查下一个动作会不会把它带进违规状态：

class SafetyMonitor:
    """两类常见安全性质的运行时监视器（示意）：
    invariants: G(cond -> not forbidden) 形式；precedence: 在 trigger 发生之前禁止 action（(¬a) U b）。"""
    def __init__(self, invariants, precedence):
        self.invariants = invariants          # [(cond(state), forbidden(action))]
        self.precedence = precedence          # [(action_name, trigger_event)]
        self.seen_events = set()

    def allowed(self, state, action):
        for cond, forbidden in self.invariants:
            if cond(state) and forbidden(action):
                return False, "违反不变量"
        for name, trigger in self.precedence:
            if action.name == name and trigger not in self.seen_events:
                return False, f"在 {trigger} 之前禁止 {name}"
        return True, ""

    def observe(self, event):
        self.seen_events.add(event)           # 自动机状态推进：记录已发生的事件

关键在于这个监视器是确定性的、与模型无关的：无论模型被如何诱导，违规的动作都到不了执行器。模型的作用被限制在"把规则结合当前环境具体化"（如 RoboGuard 的信任根 LLM），而判定本身交给形式化的检查。

11.4 物理层：控制屏障函数

最底层的保障是几何与动力学上的：把安全集写成 $S = \{x : h(x) \ge 0\}$（例如令 $h(x)$ 为与人的距离减去安全距离），要求控制输入满足

只要初始状态在 $S$ 内，这个条件保证状态永远不离开 $S$（$\alpha > 0$ 控制靠近边界时减速的快慢）。实现上，对上层给出的名义控制 $u_{\mathrm{nom}}$ 做一个最小改动的投影：$u^* = \arg\min_u \lVert u - u_{\mathrm{nom}} \rVert^2$，约束为上式。对控制仿射系统、单个约束，这个二次规划有闭式解：

import numpy as np

def cbf_filter(u_nom, grad_h, h, alpha=2.0):
    """单积分器 x' = u、单个约束 ∇h·u ≥ -α h 的 CBF 安全滤波（闭式解）：
    名义控制满足约束就原样通过，否则沿 ∇h 方向做最小修正。"""
    g = np.asarray(grad_h, dtype=float)
    slack = g @ u_nom + alpha * h            # ≥ 0 表示满足约束
    if slack >= 0:
        return u_nom
    return u_nom - slack * g / (g @ g)       # 投影到半空间 {u : ∇h·u ≥ -α h} 上

CORE 正是用这种方式，把 VLM 推理出的情境化规则落实成可强制执行的约束：语义判断可以出错，但执行层的约束是确定的。SafeHarness 也在物理层上补洞：用障碍物的包围几何做避障路径规划，并让接触执行同样受这个约束限制。

11.5 小结

• 风险既来自攻击（越狱、诱导），也来自无攻击时的规划失误与潜在的情境风险；模型不能是最后一道防线。
• 防线要分层：语义层判定是否允许，形式层检查时序规范，运行时层持续监控，物理层用屏障函数与硬限位兜底，审计层保证可追溯。
• 越往下层越确定、越与模型无关；模型的角色应限制在"把规则结合当前情境具体化"，判定交给形式化的检查。

11.6 自测

12. 串起来：搭一个 agentic 机器人系统的路线

按依赖关系排序：先安全与执行，再闭环与判定，再智能与学习。每个阶段给出目标、关键决策与进入下一阶段的验收标准。

12.1 阶段一：执行层与安全底座（第 4、5、11 章）

• 目标：一组可调用、可中断、有边界的能力（技能、VLA 指令或原生接口），以及与模型无关的安全底座。
• 关键决策：接口层级（技能 / VLA / 代码）；频率栈（谁以多高频率运行）；硬限位、急停、执行前动作校验放在哪里。
• 验收标准：每个能力都有时间预算、能被中途停止；任何来自上层的动作都必须经过执行前校验才能到达执行器；有审计日志。

12.2 阶段二：最小闭环与结果判定（第 1、6 章）

• 目标："观测 → 状态表示 → 一次一个工具调用 → 退出码"的最小 harness。
• 关键决策：状态表示（场景图还是原始图像）；每个能力的终止规则与成功判定（规则、检测器还是 VLM 判断）；退出码的格式（成功、失败、超时、未就绪及原因）。
• 验收标准：成功判定在人工标注的样本上有可接受的准确率——判定器的错误会被后面所有阶段放大；能力从"干净起点"和"链式状态"出发的成功率分别测量过（第 5.4 节）。

12.3 阶段三：grounding 与求助（第 2 章）

• 目标：计划在当前状态下可行，不确定时知道停下来问。
• 关键决策：可行性来源（价值函数、前置条件检查、仿真预演）；求助机制（共形预测的覆盖率目标 $1 - \varepsilon$ 与校准数据）。
• 验收标准：歧义指令的求助率与误执行率都在目标范围内；换环境后重新校准过。

12.4 阶段四：记忆与技能库（第 6、8 章）

• 目标：经验能积累、能复用，而且不会被一次碰巧的成功污染。
• 关键决策：记忆锚定在什么上（物体、位置）、何时验证、何时删除；技能晋升需要多少证据。
• 验收标准：技能的晋升用随时有效的统计检验（第 8.3 节）；记忆在使用前经过验证；长时程任务的成功率随经验单调提升，而不是来回波动。

12.5 阶段五：外环与自动化研发（第 7、8 章）

• 目标：奖励、数据、环境的迭代由 agent 完成；真机上有可重复的"复位—执行—验证—改进"回路。
• 前提：前四个阶段已经稳定、可脚本化——agent 只能自动化一个本身可重复的流程。
• 关键决策：关卡按代价从低到高排列；评估器独立于 agent、目标不可变；分阶段评估技能链。
• 验收标准：agent 产出的改进在独立评估器上成立，且经过人工抽查；错误晋升率可量化。

12.6 阶段六：后训练（第 9 章）

• 目标：模型本身（VLA 或规划器）从部署经验中变好。
• 关键决策：路线（以优势为条件、让似然可算、$Q$ 学习 + 小头）；对先验的锚定强度；人工干预数据的信用分配；人工监督的组织方式。
• 验收标准：在扰动设置与分布外任务上也有提升，而不只是在训练任务上。

12.7 贯穿始终：评测协议（第 10 章）

12.8 全书小结

1. 机器人上的 agent 是任务层的闭环控制器；选项框架把它拆成选择、执行、终止与判定三件职责。
2. grounding 的核心是给"有用"配上"可行"，并在不确定时有统计保证地求助。
3. 代码与 VLA 是两种执行接口：代码精确、可检查，VLA 擅长接触与实时；让模型写目标、让优化器求数值，是稳健的分工。
4. 分层的难点在接口：传什么、多快、何时交接；技能组合的主要隐患是链式状态带来的协变量偏移。
5. harness 决定上限：它要造出物理世界不提供的"读取状态"与"判定结果"两种能力。
6. 外环与自我改进的瓶颈是验证：关卡、证据门控、独立的评估器比更强的生成能力更重要。
7. 大模型的 RL 后训练要绕开或解决似然问题，并小心人工干预的信用分配。
8. 前沿模型的能力高度两极化；评测要控制变量并报告完整代价。
9. 安全闸门必须在模型之外、分层、越往下越确定。