🤖 AI

ASPIRE: Agentic /Skills Discovery for Robotics

ASPIRE is a continual learning system that autonomously writes and refines robot control programs through an iterative loop of execution, failure diagnosis, and evolutionary search, resulting in a reusable skill library that significantly outperforms prior methods in perturbed, bimanual, and long-horizon tasks while enabling zero-shot generalization and sim-to-real transfer.

Original authors: Runyu Lu, Yubo Wu, Ethan Kou, Letian Fu, Wenli Xiao, Ajay Mandlekar, Yinzhen Xu, Guanya Shi, Ken Goldberg, Ang Chen, Mosharaf Chowdhury, Yuke Zhu, Linxi "Jim" Fan, Guanzhi Wang

Published 2026-07-02

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Runyu Lu, Yubo Wu, Ethan Kou, Letian Fu, Wenli Xiao, Ajay Mandlekar, Yinzhen Xu, Guanya Shi, Ken Goldberg, Ang Chen, Mosharaf Chowdhury, Yuke Zhu, Linxi "Jim" Fan, Guanzhi Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Idea: Teaching Robots to "Learn from Their Mistakes" Like a Human

Imagine you are teaching a very smart, but very literal, robot how to cook dinner.

The Old Way: You write a strict recipe (code). If the robot drops a spoon, it stops, you have to manually rewrite the recipe, and then try again. If the spoon was slippery, you have to rewrite the recipe for every future time it uses a spoon. The robot forgets everything once the job is done.
The ASPIRE Way: The robot tries to cook. When it drops the spoon, it doesn't just stop. It looks at exactly why it dropped it (was the handle slippery? Did it grab too hard?). It fixes the recipe immediately. Then, it writes down a "Pro Tip" in a shared notebook: "When holding slippery spoons, grip tighter and lift slowly." Next time it cooks, or even when a different robot tries to cook, it checks the notebook first.

ASPIRE (Agentic Skill Programming through Iterative Robot Exploration) is a system that lets robots write their own code, debug their own failures, and build a permanent "library of tricks" that makes them smarter every single day.

How It Works: The Three Magic Tools

The paper describes ASPIRE as a team of three workers working together in a loop:

1. The "Super-Debugger" (Robot Execution Engine)

Most robots only tell you: "I failed." They don't tell you why.
ASPIRE's engine is like a high-tech security camera that records every tiny move the robot makes.

The Analogy: Imagine you are trying to park a car in a tight spot. A normal robot just says, "Crash!" ASPIRE's engine shows you the video: "You turned the wheel too early, and the back bumper hit the wall."
What it does: It gives the robot a "trace" (a detailed log) of exactly where the perception failed, where the plan went wrong, or where the arm got stuck. This allows the robot to diagnose the problem itself rather than guessing.

2. The "Shared Notebook" (Skill Library)

In the past, if a robot learned how to open a specific drawer, that knowledge died when the task was over.
ASPIRE keeps a growing library of "Skills."

The Analogy: Think of this like a cookbook of "Life Hacks."
- Entry 1: "If the robot can't reach the object because a table is in the way, try approaching from the side instead of straight on."
- Entry 2: "If the robot sees two bowls, look at the one on the left first."
What it does: When the robot fixes a bug, it doesn't just save the fix; it saves the pattern. If it encounters a similar problem later (even with a different robot or a different object), it pulls the "Life Hack" from the notebook and uses it immediately. This is how it gets faster and better over time.

3. The "Brainstorming Session" (Evolutionary Search)

Sometimes, a robot gets stuck in a loop, trying the same bad idea over and over.
ASPIRE uses a method called "Evolutionary Search."

The Analogy: Imagine you are trying to fix a leaky pipe. Instead of just tightening the bolt once, you try 10 different wrenches, 5 different angles, and 3 different types of tape all at the same time. You see which one works best, keep that one, and then try to improve that one.
What it does: The system generates many different versions of the robot's code at once. It tests them all, keeps the winners, and discards the losers. This helps the robot escape "local loops" and find creative solutions a human might not think of.

What They Actually Achieved (The Results)

The paper tested this system on three types of challenges, and the results were impressive:

The "Messy Kitchen" Test (LIBERO-Pro):
- Scenario: The robot had to move objects, but the objects were moved to random spots, or the instructions were slightly changed (e.g., "pick up the red cup" vs. "pick up the blue cup").
- Result: ASPIRE succeeded 77% more often than previous methods. It didn't just memorize the spot; it learned the skill of finding and grabbing things regardless of where they were.
The "Two-Armed Handoff" (Robosuite):
- Scenario: A robot with two arms had to pass an object from one hand to the other. This is incredibly hard because timing and physics are tricky.
- Result: Previous methods succeeded only 20% of the time. ASPIRE jumped to 92%. It learned the "dance" of passing the object by trial and error.
The "Long Day at Home" (BEHAVIOR-1K):
- Scenario: The robot had to do a long chain of tasks, like "Go to the kitchen, find a soda, open the fridge, put it in."
- Result: ASPIRE was 32% better than the next best method. Because it had a library of skills, it didn't have to re-learn how to open a fridge every time; it just looked up the "Open Fridge" skill.

The "Magic" Transfer: From Simulation to Real Life

One of the coolest parts of the paper is Sim-to-Real Transfer.

The Setup: The robot learned all its skills in a video game (simulation). Then, they put it on a real physical robot that looked different and had different sensors.
The Result: Even though the real robot was different, the "Life Hacks" from the simulation still worked.
- Example: The robot learned in the game that "if you try to push a drawer straight on, it jams." It applied this same logic to the real drawer.
- Impact: This reduced the amount of "thinking" (computer processing) the real robot needed to do by nearly 10 times for some tasks. It proved that skills learned in a virtual world can help a real robot in the real world.

Summary

ASPIRE is a system that stops robots from being "dumb repeaters" and turns them into "continuous learners."

It gives them eyes to see exactly why they failed (Execution Engine).
It gives them a memory to save their fixes for later (Skill Library).
It gives them a brain to try many solutions at once (Evolutionary Search).

The paper claims that by doing this, robots can solve complex, messy tasks much faster than before, and the knowledge they gain in one situation helps them succeed in completely new situations.

Technical Summary: ASPIRE – Agentic Skills Discovery for Robotics

1. Problem Statement

Traditional robot programming is inherently difficult, requiring the orchestration of multimodal perception, complex physical contact dynamics, and robust handling of diverse environment configurations and execution failures. While recent advances in software engineering agents have demonstrated that Large Language Models (LLMs) can autonomously inspect execution traces, localize failures, and revise code, existing robotic coding agents remain fundamentally limited.

Current limitations include:

Coarse Feedback: Existing systems often rely on naive execution environments that provide only high-level task-level feedback (success/failure). This lacks the fine-grained diagnostic traces necessary to distinguish between root causes such as incorrect perception, unstable grasps, planning errors, or downstream recovery failures.
Lack of Accumulation: Once a task is completed, discovered fixes and recovery strategies are typically discarded. Agents solving their hundredth task possess no more experience than those solving their first, failing to compound knowledge into reusable skills.
Local Optimization: Debugging often collapses into local repair loops where agents repeatedly patch the same failed strategy rather than exploring fundamentally different solution spaces.

2. Methodology

The authors introduce ASPIRE (Agentic Skill Programming through Iterative Robot Exploration), a continual learning system that autonomously writes and refines robot control programs within a "code-as-policy" paradigm. ASPIRE operates in an open-ended learning loop comprising three core components:

A. Closed-Loop Robot Execution Engine

Unlike fixed interfaces providing coarse summaries, ASPIRE's execution engine exposes per-primitive multimodal traces. For every perception, planning, grasping, and control call, the engine records:

Invoked APIs, inputs, outputs, and return statuses.
Relevant multimodal evidence (RGB keyframes, overlays, grasp candidates, object poses, motion-planning results).
Visual evidence immediately before and after primitive calls.

This granularity allows the agent to selectively inspect logs, localize failures to specific primitives (e.g., identifying that a navigate_to_pose call failed due to a collision buffer violation rather than perception), and validate repairs through re-execution.

B. Continually Expanding Skill Library

ASPIRE accumulates experience by distilling validated fixes into a reusable skill library.

Content: The library stores heterogeneous repair knowledge, including localization heuristics, perception prompts, grasping constraints, navigation recovery strategies, motion primitives, and debugging workflows.
Admission: A central coordinator audits agent-reported findings. Only patterns that are validated as reusable and transferable (rather than task-specific overfits) are admitted.
Usage: Future agents retrieve these skills as in-context guidance, allowing them to apply previously discovered recovery patterns (e.g., "Multi-Angle Approach" for navigation failures near obstacles) without rediscovering them via test-time reasoning.

C. Evolutionary Search

To prevent agents from getting stuck in local repair loops, ASPIRE employs an evolutionary search procedure.

Process: The agent proposes a population of $K$ candidate programs conditioned on top-performing previous programs and failure traces.
Iteration: Candidates are executed in the engine, and the next generation is conditioned on the best performers and their remaining failure modes.
Goal: This encourages diverse repair hypotheses and task strategies, exploring beyond single-trajectory self-improvement.

Architecture: The system uses a Coordinator–Actor architecture. A central coordinator manages the shared skill library and dispatches actor coding agents to individual tasks. Actors work in parallel, refining programs within the execution engine, while the coordinator serializes skill admission to ensure consistency.

3. Key Contributions

Open-Ended Learning Loop: ASPIRE establishes a self-improving robotic system where performance scales with experience. It moves beyond fixed pipelines to a dynamic loop of self-diagnosis, repair, and knowledge consolidation.
Fine-Grained Trace Exposure: The system replaces coarse feedback with per-primitive multimodal traces, enabling agents to autonomously diagnose root causes (e.g., distinguishing between perception failure and planning infeasibility).
Reusable Skill Library: The paper demonstrates a mechanism for accumulating validated repair patterns into a transferable knowledge base that supports zero-shot generalization to unseen tasks and embodiments.
Evolutionary Exploration: The integration of evolutionary search allows the system to explore diverse solution spaces, avoiding local minima common in iterative debugging.

4. Experimental Results

ASPIRE was evaluated across three benchmark families, comparing against prior coding agents (CaP-Agent0) and end-to-end Vision-Language-Action (VLA) policies (OpenVLA, $\pi_0$ , $\pi_{0.5}$ ).

LIBERO-Pro (Short-Horizon Robustness): ASPIRE improved success rates by up to 77% on perturbation suites (Object, Goal, Spatial) compared to the strongest baseline.
Robosuite (Contact-Rich Manipulation): On bimanual handover tasks, ASPIRE improved success from 20% to 92%, a 72% gain over baselines.
BEHAVIOR-1K (Long-Horizon Household Tasks): ASPIRE outperformed both human experts and baselines on navigation and task success, achieving an 88% success rate on "navigate-and-pick-up-radio" (up from 56% for baselines).
Zero-Shot Generalization: Using a skill library accumulated on LIBERO-90, ASPIRE achieved 31% success on held-out long-horizon tasks (LIBERO-Pro Long), substantially outperforming prior methods which saturated at 4%, despite those methods relying heavily on test-time reasoning and retries.
Sim-to-Real Transfer: In experiments with a real bimanual robot, retrieving simulation-discovered skills as in-context guidance significantly reduced debugging costs (token usage) and enabled successful programs where naive debugging failed. For example, "Lift soda can" success improved from 13/20 to 19/20, and total token usage dropped by nearly an order of magnitude.

5. Significance and Claims

The paper claims that ASPIRE represents a significant step toward autonomous, lifelong robot learning. Its primary significance lies in:

Scalability: The system demonstrates that performance scales with the number of tasks encountered, as the growing skill library enables increasingly rapid adaptation to new challenges.
Generalization: The ability to transfer skills discovered in simulation to real-world robots with different embodiments and APIs suggests a pathway to reducing the high cost of real-robot programming.
Paradigm Shift: By treating robot programming as an iterative, self-correcting process similar to software engineering, ASPIRE bridges the gap between high-level language models and low-level physical control, moving beyond static policies to dynamic, experience-driven code generation.

The authors acknowledge limitations, noting that the system currently relies on a frozen frontier LLM, requires predefined APIs, and needs further work on robust real-world success detection and memory management (pruning stale skills) to scale to very large task suites. However, the results provide initial evidence that agentic skill discovery can substantially reduce the effort required to program robots for complex, long-horizon tasks.