NVIDIA's GEAR lab open-sources ASPIRE v1.0, where coding agents teach robots to solve a Rubik's Cube

What NVIDIA's GEAR lab released

NVIDIA's Generalist Embodied Agent Research lab, GEAR, published version 1.0 of ASPIRE in its NVlabs/ASPIRE GitHub repository on 15 October 2026, and lab co-lead Jim Fan promoted the release the next day. ASPIRE, short for Agentic Skill Programming through Iterative Robot Exploration, is a framework in which a coding agent such as Claude Code or Codex writes Python programs that control a robot, watches what goes wrong, and fixes them. The code is released under the Apache License 2.0.

The project is not brand new. The original paper was submitted to arXiv on 30 June 2026 with authors from NVIDIA, the University of Michigan, UIUC, UC Berkeley and Carnegie Mellon, and a first public code release followed on 21 August. What v1.0 adds, according to the repository's news entry, is a working real-robot pipeline that can solve a physical Rubik's Cube, and 99% success on 80 LIBERO-Pro Goal, Object, Spatial and Long tasks plus selected Robosuite and BEHAVIOR-1K tasks.

The release ships agent skills for both Claude Code and Codex, runbooks for reproducing the paper's experiments, and operator guides for four real-robot demonstrations on a two-arm YAM station.

Code instead of weights: how ASPIRE learns

The README sums up the idea in three lines. Training is skill refinement instead of gradient descent. The trained model is a repository of sensorimotor skills instead of floating-point weights. Distributed training is a panel of agents each practising a different skill instead of sharded minibatches.

In practice, the project page describes three parts. A closed-loop execution engine records every perception, planning, grasping and control call, with its inputs, outputs and visual evidence such as perception overlays, grasp candidates and collision feedback. The agent reads those traces to find where a run failed, rewrites the program, and re-executes it to confirm the fix.

Validated fixes go into a growing skill library, stored as text the agent can retrieve as guidance on later tasks. An evolutionary search then generates many varied task sequences and programs in parallel, so the system is not stuck improving one attempt. This is the code-as-policy approach: the robot's behaviour is a readable program built on a fixed set of perception and motion primitives, not a neural policy trained from demonstrations.

The paper reports that this beat earlier methods by up to 77% on LIBERO-Pro manipulation under perturbation, 72% on Robosuite's bimanual handover task and up to 32% on long-horizon BEHAVIOR-1K household tasks. On unseen long-horizon LIBERO-Pro tasks, reusing the skill library gave 31% success without any task-specific debugging, against 4% for the CaP-Agent0 baseline, which regenerates a program for every attempt.

The Rubik's Cube and other real-robot tasks

The headline demonstration of v1.0 is a Rubik's Cube solved on real hardware by two robot arms with soft grippers, with GPT-6 Astra as the coding agent. The repository's System 2 operator runbook explains that the agent works through the station's live cameras and low-level motion tools over the Model Context Protocol. It has to reconstruct all six faces of a scrambled cube, compute a solution, hold two layers still while turning the third, and finally confirm that every face is uniform and the cube rests stably on the table.

The packaged task notes are blunt about what counts as success. A solver's move list or a smooth robot motion does not establish the outcome; only a verified solved cube does. They also warn that the soft gripper tips give limited support, so grasps have to be re-grounded after any hardware change.

Three other real-robot recipes ship with the release: unscrewing a bottle cap and pouring out a pill, putting a pill in a bottle and closing it, and nesting cups upside down. The README notes that these three recipes were distilled from demonstration sessions and are not a new round of real-robot validation, and that the pill recipe separates a seated cap from a verified tight one. An earlier demo, long-horizon table bussing, used skills learned in simulation with Claude Opus 4.6 and transferred them to a real robot driven by GPT-5.5. The project page says reusing simulation-discovered skills let the agent reach its first real-world success with fewer tokens and produced code with a higher held-out success rate.

How much the coding model matters

ASPIRE's results depend heavily on which model writes the code. Holding the environment, robot API and evaluation fixed, the team ran the same 10 LIBERO-Pro tasks with a dozen coding models. Success ranged from 15% with GPT-6 Luna at $0.83 per task to 99% with Claude Opus 5.5 at $18 per task, according to the chart in the repository.

The chart also shows that the most expensive model is not the best value. Claude Sonnet 5.5 reached 99% at about $12 per task, GPT-6.1 Sol 88% at $10, and Claude Opus 5 91% at $60. Open-weight models such as Kimi K3 and Qwen 3.8 Max were tested too and sit well below the cost-success frontier. The README says that with Claude Opus 5.5, ASPIRE reaches 97% to 100% success on every task it reports across LIBERO-Pro, Robosuite and BEHAVIOR-1K.

Those figures come from NVIDIA's own evaluation on held-out seeds, with programs learned on a small debug split. Independent groups have not yet published reproductions of the v1.0 numbers.

How to run it, and the safety warnings

Getting started is itself an agent task. The README gives a prompt to paste into Claude Code or Codex: clone the repository, read the iterative-debugging skill and the LIBERO-Pro guide, and run the quick start for ten goal-swap tasks. The prompt tells the agent to report the GPUs, credentials, gated weights, services and expected runtime it needs, and to wait for confirmation before launching. The host needs CUDA, the uv package manager and a Hugging Face token for the gated SAM 3 segmentation weights.

The project carries an unusually direct warning. ASPIRE executes language-model-generated Python with full import access, and its trial processes and watchdogs are not a security sandbox. The team says to run generated code on an isolated host without credentials or sensitive mounts, to restrict network access, and never to give a simulation agent access to physical hardware. Real-robot work requires separate operator authorisation and its own set of controls, and the quick-start prompt explicitly tells the agent not to read the real-robot instructions.

Limitations the team lists

The project page lists five limitations. ASPIRE is not yet a fully autonomous real-world learner, because deployment still needs reliable success detection, safe resets, safety monitoring and calibration. It depends on a frozen frontier language model, and the original work did not verify that smaller models can sustain the debugging loop; the v1.0 scaling chart suggests the weakest models struggle.

It is also bounded by a predefined primitive API. That fixed set of perception, planning and control functions keeps debugging safe but limits what behaviour the agent can express. Long-term memory is unsolved, since library entries can become stale, overly specific, redundant or misleading as the library grows. And the search loop is compute-hungry, needing many model calls and rollouts per task, so scaling it will require cheaper inference or more sample-efficient search.

Why it matters for robot learning

Most recent robot-learning releases are trained policies. Physical Intelligence opened its π models to outside developers, and NVIDIA's own Long-WAM keeps 19.2 seconds of camera history inside a policy network. ASPIRE takes the other route: the robot's know-how lives in readable code and text skills that a person can inspect, edit and share.

It also fits the wider pattern of agents improving a system through a strict evaluator, seen this week in Claude Mythos 5's quantum-circuit search and in earlier work such as RoboRSI's top-down skill refinement. The open questions are practical: whether outside labs can reproduce the Rubik's Cube result on their own stations, how quickly the skill library degrades as it grows, and whether per-task API costs fall far enough for ASPIRE to compete with trained policies outside the lab.