CycleVLA: Proactive Self-Correcting Vision-Language-Action Models via Subtask Backtracking and Minimum Bayes Risk Decoding

In plain words

A robot policy that reads camera images and an instruction, then outputs motions, often fails in a predictable place: where one step of a task ends and the next begins. A peg is slightly off before it jams, or a teapot handle misses the hook. Most existing fixes notice the failure only after it has happened.

CycleVLA tries to act earlier. The policy is taught to say when a step is nearly done, and a separate vision-language model looks at the scene at that moment and decides whether to keep going or to go back to an earlier step. If it goes back, the robot tries that step again. Instead of taking one action sample, it draws several and keeps the one that agrees most with the others, on the idea that consensus tends to be a safe choice.

The paper tests this on two simulated robot benchmarks and on a real arm with three tasks. The results are the authors' own. The real-robot tests use one arm and three tasks, so they do not show how well the method works elsewhere.

TL;DR

• The policy gets two extra outputs: a stop signal and a progress value per subtask §4.1.
• When progress reaches a threshold, a VLM either moves on or backtracks to an earlier subtask §4.2.
• The retry draws several action chunks and keeps the consensus one, selected with Minimum Bayes Risk (MBR) decoding §4.2 eq. 4.
• Author-reported: higher success on LIBERO and LIBERO-Plus, and about 80% of injected failures corrected on a real robot §5.2 §6.2.
• The official code is MIT-licensed, but it is a fork of OpenVLA-OFT and two of its dependencies are not included. See ## Paper vs code.

Problem

Most robot failure detection runs after the failure §1§2. Correction is often a retrospective residual policy §2. Closest prior work is PAINT, which needs a human, and Bellman-Guided Retrials, which does not target generalist policies §2. The paper argues that many failures happen at subtask transitions, and that progress near completion gives an early signal §1§4. Existing VLAs lack mechanisms for stopping or estimating progress, which the paper treats as a key gap §1.

Test-time scaling has been shown for LLMs, and related work applies it to VLAs through learned scorers and sampled actions, such as RoboMonkey, Rover and V-GPS §2. The authors assume that imitation-trained policies put their successful behaviours in dense regions of the output space, so consensus selection should help §1.

Method

The method has two parts. Section 4.1 trains the VLA to predict subtask stop and progress. Section 4.2 runs the inference loop with a VLM check and MBR retries. The loop is summarised in alg. 1 and fig. 3.

Preliminaries

The policy maps the observation and a language goal to a chunk of H future actions, predicted in one forward pass §3. Actions are 7-dimensional end-effector deltas: three translations, three rotations and a gripper state \gamma_t \in \{0,1\} §3. The policy must support stochastic sampling, so that N different chunks can be drawn from the same observation §3.

Subtask-decomposed data §4.1

1. An LLM splits each task into subtasks from a short list of verbs such as move, rotate, open and close §4.1 app. F.
2. Per-step gripper states (open, close, idle) and movement primitives are read from the robot's proprioception, using differences over a sliding window of 4 steps §4.1 app. B.1.
3. If the number of LLM subtasks equals the number of gripper segments, each subtask takes the timestamps of one segment. Otherwise an LLM infers the boundaries from the movement-primitive sequence, with no gaps allowed §4.1.

Extended action space §4.1

The 7-dimensional action becomes 9-dimensional:

a_t = [\Delta x_t, \Delta y_t, \Delta z_t, \Delta u_t, \Delta v_t, \Delta w_t, \gamma_t, s_t, p_t]^\top \in \mathbb{R}^9

§4.1. The stop signal s_t \in \{0,1\} marks subtask end. The progress signal p_t \in [0,1] is discretised in bins of 0.1 over the normalised time inside the subtask §4.1. Both are predicted as scalar outputs in the same head as the actions §4.1. In the main setting, the final step of each subtask gets 8 times its usual weight in training §4.1 tab. 8 tab. 10.

Inference loop §4.2 alg. 1

# CycleVLA inference loop  [alg. 1]
# Input:  task, policy, vlm, retry cap R, horizon H, samples N, timeout
# Output: episode success or failure

def run_episode(task, policy, vlm, retry_cap, timeout):
    # Split the task into an ordered list of subtasks, via the VLM  [§4.2]
    subtasks = vlm.decompose(task)           # list of K subtask strings
    current = 0                              # index of the active subtask
    phase = IN_PROGRESS                      # or COMPLETE
    queue = []                               # actions waiting to run
    retries = [0] * len(subtasks)            # backtracks used per subtask
    t = 0
    while current < len(subtasks) and t < timeout:
        # Get a new chunk from the policy when the queue is empty  [§4.2]
        obs = env.observe()
        if not queue:
            queue = policy.sample_chunk(obs, subtasks[current])
        # Run the next action and read its stop and progress outputs  [§4.1]
        action, stop, progress = split(queue.pop(0))
        env.step(action)
        t += 1
        if env.succeeded():
            return SUCCESS
        # While in progress, ask the VLM once progress is confirmed high  [§4.2]
        if phase == IN_PROGRESS and confirmed(progress, tau_p):
            # The VLM picks the next subtask or an earlier one  [§4.2]
            target, decision = vlm.check(obs, subtasks[current], subtasks)
            if decision == BACKTRACK and retries[target] < retry_cap:
                retries[target] += 1
                # Rewind to the start of the target subtask  [§4.2] [app. E]
                env.rewind_to_start_of(target)
                obs = env.observe()
                # Draw N chunks and run the MBR-selected one  [§4.2] [eq. 4]
                queue = mbr_select(policy.sample_chunks(obs, subtasks[target]))
                current = target
            else:
                phase = COMPLETE
        # Once complete, a confirmed stop moves to the next subtask  [§4.1]
        elif phase == COMPLETE and confirmed(stop, 1):
            current += 1
            phase = IN_PROGRESS
            queue = []
    return FAILURE

Two details are not in the algorithm box. The VLM is queried with synchronised third-person and wrist images, the current subtask and the subtask list §4.2. A backtrack target must be the earliest subtask that restores the missing precondition §4.2 app. G. The confirmed test is described in app. D: a signal counts when it occurs on two consecutive steps, or when it recurs after at least two low steps.

MBR selection §4.2 eq. 1 eq. 4

After a backtrack, the policy draws N hypotheses from the same observation and the active subtask §4.2. Each hypothesis is turned into a path by summing its translation deltas and rotation deltas, giving a feature vector of length 6H §4.2 app. C. The selected chunk is the one with the smallest average distance to all the others eq. 4:

a^{\mathrm{MBR}}_{t:t+H-1} = \operatorname*{argmin}_{a^{(i)} \in \mathcal{A}} \frac{1}{N} \sum_{j=1}^{N} d\!\left(\phi(a^{(i)}), \phi(a^{(j)})\right)

eq. 4. The paper uses L_2 for d with N = 8 §5.1 app. C.

# MBR selection over N sampled chunks  [eq. 4]
# Input:  hypotheses, a list of N action chunks of shape (H, 9)
# Output: the chunk to execute

def mbr_select(hypotheses):
    # Turn each chunk into a path of summed deltas, shape (N, 6H)  [§4.2]
    paths = [to_path(chunk) for chunk in hypotheses]
    # For each candidate, average its distance to every candidate  [eq. 4]
    risks = []
    for candidate in paths:
        distances = [l2(candidate, other) for other in paths]
        risks.append(sum(distances) / len(paths))
    # The candidate with the lowest average distance wins  [eq. 4]
    return hypotheses[argmin(risks)]

Stop-and-progress confirmation app. D

Progress and stop signals can be noisy. The paper's rule counts a high signal (progress \geq \tau_p or s_t = 1) as confirmed when either of these holds:

c_{\text{consec}} \geq 2 \quad \text{or} \quad (\texttt{first\_seen} \land c_{\text{gap}} \geq 2)

app. D. Here c_{\text{consec}} counts consecutive high signals, and c_{\text{gap}} counts low steps since the last high one. The official code applies this rule only to some suites run_libero_eval_decomposed_progress_mbr.py. See ## Paper vs code.

VLM prompt app. G

The VLM receives the task, the subtask list and the current subtask, plus the two camera views. It must return one of two decisions, transit or backtrack, with the subtask to continue from, and short evidence lines. The decision rule defaults to transit and allows backtrack only on clear visual evidence of failure. It is also told to catch wrong-object or wrong-subtask engagement app. G. The full prompt text is in app. G; it is not repeated here.

Hyperparameters

Values come from the paper's tables. "Not stated" means the paper does not say.

OFT-Diff training (LIBERO) tab. 8

\pi_{0.5} fine-tuning (LIBERO and real robot) tab. 10

Subtask decomposition app. B

Movement labels are the ECoT primitives: move forward/backward, left/right and up/down; tilt up/down; rotate clockwise/counter-clockwise; open or close the gripper; and stop when nothing is detected app. B.1. The LIBERO thresholds are given above. The per-trajectory translation grid minimises 1.0 \times N_{\text{overlaps}} + 2.5 \times N_{\text{stops}} app. B.1. An idle gripper segment is removed when it is shorter than the two neighbouring consistent segments combined app. B.2.

Results

All numbers are author-reported. Each setting is described in the text cited.

LIBERO-Plus under seven perturbations tab. 1

Success rates (%). Columns are the perturbation dimensions. Average in the last column.

The "+" figures are gains over the backbone tab. 1. The LIBERO-Plus models are the LIBERO-trained ones, evaluated without further training §5.2.

LIBERO tab. 2

Success rates (%) per suite, trained jointly on all four suites §5.2.

The caption says every policy in tab. 2 is supervised-finetuned, with no RL post-training tab. 2.

Under-trained checkpoints tab. 3

Average success (%) on LIBERO, without and with failure correction (FC) §5.2.

The paper says the corrected 200K and 350K checkpoints approach the uncorrected 350K and 500K ones §5.2.

MBR as test-time scaling tab. 4 tab. 5

tab. 4 gives the estimated success probability P_{\text{succ}} eq. 5 over hypothesis counts N. It is computed offline from recorded rollouts, not from closed-loop MBR runs §5.3. Random means one hypothesis is drawn at random.

The paper reports most of the gain by N = 8 and a plateau from N = 16 on §5.3.

Distance metric at N = 8 tab. 5:

L_2 is best at every checkpoint in tab. 5. The paper attributes this to rotation deltas being sparse and translations dense §5.3.

Ablation on LIBERO tab. 6

Always-on MBR takes about 2.2 times the inference time of the main method §5.4. Ending the episode on a predicted failure costs about 10% §5.4. The paper calls this VLM sycophancy: when asked whether failure is likely, the VLM tends to agree §5.4.

Runtime tab. 9

Seconds, from the table caption. The paper does not say whether these are per episode or averages app. D.

The paper says the added parts cost about 30% on top of the base rollout app. D.

Subtask decomposition quality tab. 7

Human check of LLM boundaries on 40 demonstrations, five annotators app. B.5. Mean absolute error 5.7 steps (Spatial 4.2, Object 3.5, Goal 8.0, Long 7.2). Relative error 3.8% on average. Goal is hardest, which the authors link to weak gripper cues and heavy rotation app. B.5.

Real robot (AgileX PiPER) §6.2 fig. 8

Three tasks, 15 trials each, with 100 demonstrations per task §6.1 app. E.

• Natural failures, CycleVLA vs baseline without correction: teapot hanging 0.87 vs 0.73; fruit sorting 0.93 vs 0.87; cookware packing 0.93 vs 0.80 §6.2.
• Stress tests inject one error per trial. Average correction is about 80% §6.2.
• Under target displacement, teapot hanging falls to 0.67 §6.2.
• Per-cell values for the stress tests appear only in fig. 8 and are not stated in the text.

The author-reported average of 91% in the abstract matches the natural-failure numbers above.

Paper vs code

Code: github.com/dannymcy/cyclevla_code at commit f3d0d7c1b3fa2d48a6b2e24feb260e3f66da2e17, linked from the authors' project page [https://dannymcy.github.io/cyclevla/]. Checked on the cloned repository.

1. MBR selection rule. Paper: plain average-distance argmin eq. 4 app. C. Code default: the r-NN density variant. It picks the point with the smallest distance to its rth neighbour, with r = \max(2, \min(4, \lfloor\sqrt{N}\rfloor)), which is r = 2 at N = 8. It takes the medoid of that pocket and ranks by a robust-normalised score, then executes the top chunk run_libero_eval_decomposed_progress_mbr.py run_libero_eval_decomposed_progress_mbr.py run_libero_eval_openpi_cyclevla.py. The plain average-distance rule exists in code as MBR_vanilla / mbr_vanilla, and it is off by default run_libero_eval_decomposed_progress_mbr.py run_libero_eval_openpi_cyclevla.py. The visible appendix text calls the selected chunk the medoid of the hypothesis set app. C, which fits the plain rule. The density pocket appears only in commented-out text app. C. The paper does not say which rule produced tab. 4 and tab. 5.
2. Stop and progress confirmation. Paper: one rule for all tasks app. D. Code: the robust rule (two consecutive or recurring highs) runs only for libero_goal and libero_10. For Spatial and Object, the code counts highs cumulatively and fires at the second one run_libero_eval_decomposed_progress_mbr.py run_libero_eval_decomposed_progress_mbr.py.
3. VLM model. Paper: GPT-5.2 at temperature 1.0 §5.1. The OFT script uses gpt-5.2 run_libero_eval_decomposed_progress_mbr.py. The openpi (\pi_{0.5}) script defaults to gpt-5.5 run_libero_eval_openpi_cyclevla.py. The paper does not name a VLM for the \pi_{0.5} runs.
4. Rollouts per task. Paper: 50 rollouts per task §5.2. Code default is 10, and its comment still says "(50)" run_libero_eval_decomposed_progress_mbr.py. The launch script also passes 10 run_libero_eval_decomposed_progress_mbr.sh.
5. Backtrack mechanism in simulation. Paper: restore the configuration by reverse-executing recorded delta actions, with object states kept §4.2. Code: the simulator replays the recorded robot states in reverse, restoring only robot joint positions, velocities and mocap pose, and keeps the current object positions run_libero_eval_decomposed_progress_mbr.py run_libero_eval_decomposed_progress_mbr.py. The robot slots are hard-coded to 9 DOF in that function. Real-robot joint replay matches the paper app. E.
6. Progress threshold in other scripts. Paper and both main scripts use 0.9 §5.1. The ablation script uses 0.95, which matches the paper's ablation description run_libero_eval_decomposed_progress_transit_ablation_8-dim.py.
7. Decomposition thresholds. The code's thresholds of 0.02, 0.0075 and 0.03 match the paper decompose_traj.py.
8. Licence file. The repository's LICENSE file is MIT. Its copyright line names Kim, Finn and Liang (2025), the authors of OpenVLA-OFT, from which this code descends. The code_license field above is taken from that file. It covers this repository only.
9. Missing dependencies. .gitmodules points to openpi and rlds_dataset_builder forks, and both directories are empty in the shallow clone. The \pi_{0.5} path therefore cannot run from this repository alone.

Pitfalls

• Ambiguous progress output. The paper says progress is discretised in bins of 0.1 §4.1, but also says it is predicted as a scalar in the action head §4.1. Treat it as a regressed scalar, with bins used for targets.
• Oversampling. The simulation setting oversamples the last action step by 8× tab. 8. The real-robot data repeats the last frame 8 times, with s_t = 1 and p_t = 1.0 app. E. The paper does not say how progress labels are set for the simulation repeats.
• Extra VLM context. The code adds 32 identical copies of the current frame to the VLM's inputs when it runs a check run_libero_eval_decomposed_progress_mbr.py. The paper does not mention this.
• Chunk features. The paper says deltas are accumulated. The code composes rotations by multiplication and converts back to Euler angles at each step run_libero_eval_decomposed_progress_mbr.py. The openpi version also pads short chunks with zeros run_libero_eval_openpi_cyclevla.py. The paper does not state either choice.
• Seeds versus stochastic sampling. OFT draws N chunks by changing the diffusion noise seed. The openpi version calls the server N times on the same observation. Equivalence is not tested in the paper.
• Cost. Each backtrack adds N = 8 policy forward passes, and each VLM check adds latency. The VLM's share of runtime rises from 6.0% on the A10 to 19.9% on the A100, but action rollout is still the largest share on both GPUs tab. 9.
• Reversibility. The paper says backtracking assumes reversible robot states and does not reset objects §7 §4.2. Irreversible events, such as a cup that has been knocked over, can make the retry impossible.
• Retry cap. After R = 3 retries the subtask is forced to complete. The paper does not say how often this happens app. D.
• Real-robot gripper. Training uses a continuous gripper value. Deployment binarises it at 6.0 cm, or 8.25 cm for teapot hanging app. E. Results could depend on this threshold, and the paper does not report sensitivity to it.
• Checkpoints. The shipped launch script evaluates only the 500K checkpoint. The 200K and 350K rows of tab. 3 cannot be reproduced from it.
• Figure and table numbers follow source order. They were not checked against a compiled PDF.

Lineage

• Builds on: VLA backbones \pi_{0.5} and OpenVLA-OFT, with OpenVLA-OFT's diffusion head §5.1. Subtask-decomposition primitives follow ECoT app. B.1.
• Backtracking follows Bellman-Guided Retrials §2 §4.2. PAINT is the closest prior work with human intervention §2.
• MBR decoding is taken from LLM work on minimum-Bayes-risk selection §2 §4.2.
• Compared against: RoboMonkey and Rover, which score sampled actions with learned models §2. The paper does not compare with these in its tables.
• Superseded by: not known from content on this wiki.