ReSkill: Selective Self-Improvement for Robot Manipulation

Zheng Sun, Zhihao Li, Zhuo Li, Wenrui Liu, Xin Wang, Fei ChenarXiv 2026 · arXiv

TL;DR

ReSkill is a framework that allows robots to "self-improve" by surgically identifying and fixing specific capability gaps in complex, multi-step tasks. Instead of retraining a massive neural network or relying on expensive Large Language Model (LLM) calls during execution, ReSkill uses a coding agent during development to refine a library of reusable, code-based skills and task logic, resulting in fast, robust, and independently executable robot policies.

What Problem Does This Paper Address?

When a robot fails at a complex task—like tidying a desk or storing tools—it rarely fails at everything. Usually, it can grasp and move objects just fine but might struggle with a specific "capability gap," such as seating a tilted tool correctly into a tight slot.

Current approaches to this problem fall into two camps:

  1. End-to-end learning: Retraining the entire policy. This is data-hungry, computationally expensive, and makes it nearly impossible to debug why a specific sub-task failed.
  2. Agent-as-Policy: Using an LLM to decide every move in real-time. While flexible, this is slow (high latency), expensive (API costs), and doesn't result in a permanent, "learned" skill the robot can reuse without the agent's help.

ReSkill asks: How can a robot locate exactly where it’s failing, fix only that part, and retain that improvement for future tasks?

Figure 1: What should a robot improve for a new manipulation task? The tool-storage example isolates a missing tilt-aware seating skill. End-to-end adaptation retrains a task policy, while an Agent-as-Policy handles the current episode through repeated model calls. ReSkill revises the task graph and local skills during development, validates the changes, and retains reusable skills and an executable policy requiring no run-time Agent calls.

Methods

ReSkill treats robot manipulation as a software engineering problem. It represents a task as an object-centric task graph, where nodes are specific skills (e.g., "Locate," "Grasp," "Place") with defined entry and exit conditions.

The framework operates in a development loop:

  • Task Construction: A coding agent (using Claude 3.5 Opus) generates an initial task graph and binds nodes to skills from a library.
  • Dual-Level Improvement: When the robot fails in simulation, the agent analyzes execution records to find the "earliest node that deviates." It then performs Task-level revisions (reorganizing the graph or recovery routes) or Skill-level revisions (editing the Python code for perception, motion, or verification).
  • Rigorous Selection: Revisions aren't adopted blindly. They must pass a multi-stage evaluation, including paired comparisons on hidden "test layouts" to ensure the fix is robust and not just "overfitting" to a single scenario.
  • Deployment: Once validated, the policy is "frozen." The final program runs locally with zero runtime LLM calls, eliminating latency and cost.
Figure 2: ReSkill constructs and improves an executable task policy. An instruction and a skill library define a task graph and its node–skill bindings. Trial execution exposes planning or skill gaps, prompting task-level graph revision and skill-level implementation changes. Paired evaluation determines which candidates are retained, updates the skill library, and yields a frozen executable policy with no run-time Agent calls. The bottom row shows original simulation examples of perception, motion, manipulation, and verification skills.

Datasets

The authors evaluated ReSkill on two main fronts:

  • RoboDojo: A benchmark of 10 diverse simulation tasks (stacking, classification, tool storage) in Isaac Sim.
  • Real-World Tasks: 8 tasks (e.g., drawer opening, bimanual sorting) performed on an Xtrainer robot platform.
  • Real-to-Sim-to-Real: For real-world tasks, the authors used a single teleoperated demonstration to rebuild the scene in the MuJoCo simulator, where the ReSkill development loop took place before deploying the final code back to the physical robot.

Key Insights and Ideas

  • Revision Locality: One of the most striking findings is that improvements are incredibly "local." The median revision changed only three functions—roughly 0.5% of the total program code. You don't need a new brain; you often just need a better verification check.
  • The Power of Verification: Many failures aren't due to bad movement, but bad "judgment." In the tool-storage task, success skyrocketed once the agent added a "tilt-aware" verification skill that checked if a tool was lying flat and pressed it down if it wasn't.
  • Skill Accumulation: As the robot learns more tasks, it gets faster. For later-added tasks, 39% of the code was reused verbatim from previous tasks. This suggests a path toward a "foundation library" of programmatic robot skills.
  • Failure Evolution: During development, the type of failures shifts. Early on, robots fail at basic perception or grasping; later, failures move toward subtle "hand-off" errors between stages, which ReSkill handles by refining the task graph's logic.

Key Results

  • Simulation Success: On RoboDojo tasks, average success rose from 30.0% (initial versions) to 86.2% for final programs.
  • Real-World Performance: ReSkill achieved a 77.5% success rate across 80 real-robot trials.
  • Efficiency: Compared to "Agent-as-Policy" methods, ReSkill has zero runtime API cost and significantly lower latency, as the LLM is only used during the "offline" development phase.
  • Robustness: Retained programs maintained an 83.6% success rate even when tested on novel layouts not seen during the revision process.

Limitations and Future Work

  • Perception Stability: ReSkill relies on stable geometric estimates (like object poses). If the underlying perception (e.g., SAM 3 segmentation) is noisy or fails due to occlusions, the downstream skills struggle.
  • Long-Sequence Challenges: In very long tasks (like "Table Organization"), errors can still accumulate. The authors note that high-precision contact and extremely long sequences are the hardest to cover with rule-based loops.
  • Real-Robot Development: Currently, the "self-improvement" loop happens mostly in simulation. A major future goal is to move this entire diagnostic and revision process onto physical hardware, which would require solving challenges like automatic resets and real-world success detection.

Summary updated

Abstract

Self-improvement on compositional manipulation tasks requires deciding what to reuse, where to improve, and which changes to retain. We present ReSkill, a selective self-improvement framework that concentrates revision on capability gaps. A coding agent constructs an object-centric task graph from an instruction and a skill library, then uses node-level execution records to locate failures. At the task level, it revises stage organization, hand-off conditions, and recovery routes; at the skill level, it strengthens perception, motion, manipulation, and verification capabilities that repeatedly fail. Candidate revisions undergo full-task evaluation and paired comparisons before adoption, allowing local changes to accumulate into validated skills and an independently executable policy. The agent participates only during development; the deployed policy calls the retained skills without invoking the agent at run time. On the same development set, average success across ten RoboDojo tasks rises from 30.0% for the initial versions to 86.2% for the final adopted programs; retained programs achieve 83.6% in recorded robustness and model-selection evaluations. Across eight real-world tasks, ReSkill succeeds in 72 of 80 rebuilt-simulation trials and 62 of 80 real-robot trials (77.5%). The median revision changes only three functions, approximately 0.5% of a program, while 39% of task-specific functions in later-added tasks directly reuse existing implementations. These results show how locating local deficiencies, validating candidate changes, and accumulating reusable skills can improve execution of compositional manipulation tasks.
BibTeX
@misc{sun2026reskill,
  author = {Zheng Sun and Zhihao Li and Zhuo Li and Wenrui Liu and Xin Wang and Fei Chen},
  title = {{ReSkill: Selective Self-Improvement for Robot Manipulation}},
  year = {2026},
  eprint = {2611.10510},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.10510},
}
Figure