acceptodds
Under review as a conference paper at ICLR 2027

If at First You Don't Succeed, Backtrack: Lightweight Recovery for Frozen VLAs

Abstract

Vision-Language-Action (VLA) models perform well on robotic manipulation, yet remain brittle once their own actions carry them into states their training data barely covers. Recovering from such failures usually requires recovery demonstrations, policy retraining, or a separate model at inference time. We introduce Backtrack, a lightweight failure detection and recovery mechanism for frozen VLAs that needs none of these. A small failure-prediction head, trained only on outcome-labeled rollouts of the frozen policy, reads the VLA's existing internal representations to estimate whether the current episode will fail. When the predicted failure probability exceeds a threshold, a controller pauses the policy, retraces the arm's recently achieved motion, and hands control back to the unchanged policy so it can retry from an earlier configuration. The head adds only 0.48-0.88% to the policy's parameter count. We evaluate Backtrack on LIBERO with three VLAs spanning two action-generation families: SmolVLA and 0.5, which use flow-matching action experts, and the autoregressive 0-FAST. On LIBERO-Long, the suite of long-horizon multi-step tasks and the one on which all three policies fail most often, Backtrack reduces each policy's failure rate by 19-48%, raising success by up to 7.4 percentage points; on the three shorter suites, where control success is already 85-99%, its effect is smaller. On MetaWorld, all twelve controller configurations tested with SmolVLA improve on the unassisted policy.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Vision-Language-Action Models, Robot Learning, Failure Recovery, Robotic Manipulation, Failure Detection

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_oVMCOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Backtrack, a recovery module that enables a frozen VLA to recover from failures during online execution. Backtrack consists of a failure detection module and a recovery module. The failure detection module uses the VLA’s internal features to classify whether the current episode will succeed or fail, and the recovery module reverses previously executed motion to return the robot to a state similar to an earlier one (backtracking). The method is evaluated with three VLA backbones (SmolVLA, π0.5, and π0-FAST) on two benchmarks (LIBERO and MetaWorld), and it improves success rates in most settings, with the largest gains on the long-horizon LIBERO-Long suite.The paper addresses an important but challenging problem. Failures in robot manipulation are diverse and can arise in many different forms, which makes recovery difficult to address, yet important. The proposed module is lightweight and requires neither recovery demonstrations nor fine-tuning of the VLA. Since only a small head is trained, the training cost is low and the approach is efficient. The method is simple, yet it includes the components needed for detection and recovery.

Critical strengths
  1. The paper addresses an important but challenging problem. Failures in robot manipulation are diverse and can arise in many different forms, which makes recovery difficult to address, yet important.
  2. The proposed module is lightweight and requires neither recovery demonstrations nor fine-tuning of the VLA. Since only a small head is trained, the training cost is low and the approach is efficient. The method is simple, yet it includes the components needed for detection and recovery.
Critical weaknesses
  1. Weak baselines. The paper states that retrying after a detected failure is not new (line 136). Given this, the paper should explain why it does not compare against existing approaches such as Bellman-Guided Retrials (Du et al., 2024) or LLM-based failure recovery methods (Lin et al., 2025; Liu et al., 2023b). The current comparisons are limited to the unassisted policy, a longer step budget (Appendix A.3), and privileged restoration (Appendix A.6).

  2. Recovery from irreversible failures. The introduction motivates the method with cases such as dropping or knocking over an object. In such cases, reversing the arm’s motion may cause the arm to contact the object again. In addition, backtracking is performed only at the kinematic level, and the scene is not restored. Section 3.2 (around line 223) and Section 6 acknowledge these points and state that the experiments do not isolate the sources of improvement. However, the paper does not explain why returning only the arm configuration is sufficient for recovery. A more detailed rationale, or an analysis of which failure types are recovered, would strengthen the paper.

  3. Insufficient qualitative results. The paper does not include videos or snapshot sequences of the recovery process. Without them, it is difficult to see what kinds of failures are recovered and how, which weakens the paper’s claims.

  4. Sensitivity to the threshold. The threshold sweeps (Tables 5–7 and 14) suggest that performance depends on the threshold and on its interaction with the retreat rule. On π0.5, the adaptive rule at t = 0.90 performs significantly worse than control. On π0-FAST, the ranking of thresholds changes with the retreat shape. The selected configurations also differ across policies (t = 0.97, 0.99, and 0.90). The paper does not discuss how the threshold should be chosen for a new policy or task without a per-policy sweep.

Questions for authors
  1. Training the classifier requires a substantial amount of rollout data including failures (7,953–20,000 episodes per policy, Table 2). Is it reasonable to assume that this amount of outcome-labeled rollout data is available, particularly on a physical robot where each rollout must be labeled as success or failure? In addition, the failure prediction head is trained on rollouts from the same four LIBERO suites used for evaluation, so its generalization to unseen tasks is not evaluated.

  2. Would it be possible to add comparisons with existing failure recovery methods?

  3. Could the authors explain in more details with figures and examples of why backtracking at the kinematic level alone is sufficient for recovery in many cases?

  4. Could the authors provide qualitative results, such as videos or snapshot sequences of the recovery process?

  5. Could the authors provide guidance on selecting the threshold and retreat rule for a new policy or task, given the sensitivity observed in Tables 5–7?

1 comment
AuthorsOpenReview ↗

Response to Reviewer oVMC

We thank the reviewer for the detailed and constructive review, and for recognising that Backtrack addresses an important problem with a lightweight module that needs neither recovery demonstrations nor fine-tuning of the VLA.

W1/Q2 (baselines).

LLM-based recovery methods (Lin et al., 2025; Liu et al., 2023b) add a second large model at inference, which Backtrack is designed to avoid. Bellman-Guided Retrials (Du et al., 2024) is the closest in spirit, but its authors note that it "assumes access to a robust recovery policy, which may not be trivial for more involved tasks" (their Sec. 6); Backtrack replaces this assumed recovery policy with the arm's own recorded motion. We could not reimplement these methods within the discussion period.

W2/Q3 (recovery from irreversible failures).

Execution errors such as a missed or slipped grasp leave the scene largely unchanged (see the new figure under W3); returning the arm to where it was before the error is then enough for a fresh attempt. Dropping or knocking over an object changes the scene, but the task can remain solvable from there, so a fresh attempt can still succeed. We agree that an analysis of which failure types are recovered would strengthen the paper and leave it to future work.

W3/Q4 (qualitative results).

We agree. In the revision, we will add a figure showing one full LIBERO-Long episode as a snapshot sequence (missed grasp → retreat → re-grasp → success) together with the predicted failure probability, plus further sequences, including failed recoveries, in the appendix.

W4/Q5 (sensitivity to the threshold).

A strict threshold is a safe default: t = 0.99 improves over the control on all three policies under each policy's reported retreat rule, with every interval excluding zero (Tables 5–7). Loose thresholds are riskier on a policy that rarely fails, likely because they trigger needless retreats (π0.5, adaptive t = 0.90). For SmolVLA, settings also transfer across benchmarks: in a new experiment, its LIBERO-Long settings, run unchanged on MetaWorld, raise success from 72.32% to 76.64% (+4.32 pp, seed-paired 95% CI [+1.35, +7.29]), and every threshold from 0.90 to 0.995 gives +3.6 to +4.3 pp. We will add a recommendation: start at t = 0.99, and tune only if a sweep is affordable.

Q1 (amount of rollout data).

The head needs only rollouts of the unmodified policy labelled by episode success, with no teleoperation or per-step labels. The amounts in Table 2 are what we used; how few rollouts suffice, and thus how practical collection is on a physical robot, we have not tested and leave to future work.

Regarding unseen tasks, the MetaWorld head is trained only on the 11 medium-difficulty tasks (l. 354–355). On the 39 tasks it never saw, Backtrack with the transferred LIBERO settings still improves success by +2.41 pp [+0.09, +4.73], compared with +4.32 pp over all 50 tasks; we will add this breakdown to the revision. On LIBERO, generalisation to unseen tasks remains untested, and we will state this as a limitation.

Reviewer_Y64tOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents a simple yet effective failure detection and recovery mechanism for Vision-Language-Action (VLA) models. Without requiring additional recovery demonstrations or retraining the underlying policy, the proposed method detects potential failures and performs backtracking with minimal computational overhead.

Critical strengths
  1. Lightweight failure detection. The proposed failure prediction head introduces only a small number of additional parameters and incurs negligible inference overhead.

  2. Clear presentation. The paper is well-organized, with a clear motivation and a focused technical contribution.

Critical weaknesses
  1. The claim of requiring no additional demonstration data needs clarification. Although the proposed method does not require recovery demonstrations, it still relies on collecting successful and failed rollouts to train the failure prediction head. My understanding is that these data are collected by executing the existing policy in each environment and labeling the resulting episodes as successful or failed. This process still involves collecting additional training data. The authors should clarify this distinction and discuss the data collection cost, particularly when transferring the method to new tasks or environments.

  2. The recovery mechanism is relatively simple and lacks active corrective guidance. The underlying motivation is straightforward and has been explored in previous work on failure recovery for VLAs, such as CoRe. While the proposed approach is simple and practical, its recovery mechanism essentially consists of backtracking and retrying. This primarily provides another opportunity for the policy to generate a different execution trajectory, rather than actively guiding it toward a more successful strategy. The authors should better distinguish their contribution from existing recovery methods and discuss the limitations of relying solely on repeated attempts.

  3. The evaluation benchmarks are insufficiently challenging. LIBERO has been extensively used and optimized for in recent VLA research, raising concerns about whether improvements on this benchmark are sufficient to demonstrate the effectiveness of a general recovery mechanism. As discussed in Qwen-Manipulation, the limitations of LIBERO may reduce its ability to distinguish between different methods. I recommend evaluating Backtrack on more challenging benchmarks, such as LIBERO-Plus or RoboTwin, particularly under environmental and state perturbations that require genuine recovery capabilities.

  4. Broader evaluation across VLA architectures is needed. If the authors aim to demonstrate that Backtrack is a generalizable recovery mechanism, experiments on a wider range of VLA models would strengthen this claim. In particular, I recommend considering additional models such as OpenVLA, GR00T, and LingBot-VLA to further evaluate the applicability and robustness of the proposed approach.

Questions for authors
  1. The claim of requiring no additional demonstration data needs clarification. Although the proposed method does not require recovery demonstrations, it still relies on collecting successful and failed rollouts to train the failure prediction head. My understanding is that these data are collected by executing the existing policy in each environment and labeling the resulting episodes as successful or failed. This process still involves collecting additional training data. The authors should clarify this distinction and discuss the data collection cost, particularly when transferring the method to new tasks or environments.

  2. The recovery mechanism is relatively simple and lacks active corrective guidance. The underlying motivation is straightforward and has been explored in previous work on failure recovery for VLAs, such as CoRe. While the proposed approach is simple and practical, its recovery mechanism essentially consists of backtracking and retrying. This primarily provides another opportunity for the policy to generate a different execution trajectory, rather than actively guiding it toward a more successful strategy. The authors should better distinguish their contribution from existing recovery methods and discuss the limitations of relying solely on repeated attempts.

  3. The evaluation benchmarks are insufficiently challenging. LIBERO has been extensively used and optimized for in recent VLA research, raising concerns about whether improvements on this benchmark are sufficient to demonstrate the effectiveness of a general recovery mechanism. As discussed in Qwen-Manipulation, the limitations of LIBERO may reduce its ability to distinguish between different methods. I recommend evaluating Backtrack on more challenging benchmarks, such as LIBERO-Plus or RoboTwin, particularly under environmental and state perturbations that require genuine recovery capabilities.

  4. Broader evaluation across VLA architectures is needed. If the authors aim to demonstrate that Backtrack is a generalizable recovery mechanism, experiments on a wider range of VLA models would strengthen this claim. In particular, I recommend considering additional models such as OpenVLA, GR00T, and LingBot-VLA to further evaluate the applicability and robustness of the proposed approach.

1 comment
AuthorsOpenReview ↗

Response to Reviewer Y64t

We thank the reviewer for the review, and for highlighting the lightweight failure detection and the clear presentation. We address each point below.

Q1 (additional data).

We will clarify this in the revision. The introduction states that "the only supervision Backtrack needs is whether autonomous rollouts of the frozen policy succeed or fail" (l. 087–088). These rollouts need no teleoperation or per-step labels; Table 2 lists the rollouts used for each head (7,953–20,000 episodes per policy on LIBERO). On MetaWorld, a head trained on only 11 of the 50 tasks still improves success on the 39 tasks it never saw (+2.41 pp [+0.09, +4.73], compared with +4.32 pp over all 50 tasks), which suggests that new tasks do not always require new rollouts. We did not evaluate how many rollouts are needed at minimum; we will discuss this cost for new tasks and environments explicitly.

Q2 (corrective guidance and CoRe).

As CoRe was posted to arXiv five weeks before our submission deadline, we consider it concurrent work and will cite it. It provides active guidance at a substantially higher cost: an RGB-D scene model with per-object voxel stores, open-vocabulary detection and segmentation models on the real robot, image synthesis to roll the policy out in imagination, and restoration of objects by motion-planned pick-and-place (on LIBERO, by writing the simulator state directly). Backtrack sits at the opposite operating point: RGB only, no extra models beyond a head adding <1% parameters, and no manipulation of objects. We agree Backtrack does not actively steer the retry: it relies on the stochastic policy producing a new attempt from an earlier configuration. We will discuss this limitation explicitly.

Q3 (benchmarks).

We agree harder benchmarks are an important next step but could not add them within the discussion period.

Q4 (VLA architectures).

We evaluate three VLAs spanning both main action-generation families: flow-matching action experts (SmolVLA, π0.5) and autoregressive action tokens (π0-FAST), from 0.45B to 3.6B parameters. Backtrack improves all three. The suggested models fall into the same two families: OpenVLA predicts autoregressive action tokens like π0-FAST, and GR00T uses a flow-matching action head like SmolVLA and π0.5. Backtrack requires only access to features the policy already computes, and none of its components depends on a particular architecture, so we expect it to apply to other VLAs in the same way.

Reviewer_MaasOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Backtrack, a lightweight mechanism for frozen VLAs in which a small failure-prediction head, trained only on rollout success/failure labels, detects likely failure and triggers reversal of recently achieved arm motion before returning control to the unchanged policy, adding under 1% parameters with no retraining or recovery demonstrations. Experiments on three policies over LIBERO's four suites and MetaWorld show its effectiveness.

Critical strengths

The proposed method is simple and easy to understand, and is highly lightweight, requiring little engineering adaptation.

Critical weaknesses
  1. Insufficient experimental evaluation. The paper employs a lightweight failure-prediction head to decide when to intervene, but all experiments are conducted in MuJoCo-based simulated environments, LIBERO and MetaWorld. For robotic manipulation tasks, simulation and real-world execution differ substantially in complexity: simulated conditions are more idealized and structured, whereas real-world settings contain considerably more disturbances. The current experiments therefore cannot establish whether this prediction head remains effective in more complex, realistic scenarios. Since this prediction head constitutes the paper's primary contribution, I consider real-robot experiments necessary, or, at a minimum, evaluation on benchmarks that test algorithmic robustness, such as LIBERO-Plus and RoboTwin2.0 clean2random.

  2. Weak potential for real-robot deployment. The method requires the controller to replay previously achieved arm motion in reverse. This is entirely feasible in a differentiable simulator, but it is arguably infeasible in real environments. First, the real world does not satisfy the idealized static assumption that ``if the arm does not move, the world does not move either''; real-world settings are full of dynamic scenes, which would prevent the system from returning to the original state. Second, even for highly static tasks such as pick-and-place, if the arm contacts an object during execution, recovery may become entirely impossible. Third, robotic manipulation inevitably involves control error. These are all issues that the paper should have discussed but does not.

Questions for authors

Please see the Critical Weaknesses above.

1 comment
AuthorsOpenReview ↗

Response to Reviewer Maas

We thank the reviewer for the review, and for noting that Backtrack is simple, lightweight and requires little engineering adaptation. We address each point below.

W1 (experimental evaluation).

We agree real-robot validation is the key next step; the paper states it as the first limitation (l. 462–465). We could not add real-robot or new-benchmark experiments within the discussion period.

W2 (reversing the arm's motion).

We believe there is a misunderstanding. Backtrack uses no simulator privilege: no simulator state is written, reset or restored. The retreat is executed as ordinary control commands that replay the arm's own recorded motion in reverse, the same kind of command the policy itself issues. Nor do we assume that the world stays still: the scene keeps evolving under its normal dynamics during the retreat, and the policy resumes from whatever state the scene is in when the retreat ends. The paper already discusses control error and contact with objects. Control error: "the reversed deltas are themselves executed approximately because of the embodiment's tracking dynamics" (l. 220–223). Contact with objects: Backtrack "restores neither object poses nor the full environment state, and executing the return trajectory can itself change the scene. It cannot recover failures that have made the task physically impossible" (l. 467–469).

Reviewer_uoV7OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes Backtrack, a simple way to detect and recover from failures in frozen VLA models. There is a small failure-prediction head that reads the VLA’s internal features and predicts whether the current episode will fail. When the predicted probability goes above a threshold, the arm moves back along its recent path and the same VLA tries again from there. The head architecture is also very simple, the failure head is just an attention-pooling layer over the policy’s own token features, followed by a small three-layer feed-forward network that outputs one number, the predicted probability that the episode will fail. The head is trained only on success/fail labels from the policy’s own rollouts, so no recovery demonstrations or VLA retraining are needed, and it adds less than 1% extra parameters. They test it on SmolVLA, π0.5 and π0-FAST on LIBERO and on SmolVLA on MetaWorld.

Critical strengths
  1. Simple and practical. The method needs no recovery data, no retraining and no extra model at inference, and the head is very small. It works with both flow-matching and autoregressive VLAs, so it is easy to add to an existing policy. This matters because collecting recovery data is expensive.
  2. Authors seems careful and honest about their evaluations. Results use five seeds with seed-paired confidence intervals, and some seeds were held out when choosing the settings. The authors also show that simply giving the policy more time (double the step budget) improves success only slightly, so Backtrack’s gain is not just extra time. They are also open about what their results do not prove. This makes the reported improvements believable.
Critical weaknesses
  1. Idea is not fully novel or not proposing something new. The authors took the main failure detection idea from SAFE, which they also tell in L084. For the recovery, they use a "try again" type of method, which is not very new either. CycleVLA[1] and See, Plan, Rewind[2] papers already explore and doing this ideas, and the authors did not cite these papers even though they are very close to this work. They also don’t train anything for recovery. This is presented as their main contribution, but I think it is also a weakness, the recovery is just a fixed “go back and retry” rule, so it cannot learn or change the strategy after a failure.

  2. They train the head for each model separately, which is okay, but for each model they also need a model-specific threshold. The authors choose the threshold by trying a few values and picking the one with the best success rate on LIBERO-Long. They then test on the same LIBERO benchmark. The threshold is also different for each model (0.97 for SmolVLA, 0.99 for π0.5, 0.90 for π0-FAST), so it looks like we would need to re-tune it for every model and every dataset. 
    The MetaWorld experiment doesn’t fix this. There they trained a new head, used a different feature tap, and searched for new settings again. So it doesn't show that a threshold tuned on one dataset works on another.

  3. The paper only reports how often the controller triggers at least once (the fire rate) and when the first trigger happens. It does not report anything like - how many times it backtracks in a typical episode or how many retries the successful episodes needed. Without this, it's hard to understand the recovery rate or what it costs in time. 

  4. The introduction motivates the work with the claim that VLAs “remain brittle outside their training distribution: modest changes to camera viewpoint, robot initialization, or scene composition can sharply reduce success rates.” But the authors also didn't do test this. They also didn't mention that does they use LIBERO-LONG all types of tasks present in training and testing both or there are some tasks which does not present in training to check the OOD performance.

[1] https://arxiv.org/pdf/2601.02295
[2] https://arxiv.org/pdf/2603.09292

Questions for authors

I would be happy to increase my score if the authors:

  1. The authors clear their main contributions and novelty.
  2. clear the 2nd point about generalization of thresholds.
  3. check the weakness 3rd point and do report success rate or recover rate experiment results properly. Report the average number of retreats per episode and success rate broken down by number of retreats used.
  4. Please look at weakness 4 and either fix the claims and motivation so they match what is actually tested, or run some OOD experiments to support the motivation. For example, leave a few LIBERO tasks when training the head and check the performance on those tasks. Or test on a benchmark like LIBERO-Plus or LIBERO-90 (or similar) that the model was not trained on, without setting the threshold again for that dataset.
2 comments
AuthorsOpenReview ↗

Response to Reviewer uoV7

We thank the reviewer for the careful review, and for recognising that Backtrack is simple and practical, and that our evaluation is careful and honest. We address each point below, including two new analyses requested in the review.

W1/Q1 (novelty and related work).

Thank you for these references; we will cite and discuss both. Both also move the robot back after a detected failure and retry, which we will make explicit; the difference is in what each method requires. CycleVLA predicts failures with a VLM at inference, retrains the VLA to track progress through a list of subtasks, and retries with Minimum Bayes Risk decoding over multiple samples. See, Plan, Rewind fine-tunes a 7B VLA (MolmoAct) to predict spatial subgoals and its own progress, and trains it on reversed trajectories so that it learns a rewind behaviour. Backtrack instead adds to an existing VLA without changing it: no separate VLM, no subtask structure, no change to the policy or its decoding, and a head adding 0.48–0.88% parameters trained only on outcome-labelled rollouts. We see this as complementary: Backtrack is a plug-in for policies that already exist, without needing to retrain them.

We planned a direct comparison with CycleVLA on π0.5, but its released LIBERO code (commit 4f950e5) differs from the paper. The subtask lists are hard-coded per task rather than produced by the VLM at inference, and the robot is restored by writing saved states into the simulator rather than "by reverse-executing recorded delta actions". The released code also runs the method only on the episodes a first pass without backtracking failed and counts the rest as successes, so its reported gain cannot be negative. A matched comparison was therefore not possible.

On the recovery not changing strategy: this is a deliberate choice. The retry uses the same frozen policy, which is stochastic, so a retry from an earlier configuration produces a new attempt. For π0.5 on LIBERO-Long, 99.1% of episodes with one retreat and 89.6% with two still succeed (see W3 below). Learning recovery strategies would need recovery data, which Backtrack avoids. We will state this limitation explicitly.

W2/Q2 (generalization of thresholds).

We ran a new experiment to test exactly this. We took SmolVLA's controller settings selected on LIBERO-Long (adaptive retreat, t = 0.97, restart threshold 0.2, 50–150 steps, cooldown 50, at most 3 retreats per episode) and ran them unchanged on MetaWorld MT50 (50 tasks, 5 seeds × 500 episodes). Success rises from 72.32% to 76.64% (+4.32 pp, seed-paired 95% CI [+1.35, +7.29]); all five seeds improve. No MetaWorld result was used to choose these settings. The result also does not hinge on the exact threshold: under the same rule, t = 0.90, 0.95, 0.99 and 0.995 give +3.64, +4.16, +4.24 and +3.80 pp, and every interval excludes zero. We agree the head must be trained per policy and benchmark; for SmolVLA, the new result shows the controller settings do not need to be re-tuned for a new benchmark.

W3/Q3 (retreats per episode).

We ran this analysis on our existing logs and will add it to the revision. For π0.5 on LIBERO-Long (2,500 episodes), the controller fires in 11.5% of episodes, with 0.24 retreats per episode on average (2.10 among episodes where it fires):

retreats in episode0123 (cap)
episodes2,21310548134
success100.0%99.1%89.6%35.8%
mean steps, successful episodes251446603759

Most episodes with one or two retreats still succeed, while success drops sharply for episodes that reach the cap. Overall, the time cost is small: successful episodes take 276 steps on average with Backtrack and 267 in the control (median 243 in both). Our logs for SmolVLA and π0-FAST record whether the controller fired, but not how often (fire rates 42.6% and 33.7% on LIBERO-Long); we will add counts for all three policies in the revision.

W4/Q4 (motivation and OOD).

The sentence on camera viewpoint and scene changes (l. 036–039) was meant to illustrate the general brittleness of VLAs; the failures Backtrack targets are the ones introduced in the next paragraph (l. 043–047): out-of-distribution states the policy creates itself, for example after missing a grasp. We will revise the motivation to make this clear.

As for whether the evaluation tasks appear in training: on LIBERO, the head is trained on rollouts of the same tasks it is evaluated on (rollouts are collected across all four LIBERO suites, l. 180–181). On MetaWorld, the head is trained only on the 11 medium-difficulty tasks (l. 354–355). On the 39 tasks it never saw, Backtrack with the transferred LIBERO settings still improves success by +2.41 pp [+0.09, +4.73], compared with +4.32 pp over all 50 tasks. We will add this breakdown to the revision.

Thanks for the author responses, I will maintain my initial score. As the authors didn't clearly explain the novelty(difference in comperison [1], [2] ), threshold concern, OOD motivation.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.