Vision-Language-Action (VLA) models map a language instruction and the current observation directly to actions, without checking whether the instruction has been completed. For long-horizon tasks, a single failed step therefore goes unnoticed and leaves the whole task unfinished. Such failed episodes, however, often end with the task partially complete. Moreover, the unfinished steps are reusable atomic skills that recur across demonstrations. A failed attempt can thus be recovered by composing with atomic skills. We propose RoboDuo, a closed-loop dual-system framework that uses code as the interface between a coding agent and two VLAs. The agent writes a program that lets a full-task VLA attempt the whole task and checks whether it is complete; on failure, an atomic VLA finishes the remaining steps. Since the agent emits no actions and only decides which VLA for execution, RoboDuo wraps an existing full-task VLA without updating its weights. To train the atomic VLA and the coding agent with the completion-checking ability, we build LIBERO-Atomic, LIBERO-Code, and LIBERO-Judge from a single set of LIBERO demonstrations. RoboDuo consistently improves X-VLA and π0.5 on LIBERO and LIBERO-PRO, with the largest gains on long-horizon tasks, and recovers failed rollouts of a frozen full-task VLA on a real robot.
Figures & tables
Figure 1: Overview of RoboDuo and its results. Left: open-loop VLAs fail long-horizon tasks after one unnoticed slip; token/latent dual systems cannot switch executor, and code-as-policy skips the full-task attempt. Center: RoboDuo uses a coding agent to Write a program, a frozen full-task VLA to Act , is_task_complete to Judge , and a frozen atomic VLA to Recover with at most three retries per step; control does not return. Right: matched gains on LIBERO, LIBERO-PRO (S/T), and a real robot. Bottom: one rollout from full-task attempt through failure detection to atomic recovery.
Figure 2: RoboDuo architecture: a generated program dispatches two VLA policies. Given the instruction and the current observation, the coding agent writes a two-layer program. Layer 1 makes one full-task attempt with πfull ; if is_task_complete returns false, Layer 2 executes an atomic plan with πatomic , retrying each step at most three times until its goal is verified. Both policies stay frozen, so the same program wraps X-VLA and π0.5 without retraining. The bottom row shows one LIBERO-Goal-Swap rollout: after the full-task attempt fails, the atomic VLA grasps the bowl and places it in the drawer.
#
Primitive
Role
Calls
1
move_to_and_grasp
Approach and grasp an object
11,643
2
place_and_release
Place a held object, then release
8,403
3
move_to_and_pull
Pull a drawer or door open
1,052
4
rotate_and_release
Rotate a held knob, then release
488
5
move_to_and_press
Push a drawer or door shut, or press a button
185
Table 1: Primitive vocabulary of LIBERO-Atomic. Every primitive takes a target <object> , and place_and_release also takes a relation (on, in, or under) and a <target> . Pull and press are executed with the gripper open. Calls count vla_execute_atomic invocations in the LIBERO-PRO evaluation (4,000 episodes, including retries).
Figure 3: Construction of LIBERO-Atomic. An industry VLM labels each LIBERO demonstration with an ordered list of atomic verbs and time windows. Rule-based post-processing cleans these labels, and each clip is re-cut to end where its effect is complete. Each demonstration yields atomic clips with instructions for the atomic VLA, and a Python program of the same calls, which is wrapped into LIBERO-Code for the coding agent.
Method
Spatial
Object
Goal
Long
Avg.
π0 [ 3 ]
98.0
96.8
94.4
88.4
94.4
π0.5 [ 28 ]
98.8
98.2
98.0
92.4
96.9
InternVLA-M1 [ 15 ]
98.0
99.0
93.8
92.6
95.9
GR00T-N1.7 [ 2 ]
97.7
98.5
97.5
94.4
97.0
OpenVLA-OFT [ 16 ]
97.6
98.4
97.9
94.5
97.1
Fast-WAM [ 35 ]
98.2
100.0
97.0
95.2
97.6
Table 2: LIBERO success rate (%). Upper block: published numbers from the cited papers (not rerun). Middle / lower blocks: our evaluation under four- and five-suite training, each backbone alone and with RoboDuo on the same weights. Bold marks the best average within each of our training blocks.
Method
Spatial-S
Spatial-T
Object-S
Object-T
Goal-S
Goal-T
Long-S
Long-T
Mean
OpenVLA
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.00
π0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.00
π0.5
20.0
1.0
17.0
1.0
38.0
0.0
8.0
1.0
10.75
MolmoAct
0.0
0.0
6.0
0.0
0.0
0.0
0.0
6.0
1.50
NORA
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.00
X-VLA
0.0
0.0
2.0
8.0
1.0
9.0
0.0
10.0
3.75
Table 3: LIBERO-PRO success rate (%). S is the position perturbation ( swap ) and T is the task perturbation. Upper block: published numbers under the official file-name prompting protocol. Mean is the arithmetic mean of the eight columns. Bold marks the best result in each column.
Coding agent
Spatial-S
Spatial-T
Object-S
Object-T
Goal-S
Goal-T
Long-S
Long-T
Mean-6
Mean-8
Cap-X [ 10 ]
12.0
14.0
22.0
18.0
26.0
17.0
–
–
18.17
–
Pigey [ 11 ]
66.0
80.0
54.0
54.0
44.0
22.0
–
–
53.33
–
Four-suite training (our evaluation)
None (frozen π0.5 )
63.6
60.6
20.0
25.2
39.0
24.2
12.6
11.2
38.77
32.05
LIBERO-Code fine-tuned
67.8
61.0
31.0
55.8
39.8
26.2
15.6
17.4
46.93
39.33
GPT
68.0
60.0
36.0
54.0
38.0
34.0
20.0
22.0
48.33
41.50
Table 4: Effect of the coding agent on LIBERO-PRO (%). Every RoboDuo row uses frozen π0.5 as the full-task VLA, with the same atomic VLA and retry budget. GPT denotes GPT-6-Astra. Mean-6 averages Spatial, Object, and Goal; Mean-8 averages all eight columns. Cap-X and Pigey are published references that omit Long. GPT cells use 50 episodes per cell. Bold marks the best result within each backbone block (Cap-X and Pigey excluded).
Figure 4: Real-world RoboDuo on a bimanual AgileX Piper for fruit arrangement across three layouts. Blue: frozen full-task VLA; red: the completion check fails and control switches; orange: recovery by the frozen atomic VLA.
Layout
Method
Success (%)
Fruits (/4)
1
Full-task VLA
40
2.4
RoboDuo
60
3.0
2
Full-task VLA
30
1.9
RoboDuo
60
2.8
3
Full-task VLA
40
1.8
RoboDuo
40
2.6
Table 5: Real-world fruit arrangement on a bimanual AgileX Piper. Success rate and mean fruit count over 10 trials per method and layout. Success requires all four fruits in the basket.