传统机器人编程难以规模化。它需要手动协调多模态感知、物理接触动力学、多样化配置以及执行失败。代码即策略系统让语言模型能够将这些要素组合成可执行的机器人程序。这使得机器人行为变得可检查、可编辑、可调试。
但现有的机器人编程智能体运行在简陋的执行环境中。它们只能接收粗略的、任务级别的反馈。一次失败的运行只表明任务失败，却不说明原因。根本原因可能在于感知、运动规划、抓取、接触动力学或长程协调。这些系统在任务结束后也会丢弃修复方案。因此，智能体在解决第一百个任务时，并不比解决第一个任务时更有经验。
来自英伟达、密歇根大学、伊利诺伊大学厄巴纳-香槟分校、加州大学伯克利分校和卡内基梅隆大学的研究团队推出了 ASPIRE（通过迭代机器人探索进行智能体技能编程）。这是一个持续学习系统，能够编写并优化机器人控制程序。它还将经过验证的修复方案提炼成一个可复用、可迁移的技能库。
ASPIRE 的工作原理
ASPIRE 运行一个开放式学习循环，包含三个组成部分。它采用协调器-执行器架构。一个中央协调器管理共享技能库，并将执行器编程智能体分派到各个任务。执行器之间不交换完整的聊天历史或原始轨迹。只有经过提炼的技能在它们之间传递。
闭环机器人执行引擎：该引擎用每个基本操作的多模态轨迹取代了粗略的运行反馈。对于每次感知、规划和控制调用，它都会存储输入、输出和返回状态。它还会存储 RGB 关键帧、叠加层、抓取候选、物体姿态和运动规划结果。智能体只检查与失败相关的调用。然后，它定位故障，并通过重新执行来验证修复方案。
技能库：可复用的知识很少是整个任务程序。因此，该库存储的是异构的修复方案。这些方案包括：定位启发式规则、感知提示词、抓取约束、运动基元以及调试工作流。每个技能都是紧凑的上下文内指导。它包含一个失败特征、一个适用条件、一个修复策略，并且通常附带一段代码草图。协调器只接纳那些通过调试验证和 API 策略检查的模式。
进化式搜索：仅靠跟踪引导的调试可能会陷入局部修复循环。智能体会不断修补同一个失败的策略。为了拓宽探索范围，ASPIRE 在每一轮提出 K 个候选程序。这些候选程序以表现最佳的先验程序及其剩余的失败轨迹为条件。下一轮会探索不同的策略，而不是优化单一解决方案。
在模拟环境中，编码智能体是 Claude Code，搭配 Claude Opus 4.6 和 100 万 token 的上下文窗口。程序使用 CaP-X 编写，这是一个基于 MuJoCo Playground 构建的开源“代码即策略”框架。该智能体无法读取模拟器的真实数据。禁止读取物理引擎状态或诸如 .bddl、.xml、.urdf 等资源文件。规则很简单：如果一台带有摄像头的真实机器人能够做到，那么它就是允许的。
交互式讲解器
一个实例：多角度接近技能
考虑一个 BEHAVIOR-1K 任务：机器人需要捡起桌子附近的一台收音机。感知模块返回了收音机的位姿，但重复调用 navigate_to_pose 均告失败。生成的目标点位于桌子边缘约 20 厘米范围内。这落入了桌子的碰撞规避缓冲区，cuRobo 返回了 PLANNING_ERROR。
智能体读取轨迹并定位原因。失败原因是目标不可行，而非感知或抓取问题。随后，它编写了一个修复方案，在收音机周围采样对峙位姿。
# radio_pos, safe_navigate() and dist_to() are provided by ASPIRE's robot API
for angle_deg in [180, -90, 90, -45, 45]:
angle = np.radians(angle_deg)
tx = radio_pos[0] + 0.7 * np.cos(angle) # standoff 0.7 m from the radio
ty = radio_pos[1] + 0.7 * np.sin(angle)
face_yaw = np.arctan2(radio_pos[1] - ty, radio_pos[0] - tx)
moved = safe_navigate([tx, ty, face_yaw], f"ang_{angle_deg}")
if moved and dist_to(radio_pos[:2]) < 0.8: # reached a pose within 0.8 m
break每个角度都将目标点置于物体的不同侧面。当一侧被阻挡时，另一侧通常是畅通的。在这里，180 度位姿清除了缓冲区。经过验证的修复方案被接纳为一个可复用的导航恢复技能。
基准测试与结果
ASPIRE 在三个基准系列上进行了评估。LIBERO-Pro 测试了在物体、目标和空间扰动下的短周期鲁棒性。Robosuite 涵盖了接触密集的单臂和双臂操作。BEHAVIOR-1K 涵盖了长周期的家庭移动操作。主要的编码智能体基线是 CaP-Agent0。它使用了视觉差分、预定义的技能库以及每个回合的测试时重试。对比还包括端到端的视觉-语言-动作策略：OpenVLA、π0 和 π0.5。
在 LIBERO-Pro 上，ASPIRE 在 Object 套件上获得了高达 77 分的提升。该数值是在最强基线上对两个扰动轴取平均的结果。它在 Goal 套件上还提升了 41.5 分，在 Spatial 套件上提升了 42.5 分。在 Robosuite 上，双臂交接的成功率从 20% 提升到了 92%。在 BEHAVIOR-1K 上，收音机拾取任务的成功率从 56% 提升到了 88%。
零样本结果值得注意。通过复用从 LIBERO-90 积累的技能，ASPIRE 在未见的 LIBERO-Pro Long 任务上达到了约 31% 的成功率。此前的方法则饱和在 4% 附近。
| 维度 | 端到端 VLA（OpenVLA、π0、π0.5） | CaP-Agent0 | ASPIRE |
|---|---|---|---|
| 范式 | 学习权重策略 | 代码即策略智能体 | 代码即策略智能体 |
| 跨任务经验 | 无（冻结权重） | 每个任务后丢弃 | 蒸馏到技能库中 |
| 失败反馈 | 测试时无反馈 | 粗粒度的场景级摘要 | 每个原语的多模态轨迹 |
| 测试时策略 | 直接推理 | 每个种子的推理 + 重试 | 每个任务一个程序 |
| LIBERO-Pro 总体 | 0–13% | 18% | 72% |
| LIBERO-Pro Long 零样本 | 0–5% | 约 4% | 约 31% |
真实机器人技能迁移
研究团队在真实的双臂 YAM 工作站上测试了三个从仿真中发现的技能。真实机器人编码智能体是 OpenAI Codex GPT-5.5。其具身形态和 API 与仿真环境不同。迁移的技能降低了调试成本。易拉罐拾取任务从 13/20 提升到了 19/20，同时使用的模型 token 数量减少了约 10 倍。抽屉打开任务从 0/20 提升到了 11/20，而无技能基线从未成功过。
关键要点
- ASPIRE 编写并调试机器人程序，然后将验证通过的修复方案保存为可复用的上下文技能。
- 每个原语的多模态轨迹让智能体能够定位失败原因，而不是根据运行结果进行猜测。
- 它在 LIBERO-Pro 上获得了高达 77 分的提升，并将 Robosuite 的交接成功率从 20% 提升到了 92%。
- 在 LIBERO-Pro Long 任务上，零样本迁移达到了约 31%，而此前的方法仅为约 4%。
- 通过仿真发现的技能，在不同本体和 API 条件下，降低了真实机器人的调试成本。
Traditional robot programming is hard to scale. It requires orchestrating multimodal perception, physical contact dynamics, diverse configurations, and execution failures by hand. Code-as-policy systems let language models compose these into executable robot programs. That makes robot behavior inspectable, editable, and debuggable.
But existing robotic coding agents run in naive execution environments. They receive only coarse, task-level feedback. A failed rollout signals that the task failed, not why. The root cause can be perception, motion planning, grasping, contact dynamics, or long-horizon coordination. These systems also discard fixes once a task ends. So the agent solving its hundredth task is no more experienced than at its first.
A team of researchers from NVIDIA, University of Michigan, UIUC, UC Berkeley, and CMU introduces ASPIRE (Agentic Skill Programming through Iterative Robot Exploration). It is a continual learning system that writes and refines robot control programs. It also distills validated fixes into a reusable, transferable skill library.
How ASPIRE works
ASPIRE runs an open-ended learning loop with three components. It uses a coordinator–actor architecture. A central coordinator manages the shared skill library and dispatches actor coding agents to tasks. Actors do not exchange full chat histories or raw trajectories. Only distilled skills move between them.
Closed-loop robot execution engine: This replaces coarse rollout feedback with per-primitive multimodal traces. For each perception, planning, and control call, it stores inputs, outputs, and return status. It also stores RGB keyframes, overlays, grasp candidates, object poses, and motion-planning results. The agent inspects only the calls implicated by a failure. It then localizes the fault and validates a repair through re-execution.
Skill library: Reusable knowledge is rarely an entire task program. So the library stores heterogeneous fixes. These include localization heuristics, perception prompts, grasping constraints, motion primitives, and debugging workflows. Each skill is compact in-context guidance. It holds a failure signature, a when-to-apply condition, a repair strategy, and often a code sketch. The coordinator admits only patterns that pass debug validation and API-policy checks.
Evolutionary search: Trace-guided debugging alone can collapse into local repair loops. The agent keeps patching the same failed strategy. To broaden exploration, ASPIRE proposes K candidate programs each round. Candidates condition on top-performing prior programs and their remaining failure traces. The next round explores distinct strategies rather than refining one solution.
In simulation, the coding agent is Claude Code with Claude Opus 4.6 and a 1M-token context window. Programs are written in CaP-X, an open-source code-as-policy framework built on MuJoCo Playground. The agent cannot read simulator ground truth. Reading physics-engine state or asset files like .bddl, .xml, or .urdf is forbidden. The rule is simple. If a real robot with a camera could do it, it is allowed.
Interactive Explainer
A worked example: the Multi-Angle Approach skill
Consider a BEHAVIOR-1K task where a robot must pick up a radio near a table. Perception returns the radio pose, but repeated navigate_to_pose calls fail. The generated goal lies within about 20 centimeters of the table edge. That falls inside the table’s collision-avoidance buffer, and cuRobo returns PLANNING_ERROR.
The agent reads the trace and localizes the cause. The failure is target infeasibility, not perception or grasping. It then writes a repair that samples standoff poses around the radio.
# radio_pos, safe_navigate() and dist_to() are provided by ASPIRE's robot API
for angle_deg in [180, -90, 90, -45, 45]:
angle = np.radians(angle_deg)
tx = radio_pos[0] + 0.7 * np.cos(angle) # standoff 0.7 m from the radio
ty = radio_pos[1] + 0.7 * np.sin(angle)
face_yaw = np.arctan2(radio_pos[1] - ty, radio_pos[0] - tx)
moved = safe_navigate([tx, ty, face_yaw], f"ang_{angle_deg}")
if moved and dist_to(radio_pos[:2]) < 0.8: # reached a pose within 0.8 m
breakEach angle puts the goal on a different side of the object. When one side is blocked, another is often open. Here the 180-degree pose clears the buffer. The validated fix is admitted as a reusable navigation-recovery skill.
Benchmarks and results
ASPIRE is evaluated on three benchmark families. LIBERO-Pro tests short-horizon robustness under object, goal, and spatial perturbations. Robosuite covers contact-rich single- and dual-arm manipulation. BEHAVIOR-1K covers long-horizon household mobile manipulation. The primary coding-agent baseline is CaP-Agent0. It uses visual differencing, a predefined skill library, and per-episode test-time retries. The comparison also includes end-to-end vision-language-action policies: OpenVLA, π0, and π0.5.
On LIBERO-Pro, ASPIRE gains up to 77 points on the Object suite. That figure averages both perturbation axes over the strongest baseline. It also gains 41.5 points on Goal and 42.5 points on Spatial. On Robosuite, bimanual handover rises from 20% to 92%. On BEHAVIOR-1K, the radio pickup task rises from 56% to 88%.
The zero-shot result is notable. Reusing skills accumulated on LIBERO-90, ASPIRE reaches about 31% on held-out LIBERO-Pro Long tasks. Prior methods saturate near 4%.
| Dimension | End-to-end VLAs (OpenVLA, π0, π0.5) | CaP-Agent0 | ASPIRE |
|---|---|---|---|
| Paradigm | Learned-weight policy | Code-as-policy agent | Code-as-policy agent |
| Cross-task experience | None (frozen weights) | Discarded after each task | Distilled into a skill library |
| Failure feedback | None at test time | Coarse scene-level summaries | Per-primitive multimodal traces |
| Test-time strategy | Direct inference | Per-seed reasoning + retries | One program per task |
| LIBERO-Pro overall | 0–13% | 18% | 72% |
| LIBERO-Pro Long zero-shot | 0–5% | ~4% | ~31% |
Real-robot skill transfer
The research team tests three simulation-discovered skills on a real bimanual YAM station. The real-robot coding agent is OpenAI Codex GPT-5.5. The embodiment and API differ from simulation. Transferred skills reduce debugging cost. Soda-can lifting improved from 13/20 to 19/20 while using about 10x fewer tokens. Drawer opening moved from 0/20 to 11/20, where the no-skill baseline never succeeded.
Key Takeaways
- ASPIRE writes and debugs robot programs, then saves validated fixes as reusable in-context skills.
- Per-primitive multimodal traces let the agent localize failures instead of guessing from rollout outcomes.
- It gains up to 77 points on LIBERO-Pro and lifts Robosuite handover from 20% to 92%.
- Zero-shot transfer reaches about 31% on LIBERO-Pro Long, against about 4% for prior methods.
- Simulation-discovered skills reduced real-robot debugging cost across a different embodiment and API.