NVIDIA ASPIRE changes the dynamic as every debugging session becomes an opportunity to distill a reusable skill, so by the time a robot tackles its hundredth task, it is actively benefiting from what it learned on the first ninety-nine.
NVIDIA and a group of academic partners have rolled out ASPIRE, a self-learning robotics framework that turns robot control code into a growing skill library and delivers a sharp jump in success rates on difficult manipulation and long-horizon tasks. The system is designed to make robots learn more like software systems that improve over time, rather than disposable policies trained for a single benchmark.
NVIDIA ASPIRE pushes code-as-policy into continual learning
Agentic Skill Programming through Iterative Robot Exploration(ASPIRE), builds on the recent wave of code-as-policy systems that use language models to write robot control programs.
In typical setups, these agents generate executable code, run a task, see whether it passed or failed, and then throw away any fixes once the episode ends. That means valuable debugging experience never carries over to the next task.
NVIDIA ASPIRE changes that dynamic. Every debugging session becomes an opportunity to distill a reusable skill, so by the time a robot tackles its hundredth task, it is actively benefiting from what it learned on the first ninety-nine.
The framework is the result of a collaboration between NVIDIA and researchers at the University of Michigan, UIUC, UC Berkeley and CMU.
It fits neatly into NVIDIA’s broader push around “physical AI” and agentic workflows for real-world robots, where AI agents don’t just infer actions but also write, test and refine the very code that drives robot behavior. ASPIRE sits alongside platforms such as Isaac and GR00T, adding a skill-centric layer for continual improvement without discarding prior experience.
Inside the ASPIRE learning loop
At the heart of ASPIRE is an open-ended learning loop built around a coordinator–actor architecture. A central coordinator maintains the shared skill library and assigns coding agents to specific tasks, while individual actors focus on solving and debugging those tasks.
Instead of sharing raw trajectories or full prompts across tasks, actors contribute distilled skills that capture how particular failures were detected and fixed, keeping the library compact and focused on what actually transfers.
A closed-loop execution engine replaces coarse rollout feedback with detailed, per-primitive multimodal traces.
For each perception, planning and control call, the system logs inputs, outputs, status codes and visual signals such as RGB keyframes, overlays, grasp candidates, object poses and motion-planning outcomes.
When a task breaks down, the agent narrows its attention to the primitives involved in the failure, pinpoints whether the problem lies in perception, planning, grasping or contact, and then validates the proposed repair through re-execution. This trace-guided process gives the agent much finer-grained insight into what went wrong and why.
To avoid getting trapped in a loop of minor patches to the same flawed strategy, ASPIRE layers evolutionary search over candidate programs on top of this debugging workflow. In each round, it proposes multiple program variants informed by the best-performing prior programs and the remaining failure traces.
That encourages the system to explore genuinely different approaches rather than endlessly tweaking a single solution.
Skill library as compact in-context guidance
A key design decision in ASPIRE is to treat reusable knowledge as a collection of heterogeneous skills rather than full task programs. Each skill captures a recurring pattern of failure and repair.
It is stored as concise in-context guidance that includes a failure signature, a description of the conditions where the skill should apply, a repair strategy and often a partial code sketch that can be dropped into new programs when needed.
The coordinator only admits skills that pass debugging validation and conform to API and safety policies, ensuring that the library accumulates robust fixes instead of brittle patches.
These skills can represent localization heuristics, tailored perception prompts, grasping limits, motion primitives or even systematic debugging workflows. As the library grows, the agent gains access to a playbook of tested strategies that can be reused across different robots and environments.
One example from the research highlights how this works on the BEHAVIOR-1K benchmark. A robot is asked to pick up a radio near the edge of a table but repeatedly fails to reach a feasible pose because the motion planner reports a collision inside the table’s safety margin.
By inspecting the traces, ASPIRE identifies that the issue is not perception or grasping but target infeasibility.
The agent responds by writing a Multi-Angle Approach repair that samples standoff poses around the object at different angles until it finds a safe approach trajectory. That pattern is then encapsulated as a reusable navigation-recovery skill for future tasks with similar geometry or constraints.
Benchmarks show large gains over prior agents
ASPIRE is tested across three major benchmark families. LIBERO-Pro stresses robustness to changes in objects, goals and spatial layouts. Robosuite focuses on contact-heavy single-arm and dual-arm manipulation. BEHAVIOR-1K targets long-horizon household mobile manipulation, where robots must coordinate navigation and dexterous handling over extended sequences.
The main baseline is CaP-Agent0, a code-as-policy agent that relies on visual differencing, a fixed skill library and test-time retries. The team also compares ASPIRE with end-to-end vision-language-action policies such as OpenVLA and ?0.
On LIBERO-Pro, ASPIRE posts large gains. It adds up to 77 points on the Object suite over the strongest baseline, 41.5 points on the Goal suite and 42.5 points on the Spatial suite, pushing overall performance on LIBERO-Pro to roughly 72 percent, while the baselines remain between single digits and the high teens.
In Robosuite bimanual handover tasks, success rates rise from 20 percent to 92 percent. On BEHAVIOR-1K, the radio pickup task improves from 56 percent to 88 percent, underscoring gains in both fine-grained contact control and long-horizon coordination.
One of the most striking results comes from LIBERO-Pro Long, which tests zero-shot performance on held-out long-horizon tasks.
By reusing skills discovered on LIBERO-90, ASPIRE reaches around 31 percent zero-shot success, whereas prior methods plateau at about 4 percent. This gap suggests that the growing skill library, more than static model weights alone, is acting as a powerful memory for cross-task generalization in complex physical settings.
From simulation to real robots
ASPIRE is not limited to simulation. The researchers also run transfer experiments on a real bimanual YAM station, using OpenAI Codex GPT 5.5 as the coding agent and a hardware setup that differs in embodiment and APIs from the training environment.
Even under those changes, skills discovered in simulation help cut debugging costs. Soda-can lifting improves from 13 successes out of 20 trials to 19 out of 20, while token usage drops by about an order of magnitude. Drawer opening, a task that previously never succeeded, reaches 11 successes out of 20 when ASPIRE’s skills are brought over.
The framework enforces a practical rule about what information the coding agent can access. If a real robot with a camera could see a particular signal, the agent is allowed to use it.
If not, ground-truth simulator state and asset files are kept off limits. By grounding skill discovery in realistic sensory traces, ASPIRE improves the odds that behaviors learned in simulation will hold up when deployed on actual hardware.
To Learn More: CLICK HERE
