AI Models & Releases

Nvidia ASPIRE: How Robots Are Learning to Teach Themselves

By The Agent5 founder·November 13, 2026·How we fact-check

Nvidia's ASPIRE system gives robots a kind of institutional memory, letting them write their own control programs, learn from every failure, and bank those lessons for future tasks. It is one of the most significant shifts in how physical AI is trained.

ShareX LinkedIn WhatsApp

Key takeaways

ASPIRE gives robots a growing, reusable skill library by having a large language model write control code, observe failures, debug them, and save the validated fixes, so each new task benefits from every previous one.
The system uses three interlocking components: a closed-loop execution engine for detailed failure diagnosis, a continually expanding skill library for persistent memory, and an evolutionary search to keep exploration broad.
On the LIBERO-Pro Long zero-shot benchmark, ASPIRE reached 31 percent success on tasks it had never seen before, while prior methods plateaued at around 4 percent.
Skills are stored as readable code, not opaque weights, making them inspectable, editable, and transferable across different robot bodies and environments.
The framework is model-agnostic: swapping in a more capable language model directly improves robot performance without changing the system architecture.

Imagine hiring an employee who forgets everything the moment they finish a job. No notes, no habits, no muscle memory. That is roughly how most robot learning systems have worked until now: finish a task, discard the fix, and start the next one completely cold. Nvidia's ASPIRE system is designed to break that pattern. By letting a robot write its own control code, observe what goes wrong, repair the problem, and then save that repair as a reusable skill, ASPIRE gives robots something they have always lacked: a memory that actually compounds.

What ASPIRE Stands For and Where It Came From

ASPIRE stands for Agentic Skill Programming through Iterative Robot Exploration. It was introduced in a research paper posted to arXiv on June 30, 2026, by a multi-institution team from Nvidia, the University of Michigan, the University of Illinois Urbana-Champaign, UC Berkeley, and Carnegie Mellon University. The project lives inside Nvidia Research's Generalist Embodied Agent Research group, known as the GEAR lab, co-led by Jim Fan and Yuke Zhu.

Nvidia open-sourced the initial skill library in June 2026. A more complete release, labeled ASPIRE v1.0, followed on October 16, 2026, when Jim Fan announced on X that the full agentic robotics framework, including real-robot skill discovery and self-improvement capabilities, was now publicly available at github.com/nvlabs/aspire.

The Core Problem: Robots That Forget Everything

Traditional robot programming is notoriously difficult. It requires orchestrating multimodal perception, managing complex physical contact dynamics, and handling diverse environment configurations and execution failures. Most existing approaches either hard-code fixed pipelines, which break whenever the environment changes slightly, or use deep learning to bake knowledge into neural-network weights, which are opaque and expensive to update.

Most robot coding agents compound the problem by throwing away everything they learn. After solving a task, the fix is discarded and the agent starts the next task with no advantage. As Jim Fan put it, with legacy approaches, the robot on its hundredth task is no smarter than it was on its first.

ASPIRE draws a clean architectural line between that pattern and a system whose experience genuinely accumulates.

Code as Policy: Writing Programs Instead of Moving Joints

At the core of ASPIRE is a paradigm called code as policy. Instead of outputting low-level joint commands directly, as an end-to-end vision-language-action model would, a large language model generates executable Python robot control programs that orchestrate perception, planning, and control APIs.

This is a meaningful design choice. Code is readable, debuggable, and transferable. When a program fails, the reason is often identifiable. When a fix is verified, it can be written down in plain language and retrieved later. Code-based skills also move across different robot bodies and different simulation environments in a way that neural-network weights generally do not.

The Three-Part Learning Loop

ASPIRE runs continuously through an open-ended learning loop built from three interconnected components.

The robot execution engine is the perceptual backbone of the loop. Rather than giving the system only a coarse signal like "task succeeded" or "task failed," the engine exposes fine-grained multimodal traces at every step. These traces include things like perception overlays, grasp candidates, object poses, and motion trajectories. This granularity matters because it lets the system pinpoint exactly which part of a multi-step task went wrong, rather than simply knowing that something failed somewhere.

The skill library is the memory layer. When the system successfully debugs a problem, it does not just move on. It distills the validated fix into a named, reusable skill and adds it to the library. The skill entry captures not just the repair itself but also a description of when to apply it, so future coding agents can recognize a similar situation and reach for the right tool. Crucially, only distilled skills move between agents in the system, not full chat histories or raw trajectory logs, keeping the library compact and transferable.

The evolutionary search procedure is what prevents the system from getting stuck in a single line of thinking. Rather than refining one program until it barely works, the evolutionary search generates multiple diverse candidate programs in parallel, runs them, identifies which candidates perform best, and then conditions the next generation of candidates on those survivors plus whatever failure traces remain. This keeps the exploration broad and reduces the chance that the robot locks onto a brittle local solution.

Together, these three components define what ASPIRE's researchers call an open-ended learning loop, one in which the agent itself decides where to focus next.

Coordinator, Actor, and the Skill That Travels

ASPIRE's architecture separates responsibility cleanly. A central coordinator manages the shared skill library and dispatches multiple actor coding agents to different tasks simultaneously. The actors work in parallel, each accumulating experience, but they do not share raw outputs with one another. Only verified, distilled skills travel back to the coordinator and from there into the shared library.

This design mirrors how a well-run engineering team actually operates. Individual engineers work on separate problems, but when one of them figures out a reusable pattern, they write it into the shared documentation so everyone benefits. The result is that the library grows continuously across tasks, and each new robot that draws from it starts from a much stronger baseline than its predecessors.

Nvidia's Jim Fan described this as a fundamental shift in what robot training produces. The output is no longer a fixed set of opaque neural-network weights, but a continuously expanding sensorimotor skills library that reads more like a robotics programmer's accumulated lesson notes than a black-box model checkpoint.

Simulation to Reality: Skills That Cross the Gap

One of the most practically significant claims in the ASPIRE research is that skills discovered in simulation can transfer to real physical robots, even when the hardware embodiment and the programming interface are different. This sim-to-real transfer has historically been one of the hardest problems in robotics because simulators do not perfectly replicate the physics, friction, and sensor noise of the real world.

In ASPIRE's case, the transfer works because the skills are expressed as code patterns and repair strategies rather than as learned motor primitives tuned to a particular simulated physics engine. When simulation-discovered skills were provided to a real bimanual robot as in-context guidance, they substantially reduced the amount of debugging effort required on physical hardware, even though the embodiment and the robot API differed from those used in simulation. The researchers describe this transfer as preliminary but structurally promising.

What the Benchmarks Show

The paper evaluated ASPIRE across three benchmark families. On LIBERO-Pro, a manipulation benchmark that applies perturbations to object positions, task goals, and spatial arrangements, ASPIRE surpassed prior methods by up to 77 percent on the Object suite of tasks. On Robosuite's bimanual handover task, success climbed from 20 percent to 92 percent. On BEHAVIOR-1K long-horizon household tasks, ASPIRE improved results by up to 32 percent.

The most striking single result is on zero-shot transfer. After accumulating a skill library on LIBERO-90 (a set of 90 manipulation tasks), the system was tested on LIBERO-Pro Long, a set of longer-horizon tasks it had never seen. ASPIRE reached 31 percent success on those unseen tasks. Prior methods, even when allowed to use test-time reasoning and retries, saturated at around 4 percent.

The component ablation makes the architecture's value concrete. Without either the execution engine or the evolutionary search, macro-average LIBERO-Pro success sits at 14 percent. Adding the dense trace-and-validation engine raises it to 62 percent. Adding evolutionary search on top brings it to 72 percent. Each component carries its own weight.

Following the October 2026 open-source release, when the GEAR lab swapped the backend language model to a newer frontier model, benchmark scores on LIBERO-Pro reached approximately 99 percent, illustrating how the ASPIRE framework is model-agnostic: a better underlying language model flows directly into better robot performance without requiring any structural change to the system.

Why This Is a Genuine Paradigm Shift

The standard framing for robot learning has been gradient descent: train a model on data, adjust millions of weights, and deploy. The process is expensive, opaque, and static. ASPIRE replaces that framing with something closer to iterative software engineering. Training becomes skill refinement. The output is not a frozen model but a living, growing library of tested code patterns. And distributed training becomes multiple autonomous agents practicing different skills and contributing their local insights into a central repository.

This shift has practical implications beyond benchmark scores. Skills stored as readable code can be inspected, edited, and explained in ways that neural-network weights cannot. When a robot fails at a task in a real deployment, an engineer can open the skill library and read exactly what strategy was tried and where it broke. That transparency is valuable in ways that do not show up in any accuracy table.

The approach also sidesteps one of the biggest bottlenecks in physical AI development: the need for massive curated datasets of human demonstrations. ASPIRE generates its own training signal by executing programs, observing results, and diagnosing failures, requiring no labeled human rollouts for the skills it discovers.

What to Watch Next

Several concrete developments are worth tracking in the months ahead.

The ASPIRE codebase at github.com/nvlabs/aspire is live and actively evolving. Watch for community-contributed skill libraries and reports from teams applying ASPIRE to robot hardware outside of Nvidia's labs, which will provide the independent replication the field needs before drawing broad conclusions.

The paper tested sim-to-real transfer on a bimanual robot with a different embodiment and API from the simulation environment, and the team described this as a promising but preliminary result. Further real-robot work across a wider variety of hardware will be necessary to understand how well the transfer generalizes.

ASPIRE is model-agnostic, which means its performance is partly a function of whatever large language model sits at its core. The GEAR lab's experience swapping models overnight and seeing benchmark scores change dramatically suggests that frontier language model releases will have an almost immediate impact on what ASPIRE-style systems can do physically. Each new generation of capable language model is worth re-evaluating in the context of this framework.

Finally, the LIBERO-Pro Long benchmark results, while impressive, represent a narrow slice of the tasks robots need to perform in unstructured real-world environments. Watch for evaluations on tasks involving greater physical contact variability, unstructured scenes, and language instructions that have not been seen in any structured benchmark, as these will determine whether ASPIRE's compounding-skill approach holds up outside of controlled laboratory settings.

Sources

Frequently asked questions

ASPIRE stands for Agentic Skill Programming through Iterative Robot Exploration. It is a continual learning system developed by Nvidia's GEAR lab, in collaboration with researchers from the University of Michigan, UIUC, UC Berkeley, and Carnegie Mellon, that enables robots to write, test, and refine their own control programs.

Traditional robot learning encodes knowledge into neural-network weights through gradient descent, producing a fixed, opaque model. ASPIRE instead has a large language model write executable code programs, then learns from each failure by distilling verified fixes into a readable, growing skill library. The output is a living library of reusable strategies rather than a frozen model checkpoint.

ASPIRE's skill library is a persistent, text-based repository of verified robot control strategies. Each entry captures a debugging fix, when to apply it, and what failure it addresses. When a new task arises, coding agents can retrieve relevant entries from the library and use them as starting points, so the robot is not starting from scratch every time.

Evolutionary search is a component that generates multiple diverse candidate control programs in parallel, tests them, identifies the strongest performers, and uses them, along with the remaining failure traces, to generate the next round of candidates. This prevents the system from converging on a single brittle solution and is responsible for a substantial portion of ASPIRE's performance gains in ablation experiments.

The research shows that skills discovered in simulation can transfer to a real bimanual robot, even when the hardware embodiment and programming interface differ from those in the simulator. The transfer works because skills are expressed as code patterns and repair strategies rather than as physics-specific motor primitives. The researchers describe the result as promising but preliminary.

Yes. Nvidia open-sourced the ASPIRE skill library in June 2026 and released ASPIRE v1.0, including full real-robot skill discovery and self-improvement capabilities, on October 16, 2026. The codebase is available at github.com/nvlabs/aspire.