一台机械臂被反复拆台之后

清华深圳国际研究生院的那台机械臂，把纸杯叠成 3-2-1 三层金字塔之后，被人从中间一把拆了。

它没有推倒重来，而是把被打断的那一层重新压回当前计划，继续往下叠。

这套系统叫 EMERGE-Policy，论文编号 arXiv 2608.29896v2。

作者来自清华、南京理工、西安交大、西电、哈工大、北大与南洋理工的联合团队。

在 100 次标准真机实验里，它保持了很高的叠杯完成度，几乎没有出现中途崩掉的情况。

面对人为破坏、纸杯尺寸变化 5%-15%、颜色与相机视角突变时，成功率仍然守在 85%-94%。

同一套代码在 Standard LIBERO 上拿到 99.2% 的平均成功率。

在 LIBERO-Plus 的光照与相机位姿扰动测试里，它拿到 93.9%。

更值得注意的是，整个实验过程没有微调任何一个底层模型。

变强的是编排结构，不是参数规模，也不是数据量。

这篇文章只回答一个问题：为什么把 VLA 和世界模型降级成技能之后，系统反而更稳。

答案藏在三件事里：技能按职能分类、上下文被切开、失败被局部吸收。

单一 Policy 的三种崩法

端到端 VLA 把感知、规划、执行、验证、恢复全部压进一次前向推理里。

在短任务里这是优点，放到长程任务里，它很快变成三个具体的故障。

第一种故障是上下文过载，而且随步数线性恶化。

每一帧观测、每一次工具返回都要回到同一条隐状态或者同一段对话里。

信息量一路上涨，真正决定下一步该怎么走的那条证据反而被淹没了。

第二种故障是模式冲突，它来自两种完全不同的时间尺度。

高层规划需要长上下文的慢思考，低层执行需要高频、精确、短周期的动作输出。

两种节奏塞进同一个模型，最常见的结果就是逻辑混乱或者动作抖动。

第三种故障是误差累积，而且失败之后完全不可诊断。

端到端策略把中间决策全部隐式化，出错时没人知道究竟是哪一步错了。

论文的判断很直接：策略单次 rollout 并不负责组织任务分解、结果验证、恢复与持久状态。

这四件事必须由某个明确的角色来负责，而不是指望模型在长上下文里自己涌现。

EMERGE-Policy 的做法不是再训一个更大的 Policy，而是在外面补一层显式编排。

它把「一个模型做完所有事」换成「一个框架调度多个专职角色」。

统一技能库：按在决策回路里的职能分类

传统做法把 VLA、世界模型、验证器看成一堆互相竞争的替代方案，只能挑一个当主角。

EMERGE-Policy 把它们全部降级为技能，再按在决策回路里的职能分成三类。

第一类是操作技能（Operational Skills），负责把已经确定的意图变成真实动作。

这一类里放的是 VLA 模型 π0.5，以及一批运动原语。

VLA 管高频、精确的末端轨迹，运动原语管粗粒度、大范围的运动规划。

第二类是想象技能（Imagination Skills），负责在真正动手之前先预演一遍。

世界模型 Cosmos Policy 被当成仿真器，预测候选动作会生成什么样的未来画面。

第三类是评估技能（Evaluation Skills），负责判断可行性、进度与完成度。

验证器在执行之前校验前置条件，在执行之后校验子目标的完成标准。

它还要在预演阶段给世界模型的多条候选路径打分排序，挑出最值得执行的那一条。

这套分类最关键的一点是：角色由职能定义，不由实现定义。

只要输入输出遵循同一套技能契约与状态契约，后端就可以自由替换。

换句话说，换一个 VLA、换一个世界模型，编排协议不需要改动一行。

论文把这个原则写得很工程：模型是技能，由框架在合适的时机调用。

这一点也解释了为什么它不需要重新训练：被换掉的是调用关系，不是权重。

主智能体与角色化子智能体：上下文是被切开的

系统里跑着两种代理，它们的职责边界划得非常清楚。

主智能体（Main Agent）是决策与调度中枢，也是唯一持有全局任务状态的节点。

它把语言指令拆成一组带完成标准的子目标，再决定下一步该调用谁。

角色化子智能体（Sub Agents）则在彼此隔离的上下文里干活。

感知子智能体输出场景的 3D 边界框与空间语义，供主智能体判断当前局面。

验证子智能体实时调用验证器工具，检查当前子目标是不是真的完成了。

监控子智能体盯住执行过程中的物理异常，比如接触失败或者物体滑落。

它们只把结构化的、与当前任务相关的证据交回主智能体。

原始观测、中间工具输出、详细的处理轨迹，都留在子智能体自己的上下文里。

这就是论文所说的分层上下文工程，主智能体的窗口只装决策真正需要的东西。

好处不只是省 token，更是让每一条决策都能追溯到具体的证据来源。

上下文一旦被切开，低层噪声就很难在主循环里扩散成错误决策。

代价是通信契约要设计得更严格，结构化证据必须够用且不失真。

子目标契约、Branch Stack 与三层记忆

每一个子目标都必须写清三件事，缺一件就会退回隐式决策。

目标是哪个实体、要把它的状态改成什么、用什么标准判定它改完了。

这三件事构成操作、想象、评估三类技能共享的契约，也是唯一的进度依据。

执行之后，观测结果直接对着当前子目标的完成标准打分，不需要额外的解释层。

标准满足，计划推进到下一个子目标，验证子智能体同步更新计划文件。

标准不满足，系统生成一份文本化的失败诊断，而不是只抛一个错误码。

诊断会转成一个局部恢复目标，被压进 Branch Stack。

恢复成功，执行回到被打断的那个计划继续跑，已经完成的部分照常保留。

只有局部恢复解决不了的失败，才会触发主智能体修改高层计划。

这一步是整篇论文里最值得抄走的工程决策。

长程任务里绝大多数失败其实是局部的，全局重规划会把已经做对的部分一起丢掉。

局部恢复把失败的影响范围限制在一个子目标内，重试成本因此低了一个量级。

记忆分成三层，而且全部落在文件上，不依赖任何隐藏状态。

PLAN.md 记录任务图与当前进度，是恢复时的唯一权威。

HISTORY.md 追加存储历史观测与工具调用摘要，用于回看决策依据。

MEMORY.md 动态修正并更新环境事实，比如物体位置与场景约束。

上下文接近上限时，系统自动触发 Memory Integration 压缩历史。

论文强调这是 token 感知的外部记忆，被压缩的是历史，不是任务目标。

四个基准上的数字

团队在三个公开模拟基准与真机上做了评估，关键结果整理如下表。

基准	配置	结果	对照
Standard LIBERO	世界模型技能做轨迹想象	99.2%	底座 +0.7
Standard LIBERO	π0.5 作为执行技能	98.8%	底座 +2.0
LIBERO-Plus	含世界模型，扰动场景	93.9%	对照 +11.7
RoboDojo-Sim Memory	视觉记忆与长程规划	25.00 / 22.51%	同类型领先
真机叠杯	人为破坏与尺寸扰动	85%-94%	100 次标准实验高完成度

需要提醒的是，这些增益来自编排，而不是来自额外的微调或者更大的底座。

在 Standard LIBERO 上，世界模型技能只贡献了 0.7 个百分点，幅度有限。

换成 π0.5 作为执行技能之后，平均成功率达到 98.8%，比底座高 2.0 个百分点。

扰动测试里的 11.7 个百分点才是真正的重点所在。

光照变化与相机位姿偏移，恰好是真实部署里最常见的那一类分布漂移。

RoboDojo-Sim 考的是视觉记忆与长程规划，也是这批基准里最难的一项。

它在 Memory 维度拿到 25.00 分与 22.51% 的成功率，明显领先同类型方案。

论文据此认为，系统具备历史信息编码能力与非马尔可夫推理能力。

真机上 85%-94% 的抗干扰区间，比模拟器里的数字更有说服力。

团队也承认短板：在完整机器学习工程任务上，它与更大模型之间仍有明显差距。

先规划再推理、先反思再行动这类原子能力，也还有不小的提升空间。

最小可跑的编排骨架

下面这段代码把论文的骨架抽出来，只用标准库，保存成 py 文件就能直接运行。

# emerge_skill.py —— EMERGE-Policy 编排骨架（仅用标准库）
from dataclasses import dataclass

@dataclass
class Subgoal:
    entity: str
    target_state: str
    criterion: str          # 可判定的完成标准

class Skill:
    """统一技能接口：三类技能共用同一个 invoke 签名"""
    kind = "operational"
    def invoke(self, subgoal, world):
        raise NotImplementedError

class VLAOperational(Skill):
    kind = "operational"
    def invoke(self, subgoal, world):
        world[subgoal.entity] = subgoal.target_state
        return {"action": f"move({subgoal.entity})"}

class WorldModelImagination(Skill):
    kind = "imagination"
    def invoke(self, subgoal, world):
        return {"predicted": [f"{subgoal.entity}->{subgoal.target_state}",
                              f"{subgoal.entity}->miss"]}

class CriterionEvaluator(Skill):
    kind = "evaluation"
    def invoke(self, subgoal, world):
        ok = world.get(subgoal.entity) == subgoal.target_state
        diag = "" if ok else f"{subgoal.entity} 未达到 {subgoal.target_state}"
        return {"satisfied": ok, "diagnosis": diag}

class MainAgent:
    def __init__(self, skills):
        self.skills = {s.kind: s for s in skills}
        self.plan, self.branch_stack = [], []
        self.memory = {"PLAN.md": [], "HISTORY.md": []}

    def run(self, subgoals, world, max_steps=20):
        self.plan = list(subgoals)
        for step in range(1, max_steps + 1):
            if not self.plan:
                return {"status": "ok", "steps": step - 1, "memory": self.memory}
            goal = self.plan[0]
            preview = self.skills["imagination"].invoke(goal, world)
            act = self.skills["operational"].invoke(goal, world)
            verdict = self.skills["evaluation"].invoke(goal, world)
            self.memory["HISTORY.md"].append({"entity": goal.entity, "preview": preview, "act": act})
            if verdict["satisfied"]:
                self.plan.pop(0)
                self.memory["PLAN.md"].append(f"done:{goal.entity}")
                continue
            self.branch_stack.append(verdict["diagnosis"])
            if not self._recover_local(world):
                return {"status": "global_replan", "diagnosis": verdict["diagnosis"]}
        return {"status": "out_of_budget"}

    def _recover_local(self, world):
        """局部恢复优先：栈里有诊断就先修局部，空了才升级"""
        while self.branch_stack:
            world["recovered"] = self.branch_stack.pop()
            return True
        return False

if __name__ == "__main__":
    world = {"cup1": "upright", "cup2": "upright", "cup3": "upright"}
    goals = [Subgoal("cup1", "stacked", "cup1 位于 cup2 之上"),
             Subgoal("cup2", "stacked", "cup2 位于 cup3 之上")]
    agent = MainAgent([VLAOperational(), WorldModelImagination(), CriterionEvaluator()])
    print(agent.run(goals, world))

这段代码保留了论文骨架里的三个关键机制。

第一，技能按 Operational、Imagination、Evaluation 三类注册，职责不重叠。

第二，子目标自带可判定的完成标准，由评估技能说了算，主智能体不自证。

第三，失败先压栈做局部恢复，只有栈空了才升级为全局重规划。

把 VLAOperational 换成真实的 VLA 接口，编排逻辑一行都不用动。

想象技能可以换成任意世界模型，评估技能可以换成任意验证器。

这套图结构搬到软件 Agent 上要注意什么

具身智能的这一套结构，对今天写软件 Agent 的人同样成立。

第一，把执行工具、预测工具、校验工具分开注册，不要混在同一个决策步里。

很多 Agent 失败不是工具不够，而是三种职责被压进了同一次模型调用。

第二，子目标必须带可判定的完成标准，而不是一句自然语言描述。

写不出判定条件的子目标等于没有验收，模型只能自己宣布任务完成了。

第三，局部恢复优先于全局重规划，这一点在软件任务里更容易做到。

承认失败是局部的，比每次失败都从头规划便宜得多，也稳定得多。

第四，把记忆落到文件层，并给上下文压缩设定明确的触发条件。

只靠对话上下文扛长任务，迟早会丢目标、丢约束或者丢已经确认的事实。

第五，不要为窄任务开一堆并行子智能体，并行只在子任务真正独立时才划算。

否则你只是把串行的错误放大成并行的账单，轨迹还更难复现。

论文给出的经验可以浓缩成一句话：让模型成为技能，让框架负责编排。

这句话对机械臂成立，对任何需要长程执行的生产级 Agent 同样成立。

参考与复现入口

论文标题：EMERGE-Policy: A Robot Mind Emerges Beyond a Single Policy。

论文的 arXiv 编号是 2608.29896v2，可以按编号直接检索全文。

项目主页是 emerge-policy.github.io/EMERGE-Policy。

代码仓库在 GitHub 的 EMERGE-Policy 组织下，通讯作者是清华李秀教授。

团队来自清华大学深圳国际研究生院智能计算实验室，方向覆盖决策智能与具身智能。