92%.

That's the success rate of Nvidia's newly open-sourced ASPIRE system on dual-arm object handover tasks. Before ASPIRE, methods based on the Code as Policy paradigm could only manage 20%. That 4.6x improvement didn't come from bigger models or more GPU training data -- it came from a mechanism that knows how to "take notes."

On July 1, Nvidia's robotics research lead Jim Fan announced ASPIRE's open-source release on X, putting it bluntly: "The paradigm has changed." When a robot completes its 100th task, it's finally no longer as clueless as it was on task number one -- a line that cuts straight to embodied AI's biggest pain point: starting from scratch every single time.

Robots Get a "Leveling System"

ASPIRE stands for Agentic Skill Programming through Iterative Robot Exploration. In plain English: let the Agent write robot skills through trial and error, all by itself. The core logic is identical to how Coding Agents work -- a programmer uses Cursor to write code, runs tests, checks errors, fixes bugs, and finally commits the working code; robots using ASPIRE do the same thing, except instead of reviewing a code repository, they're reviewing execution trajectories in the physical world.

It breaks down into three steps. Step one is the Execution Engine: every time the robot performs a task, the system fully records all inputs, outputs, and visual evidence -- perception results, navigation paths, grasping motions, collision detection, motion planning. Just like engineers debug robots by replaying video frame by frame to spot problems, ASPIRE automates this process.

Step two is Skill Distillation. After a failed task, the underlying GPT/Claude analyzes the multimodal trajectory like a senior researcher: was it a misrecognition? A weak grasp? Did the path planner hit an obstacle? Or did a recovery motion fail to chain properly? After identifying the problem, it modifies the control program and retests; if it passes, that verified fix is crystallized into a reusable Skill and added to the ever-growing skill library.

A concrete example: a robot tries to pick up a radio on the table. It correctly identifies the target, but the arm can't get close no matter what. ASPIRE analyzes and discovers the problem isn't visual recognition -- it's that the planner's target points all land inside the obstacle's collision buffer zone. So it distills a Skill: when planning fails, try approaching the target from different angles -- 45 degrees, 90 degrees, 180 degrees -- until a collision-free path is found. Once that experience enters the library, it can be called upon next time regardless of whether the target is a radio, a microwave, or a mug.

Step three is Evolutionary Search. The system doesn't hammer away at a single repair path; it generates multiple candidate control programs simultaneously, runs them in the execution environment, then iterates further based on survivors and failure trajectories. This is essentially porting the software engineering loop of "write code -> run tests -> inspect traces -> fix bugs" into the physical world.

Training Isn't About Refining Weights Anymore -- It's About Accumulating Skills

What makes ASPIRE truly radical is its redefinition of what "training" means.

For the past decade, deep learning has followed a single paradigm: collect data -> gradient descent -> update model weights -> deploy. Whether it's large language models or embodied AI VLA models, the output is tens or hundreds of gigabytes of floating-point weights. Open a weights file and you can't read a thing; it's nearly impossible to trace why a model made a particular decision; if you want to add a new capability, the safest bet is to collect new data, retrain, and fine-tune from scratch.

ASPIRE charts a different path: the product of training is no longer weights, but an interpretable, accumulable, transferable skill library. Training is no longer black-box gradient descent alchemy -- it's Skill Refinement, continuously polishing concrete skills one by one. Distributed training is no longer hundreds of GPUs synchronizing gradients; it's a swarm of Agents practicing different skills in different scenarios, then pooling their experiences into a shared skill library.

Behind this approach lies the maturation of the Code as Policy paradigm. Traditional VLA models have neural networks output motor actions directly, making behavior a complete black box. Code as Policy has LLMs write executable robot control programs that call perception modules, planning APIs, and control primitives. Code is white-box -- it can be inspected, modified, debugged, and versioned by Agents. That's the prerequisite that makes a Skill Library possible.

The generalization experiments in the paper tell the story. The research team built up the Skill Library on the LIBERO-90 task set, then directly transferred it to the never-before-seen LIBERO-Pro Long horizon tasks -- no additional training, no skill library updates. The results show that as the skill library grew richer, the robot's success rate on novel tasks climbed from near-zero to 31%. This means the thicker the Skill Library, the stronger the robot's transfer to new scenarios -- exactly how human engineers work: after tuning a hundred robots, you don't start from zero on the hundred-and-first; you pull from the "experience library" in your head.

Embodied AI's "App Store" Moment?

The timing of ASPIRE's open-source release is worth pondering.

Just last week, Hangmo Tech (spun out of Beihang University's Robotics Institute) closed a nearly 100 million RMB angel round for its intelligent variable-stiffness joint technology; Siyu Technology raised hundreds of millions across four rounds in six months for universal aerial agents; VAST closed a 1+ billion RMB Series A3 led by Giant Network, focusing on AI 3D foundation models and general world models. China's embodied AI funding shows zero signs of cooling.

On the chip side, Nvidia competitor Etched just hit a $5 billion valuation with $1 billion in AI chip orders already in hand. Embodied AI's appetite for compute is bottomless, but everyone in the industry agrees: compute alone won't produce usable robots. Nvidia open-sourcing ASPIRE now is less about charity and more about building the "developer ecosystem" for the embodied AI era.

Imagine: if the Skill Library model works, the future could bring an "App Store" for robot skills -- one company trains a Skill particularly good at opening drawers, another polishes a Skill for handling transparent glassware, and everyone can trade, combine, and reuse these skills instead of every company collecting data and training models from scratch. That's a far bigger vision than simply selling GPUs.

Of course, that vision is still some distance from reality. ASPIRE's experiments were conducted primarily in simulation, and Sim2Real transfer remains one of embodied AI's biggest roadblocks. The physical world is vastly more complex than simulation -- lighting changes, material differences, sensor noise, mechanical wear -- variables that code can never fully cover. But the direction is clear: make robots accumulate experience like human engineers in practice, rather than being reborn from scratch every time.

Endgame Assessment

What happened in AI coding over the past year is now repeating itself in embodied AI.

In 2025 everyone was competing on whose model completed code more accurately; by 2026, products like Cursor, Claude Code, and Devin are already running full engineering loops -- understanding requirements, writing code, running tests, reading errors, fixing bugs, submitting PRs. The core competitive advantage has shifted from "single-shot generation quality" to "closed-loop iteration capability."

Embodied AI is walking the same path. Whose VLA model scores higher on benchmarks is one thing; whether it can continuously learn, accumulate experience, and avoid repeating mistakes in real environments is quite another. ASPIRE's value lies in transforming robots from "newbies starting from zero every time" into "apprentices who take notes, review, and grow."

When Jim Fan says "the paradigm has changed," it's no exaggeration. When the goal of training shifts from producing a set of weights to depositing an accumulable skill library, when distributed training shifts from synchronized gradients to multi-Agent parallel exploration pooling experience, when a robot's improvement no longer relies on training bigger models but on a Skill Library growing thicker and thicker -- the rules of embodied AI are genuinely being rewritten.

That 92% dual-arm handover success rate is a beautiful number, but what's more worth remembering is the methodological shift behind it. After all, humanity went from artisan workshops to the Industrial Revolution not because any single generation was born smarter, but because each generation could stand on the shoulders of those before them -- the accumulation and transmission of knowledge and skills is the core of civilization's progress. Robots, finally, are starting to learn that too.