- Rating
- 3
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper presents RoboSkill, a framework that structures embodied agent learning through an "Explore–Execute–Evolve" loop. Agents explore their environments to overcome issues, execute actions using visual and tactile feedback, and convert their experience into structured, reusable skills with textual guidance, code, metadata, and failure cases. These skills are then retrieved and adapted for downstream tasks. RoboSkill is evaluated on both the LIBERO-10 benchmark and physical robots, and it demonstrates strong capabilities in skill reuse, cross-task and cross-agent transfer, and continuous skill refinement.
Critical strengths
-
The algorithm is sound:
- The "Explore, Execute, Evolve" loop is clean and well-motivated for skill acquisition and reuse.
- The use of force/torque signals from tactile feedback complements vision, and reusable code (vs. text-only instructions) reduces the reasoning burden during reuse.
- They demonstrate that skills are agent-agnostic to some extent (Section 4.4).
-
Empirical results are convincing:
- The evaluation is very broad (i.e. 4 agents, 10 LIBERO-10 tasks, cross-task transfer, cross-agent transfer, 12 real-robot tasks, significant ablations...).
- The main LIBERO results are very strong, both in terms of success rate and average time.
- Even if not as strong as simulation results, the real-robot evaluation is also valuable, as agents improve success rate with respect to the baseline.
Critical weaknesses
- The "Method" section could be improved for clarity:
- As far as I understood, how sub-goals are selected is not specified.
- It is not explained how the agent detects it requires additional information. Failure seems to be the trigger, but the mechanism of how the agent decides what addition information requires is not defined.
- The definition of skill should probably be earlier in the paper to make it easier to understand. Until Section 3.4 there is not such definition, but you speak about skills already in the abstract.
- It is not clear to me how skills are built. The paper should specify more clearly what is the process for skill extraction. Is it through prompting? If so, what prompts are being used?
- No example of what a skill looks like. Would be useful to see one given it is a central part of the algorithm.
- Section 3.3. has a grammar error: "Throughout this paper, tactile feedback broadly including pressure and force/torque signals". This sentence should be fixed.
2- One of the main motivations for this work is that agents waste time and physical interaction by repeatedly solving tasks from scratch. However, as far as I understand, the results do not include the time for acquiring the skills, it measures the time it takes the agent when the skills are available (Appendix B). This should be emphazised in the main text (or, alternatively, the reported time in the tables should capture as well the time it takes to obtain the skills).
Questions for authors
- How does the agent detect that it requires additional knowledge? And how does it identify unresolved issues?
- According to the Section 3.2, the agent explores until it "resolves the exploration subgoal or reveals a need for further investigation". Does that mean that if, while solving one sub-task it detects it requires additional information, it abandons exploration for the initial sub-task and explores to resolve the new additional issue? Does it ever go back to the original sub-task? Is the last issue always prioritized? This should probably be clarified in the paper.
- How are conflicting skills resolved?
- What is the latency of executing code + API calls? Is this acceptable for real-time control?
6 comments
Response to W1.4: Skill Extraction and Prompts
Thank you for the question. Skill extraction is prompt-based. After successful task execution, the harness continues the same agent session, with further robot actions disabled. The agent reviews its conversation, executed code, feedback logs, and saved observations to produce:
- Textual guidance: successful strategies, failures, corrections, and supporting evidence.
- Reusable code: a hierarchical program index and modules copied verbatim from code executed during the run.
- Supporting records: action records, keyframes, and scene-specific parameters with instructions for recomputing them in a new scene.
The extraction prompt includes the following instructions (translated excerpts; omissions marked):
Keep the current session and workspace. Do not call step() or reset().
Review only the actual execution of your own task/seed ...
Summarize the successful path, important failures, and causal corrections ...
Separate scene-specific values from methods for recomputing them ...
Extract a reusable hierarchical program from code you actually executed.
Copy the corresponding source files verbatim ...
The harness checks the package structure, recorded-frame references, and code-file consistency. Failed checks are returned to the agent for repair before export. We will clarify this procedure and provide the full extraction prompt in the revised manuscript.
Response W1.5: A Concrete RoboSkill Example
Thank you for the suggestion. We will include a concrete example. The following is a small placement subskill within the RoboSkill package acquired from “turn on the stove and put the moka pot on it.” It lowers the grasped pot onto the burner and detects contact from stalled vertical motion.
Textual guidance (translated; excerpted):
After reaching the estimated placement height, descend gradually with a small command magnitude of 0.05–0.08. Use stalled vertical motion to determine whether the pot has seated on the support surface.
Executable code (original logic; logging omitted and explanatory comments added):
zs = [float(c.pos[2])] # Record the initial end-effector height.
for i in range(25): # Limit descent to at most 25 actions.
c.step([0, 0, -0.06, 0, 0, 0, 1]) # Move downward slightly while keeping the gripper closed.
zs.append(float(c.pos[2])) # Read and store the updated height after the action.
if len(zs) > 6 and abs(zs[-1] - zs[-6]) < 0.0012: # Detect less than 1.2 mm of vertical progress.
break # Stop descending when the motion stalls.
Supporting records and parameters. The full package contains 12 action records and 11 keyframes, linking the guidance and code to the source execution. It also records scene-specific parameters, including the burner height (0.9303 m) and end-effector-to-pot-base offset (0.1506 m), together with instructions for remeasuring them in a new scene.
The text explains the operation, the code implements the action–feedback loop, and the supporting records preserve execution evidence and guidance for adapting scene-dependent parameters.
Response to W1.1, W1.2 & Q1, Q2: Agent-Directed Exploration and Nested Subgoals
Thank you for these questions. Our framework combines prompting with a state-machine-based harness to support agent-directed exploration. Before each model call, the harness adds a brief reminder to the input context, without retaining it in the conversation history:
The harness tracks both goals and treats the agent as exploring when the current goal differs from the main goal.
Subgoal selection and information needs (W1.1, W1.2; Q1). The agent identifies missing information and selects exploration subgoals from execution feedback, without a separate detector or predefined selection rules. Exploration does not require a preceding failure; the agent may also identify missing information before attempting an action.
Nested exploration (Q2). The same agent can temporarily shift to a new subgoal, which takes priority while the previous goal remains pending. Once resolved, the agent resumes the previous goal with the findings retained in context. Deeper nesting is supported but was not observed in our experiments. We will clarify these mechanisms in Section 3.2.
Example: placing two moka pots on the stove.
This trace illustrates the agent identifying an information gap, choosing a diagnostic subgoal, and returning to the original task.