- Rating
- 2
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
This work proposes the L2R framework, a recovery pipeline that enables a VLA policy to self-recover from failures. During data collection, a tool-using agent takes over failed executions and curates verified recovery trajectories. By re-annotating these samples into which actions to imitate and when to trigger recovery, they train a lightweight adapter and controller on top of the frozen base policy, so the tuned policy can recover without calling the agent at deployment. Each round collects new failures from the updated policy, and experimental results show improvement after rounds of recovering.
Critical strengths
- Technically solid and soundness paper, evaluated on both simulations and real-robot.
Critical weaknesses
-
Transferability. Each task learns its own adapter and controller, so recovery only works on a fixed task. The core recovery ability is not shown to transfer to other tasks. The authors should report where transfer stops. For example, on which variants of the target task does recovery still work?
-
Weak baselines. Most baselines in the experiments are not self-recovery frameworks. To show that the framework adds real value, the authors should compare against baselines that use the same VLM agent, the same annotations, and the same recovery trials. For example: (a) a simple baseline that keeps only the base policy's own successful rollouts and fine-tunes on them, with no agent correction; (b) LoRA-BC trained with the same recovery conditioning and the same amount of data as each round (90/180/270 trajectories), not R1 data only; (c) existing self-recovery or self-improvement frameworks, such as HG-DAgger-style intervention learning, PLD, FailSafe, or RePO-VLA; (d) the tool-using agent controlling the robot directly online, with its success rate, latency, and cost reported as an upper bound. Without a complete and fair comparison, we cannot tell whether the gain comes from the framework or just from extra compute and the stronger abilities of the off-the-shelf tool-using VLM agent. The pipeline also relies on many separate CV tools for state estimation, which adds to this concern.
-
Policy-agnostic experiments. The authors should test whether the framework works across different base policies and different reasoning agents. A clear relationship between the framework's effectiveness and the base model's capability is expected.
Questions for authors
-
Controller robustness under distribution shift. The VLABench shifted tracks provide the recovery boundaries and routes, so they only test the adapter. The GRU controller is never evaluated under shift. Since it is trained per task on 90 recoveries plus nominal traces using mean-pooled visual features, I expect entry and route prediction to be the fragile part. Could you run the full policy (controller + adapter) from the start on the VLABench shifted tracks, or on the randomized RoboDojo episodes, and report entry precision/recall and route accuracy against agent labels, separately for ID and shifted conditions? I would also like to see whether the GRU controller transfers across conceptually similar tasks, for example from hanging headphones to hanging a towel or a mug.
-
Sensitivity to controller design. The controller relies on several hand-set choices: an 8-query history, entry/exit thresholds, consecutive confirmations, and holding rules. None of them are ablated. How does from-start success change with history length (e.g., 1/4/8/16 queries) and with the entry threshold? A simple non-recurrent baseline, such as an MLP on the current query only, would also show whether the GRU's history matters.
-
How are the route types defined? Is there a clear taxonomy of failure types, and can it be extended to new failure types?
-
On RoboDojo, performance saturates after 2–3 rounds of recovery. What bounds the final performance? Is it bounded by the agent's direct control (an upper bound), or by the base policy's capability?
5 comments
Official Comment by Authors
W2(a): Weak baselines—“the base policy's own successful rollouts,” with “no agent correction.”
Response: The baseline and model comparisons use Stack Bowls and Insert Tubes, with 50 from-start episodes per task and configuration. LoRA used 90 Base successes per task.
Table 2. Learning from Base successes only.
| Task | Training successes | Base SR | Success-only LoRA SR | L2R-R1 SR |
|---|---|---|---|---|
| Bowls | 90 | 62% (31/50) | 64% (32/50) | 76% (38/50) |
| Tubes | 90 | 8% (4/50) | 8% (4/50) | 20% (10/50) |
Success-only learning adds one successful trial on Bowls and none on Tubes. L2R-R1 reaches 76% and 20%, exceeding this baseline by 12 percentage points on both tasks. In this comparison, the L2R recovery-learning setup improves task success more than success-only fine-tuning.
W2(b): Weak baselines—“the same recovery conditioning” and “90/180/270 trajectories.”
Response: Appendix D compares condition-aware LoRA and L2R at R1 on four tasks, with macro success rates of 25.0% and 35.0%. We extended the comparison to 90/180/270 recovery trajectories on Bowls and Tubes.
Both methods use the same corrections, action targets, masks and replay, with matched adapter-update budgets. The comparison LoRA receives the same instruction, mode–route conditions and detached controller features through a non-modulating condition input. It uses an ordinary low-rank increment and trains with the corresponding L2R controller frozen. L2R retains its jointly trained checkpoint. At evaluation, both use the same task/round-specific controller weights and rules, applied to their own observations.
Table 3. Condition-aware LoRA with matched data and a shared controller.
| Task | Method | 90 trajectories | 180 trajectories | 270 trajectories |
|---|---|---|---|---|
| Bowls | Condition-aware LoRA | 62% (31/50) | 66% (33/50) | 68% (34/50) |
| Bowls | L2R | 76% (38/50) | 84% (42/50) | 88% (44/50) |
| Tubes | Condition-aware LoRA | 10% (5/50) | 18% (9/50) | 24% (12/50) |
| Tubes | L2R | 20% (10/50) | 28% (14/50) | 34% (17/50) |
The three budgets contain 30/60/90 failure sources, with three recoveries per source. Evaluation retains the original nominal/recovery schedule of 30/5 steps. With more data, condition-aware LoRA improves on both tasks, yet L2R retains gaps of 14/18/20 points on Bowls and 10/10/10 on Tubes across R1/R2/R3. The advantage persists across all three rounds with matched teacher corrections, conditioning information, controller, and cumulative trajectory budgets.
W2(c): Weak baselines—“existing self-recovery or self-improvement frameworks.”
Response: We added a single-round HG-DAgger-style baseline [1]. A human operator corrects policy failures with a handheld teleoperation controller, and an ordinary LoRA student learns from these interventions. LoRA-BC and L2R instead share the tool-generated corrections.
Table 4. Intervention learning with 90 recovery trajectories per task.
| Method | Bowls SR | Tubes SR |
|---|---|---|
| Human-HG | 78% (39/50) | 20% (10/50) |
| LoRA-BC | 66% (33/50) | 12% (6/50) |
| L2R-R1 | 76% (38/50) | 20% (10/50) |
Each method uses 30 failure boundaries with three recoveries each. All policies replan every five actions throughout the episode and deploy without an online expert. With the same tool-generated corrections and replanning interval, L2R exceeds ordinary LoRA-BC by 10 and 8 percentage points on Bowls and Tubes. L2R records one fewer success than Human-HG on Bowls and the same number on Tubes, approaching the human-intervention reference in these evaluations.
W2(d): Online tool-using agent—task success and end-to-end runtime.
Response: We evaluated Base assisted by GPT-5.6 Sol, the original RoboDojo collection teacher specified in Appendix A. The agent decides when to intervene and retains its perception tools, robot skills and verifier. L2R-R3 uses the original 30/5-step nominal/recovery schedule.
Table 5. Online recovery and policy-only deployment.
| Task | System | Task SR | Time per episode (min) |
|---|---|---|---|
| Bowls | L2R-R3 | 88% (44/50) | 3.2 |
| Bowls | Base + online teacher | 92% (46/50) | 6.8 |
| Tubes | L2R-R3 | 34% (17/50) | 3.4 |
| Tubes | Base + online teacher | 46% (23/50) | 8.4 |
End-to-end runtime is averaged over all 50 episodes per configuration. L2R reduces mean episode time by approximately 53% on Bowls and 60% on Tubes, with success rates 4 and 12 percentage points below online assistance. This provides a task-specific comparison of autonomous execution and online correction.
The tools and privileged simulator poses support training-data collection. Averaged across the two tasks, collection from a given failure to a successful recovery takes 30.4 minutes without tool assistance and 4.8 minutes with our tool-assisted pipeline. These are collection times, distinct from the from-start deployment times above.
Official Comment by Authors
W3: Policy-agnostic experiments—“different base policies and different reasoning agents.”
Response: We changed either the Base policy to π0.5 or the collection-time reasoning model to Opus 5.5 and evaluated one learning round. The original teacher is GPT-5.6 Sol. The teacher swap retains the XR-1 failure sources and tool interface; each Base policy learns from its own failures.
Table 6. Changing the Base policy or reasoning model.
| Task | Base | Teacher | Base SR | R1 SR | Gain (pp) |
|---|---|---|---|---|---|
| Bowls | XR-1 | gpt5.6-sol | 62% (31/50) | 76% (38/50) | +14 |
| Bowls | π0.5 | gpt5.6-sol | 40% (20/50) | 56% (28/50) | +16 |
| Bowls | XR-1 | Opus 5.5 | 62% (31/50) | 78% (39/50) | +16 |
| Tubes | XR-1 | gpt5.6-sol | 8% (4/50) | 20% (10/50) | +12 |
| Tubes | π0.5 | gpt5.6-sol | 6% (3/50) | 14% (7/50) | +8 |
| Tubes | XR-1 | Opus 5.5 | 8% (4/50) | 20% (10/50) | +12 |
Each configuration uses 90 recoveries from 30 sources and the original execution schedule. Both Base policies improve on both tasks: π0.5 gains 16/8 points on Bowls/Tubes, while XR-1 gains 14/12. With Opus 5.5, XR-1 gains 16/12 points. Thus, the gains extend beyond the original policy–teacher pairing, with task- and policy-dependent improvements.
Q1: Full-policy evaluation under distribution shift.
Response: VLABench's shifted tracks supply recovery boundaries and conditions. We evaluated the full R1 policy from task start using RoboDojo's official Standard and Random task variants.
RoboDojo designates Standard for training and evaluation and Random for evaluation only. The official Random variants use different task-object instance or texture pools, with additional tabletop clutter in task-specific configurations. For example, Stack Bowls uses a separate bowl-instance pool with distractors, and Arrange Largest Number uses different digit textures.
Five tasks contribute 25 Standard and 25 Random episodes each: Stack Bowls, Pack Objects into Box, Store Laptop and Headphones, Stack Blocks, and Arrange Largest Number. Both conditions use the same R1 weights and thresholds, with autonomous entry, route selection and exit.
Table 7. Full-policy R1 evaluation with episode-level entry metrics.
| Condition | Episodes | Macro task SR | Entry precision / recall |
|---|---|---|---|
| Standard | 125 | 41.6% (52/125) | 91.1% / 96.8% |
| Random | 125 | 20.8% (26/125) | 88.4% / 95.2% |
Task SR weights the five tasks equally. Each episode counts once: a reference-positive episode needs recovery, and a predicted-positive episode contains at least one entry. Precision/recall are 92/101 and 92/95 for Standard, and 99/112 and 99/104 for Random.
With fixed weights and thresholds, most recovery-needing episodes contain an entry in both variants (recall 96.8%/95.2%). False triggers occur in 9/30 reference-negative Standard episodes and 13/21 Random episodes; observed false-trigger interventions return to nominal execution and remain counted. Task success is 41.6%/20.8%, so entry coverage and full-task completion are evaluated separately. Table 1 tests cross-task transfer of the controller–adapter pair.
Official Comment by Authors
We appreciate the time and care you put into this review. Your concrete suggestions helped us strengthen the evaluation; the additional baseline, transfer, model and controller studies are in Appendix E of the revised manuscript.
Response: We transferred frozen R1 controllers and adapters together, without target-task recovery training.
Table 1. Cross-task transfer of frozen R1 recovery modules.
Each target uses the same 50 initializations across configurations. The frozen modules improve success on all three targets by 4–6 percentage points, showing useful recovery reuse without target corrections. Target-trained R1 remains 4–6 points higher. Together with the 4% absolute success on Build Tower, this indicates that related-task transfer helps, while more complex assembly still benefits from target-specific recovery learning.