# Nvidia ASPIRE: How Robots Are Learning to Teach Themselves > Source: > Published: 2026-11-13 03:40:26+00:00 *Originally published on [agent5.news](https://agent5.news/blog/nvidia-aspire-how-robots-are-learning-to-teach-themselves?utm_source=devto&utm_medium=syndication).* 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. 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. 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. 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. 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. 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. 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. 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. 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. 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.