An embodied coding agent can write code that calls modular perception, grasping and motion-planning interfaces, or it can invoke a frozen VLA or world action model (WAM). What it cannot do is anticipate which of the two will succeed in the current physical state. The preprint RoboAware (arXiv 2610.11480, 2026-10-08) leaves the coding agent and every executor unchanged and trains only a “responsibility coordinator”: at the start of each skill stage, it decides whether the next block of code is handed to modular composition (Mod) or to an end-to-end policy (E2E). Its training data come from “state-locked counterfactual branches” in simulation: the simulator is restored to the same state and both kinds of branch are executed, exposing what would have happened on the path that was not chosen. The authors report a 77.0% overall success rate on 100 tasks across three benchmarks, LIBERO-Pro, RoboSuite and RoboTwin 2.0. All numbers below are author-reported [R]; this site has not reproduced them.
A high-level action with only two options
The paper formulates the problem as a finite-horizon hierarchical MDP. There is one high-level action: the choice of policy family c ∈ {Mod, E2E}. Once a family is chosen, the frozen coding agent, conditioned on that family and the current context, generates one complete local code block through the fixed API library and executes it. Decision points are the start of each stage in the P⁵ skill schema. P⁵ splits every skill into five stages, perceive, propose, pre-manipulate, perform and post-manipulate, and represents primitive skills such as pick, place, push and pull and compositional skills such as handover in the same way. The coordinator sees the language instruction, the observation (an RGB image, a metric depth map and proprioception), the observable execution history, the current stage and the active skill. Only the coordinator’s value model Qθ is trained; the coding agent, API interfaces, backend bindings and low-level parameters stay fixed.
| API | P⁵ stages covered | Policy family | Backend |
|---|---|---|---|
Perceive_object_pose | perceive | Mod | InstructSAM |
Propose_eef_pose | propose | Mod | NeuGraspNet+ (the authors’ extension of NeuGraspNet) |
Plan_to_eef_pose | pre-manipulate, post-manipulate | Mod | cuRoboV2 |
Perform_gripper | perform | Mod | deterministic gripper API |
Perform_E2E | perceive, pre-manipulate, perform, post-manipulate | E2E | π0.5, FastWAM |
Why are the VLA and WAM placed at grasp–lift granularity rather than given whole tasks? The authors’ offline screening (Table 1, successes / total) shows π0.5 completing full tasks 10/14, 0/4 and 0/10 times on LIBERO-Pro, RoboSuite and RoboTwin 2.0, against 13/14, 2/4 and 2/10 for grasp and lift alone; FastWAM scores 4/14, 0/4 and 10/10 on full tasks and 11/14, 0/4 and 10/10 on grasp–lift. The propose stage admits only Mod, because end-to-end backends determine grasp targets internally and do not expose them through this interface. A single Perform_E2E call may span several stages; its family stays fixed for the duration of the call, until it meets its registered postcondition, reports failure or exhausts its step budget.
SCB and EAL: filling in the path not taken from the same state
The authors note that existing methods either ignore execution outcomes or have a VLM judge the outcome of the executed trajectory. The latter sees only the consequences of the selected branch and therefore inherits selection bias. State-Locked Counterfactual Branching (SCB) is used only during training: relying on the simulator’s save–restore mechanism and oracle outcome judgments, it starts from an identical physical state at every P⁵ decision point and generates and executes one code block for each admissible family. Besides the context visible at deployment, each snapshot holds oracle masks, ground-truth object poses and the terminal reward evaluator, all of which are privileged information.
Execution-Aware Learning (EAL) organizes these branches with Monte Carlo tree search: nodes are restorable decision states and edges are admissible policy families; at expanded nodes, edges are selected by UCB; at a new node, every family is evaluated at least once; the remainder of the task is then completed through the API library until task termination, unrecoverable failure or the horizon T, and the return is backed up along the path. The budget is K = 20 completed suffix simulations per root. Every evaluated edge, including failed and nonpreferred branches, enters the training set D_SCB.
The training reward per step is r̃ = w_p·r_p + w_m·r_m + w_t·d·r, with non-negative weights and w_p + w_m + w_t = 1. Here r_p comes from agreement with the oracle mask, r_m from the object-pose error under a threshold ε_p, and r is a binary task-success reward given only at termination; the discount is γ = 1. The text this site read does not give the weight values. After collection, the authors train Qθ on this fixed dataset with Bellman targets, a Smooth-L1 loss and a stop-gradient target network, rather than regressing directly on the returns found by search. Qθ is a lightweight VLM backbone (for example Qwen3.5-0.8B) with an MLP head that reads a context–family sequence ending in a <VALUE> token. At deployment, the family with the highest Q-value is selected and the coding agent generates the code block; this step uses no simulator restoration, no privileged information and no online search.
How 77.0% is computed
The evaluation covers 100 tabletop manipulation tasks. Only scene seed 0 is used to collect SCB branches and train Qθ; the frozen coordinator is then tested on seeds 1–10, giving 1,000 test episodes, with one trial per seed. Baselines that rely on memory have global cross-episode memory disabled. π0 and π0.5 are incompatible with RoboTwin’s dual-arm setup, so results involving them are marked “/”. In the table below, the LIBERO-Pro column is this site’s average of the eight splits in the paper’s Table 3; the other values are the paper’s (%). The table shows selected rows; the omitted rows include π0, FastWAM, CaP-X, RATS and VLS.
| Method | LIBERO-Pro, mean of eight splits (this site’s calculation) | RoboSuite | RoboTwin | Overall (paper) |
|---|---|---|---|---|
| π0.5 (end-to-end) | 11.0 | 0.0 | / | 9.8 |
| FasterWAM (end-to-end) | 12.5 | 0.0 | 85.6 | 18.6 |
| CaP (code as policy) | 0.0 | 70.0 | 5.6 | 7.6 |
| ASPIRE (code as policy) | 61.25 | 80.0 | 0.0 | 57.0 |
| Pigey (VLA with harness) | 45.0 | 15.0 | / | 41.7 |
| Harness-VLA (VLA with harness) | 53.75 | 20.0 | / | 50.0 |
| RoboAware | 73.75 | 90.0 | 90.0 | 77.0 |
Three things matter when reading this table. First, Table 3’s Overall is a simple mean over the available columns. Eight of RoboAware’s 10 columns are LIBERO-Pro splits (the 73.8% in the abstract is the mean of those eight), while rows with “/” are averaged over 9 columns. The text this site read does not give the number of tasks per column, so 77.0% is not a success rate weighted by the 100 tasks or the 1,000 episodes (this site’s check). Second, RoboAware has the highest mean but not the highest score in every split: on Obj-T and Obj-S, ASPIRE scores 95.0 and 98.0 against RoboAware’s 92.0 and 86.0; on Spat-T, Pigey scores 80.0 against 68.0; on Spat-S and Obj-S, Harness-VLA scores 70.0 and 90.0 against 68.0 and 86.0. Third, on RoboTwin the standalone FastWAM and FasterWAM already reach 81.9 and 85.6; RoboAware’s 90.0 is 4.4 percentage points above FasterWAM. The text this site read gives no confidence intervals.
Ablations: two families, paired outcomes and per-stage switching
| Variant | Meaning | LIBERO-Pro | RoboSuite | RoboTwin 2.0 |
|---|---|---|---|---|
| MO | modular code blocks only | 54.8 | 67.5 | 41.9 |
| EO | end-to-end code blocks only | 49.5 | 60.0 | 45.6 |
| UO | coordinator trained on executed trajectories only, without paired branches | 58.5 | 75.0 | 53.8 |
| TF | no coordinator training; the coding agent chooses directly from the hybrid API library | 51.0 | 60.0 | 40.0 |
| FH | fixed handoff: modular APIs for perceive and pre-manipulate, then an E2E call | 64.5 | 82.5 | 55.6 |
| ES | one family chosen at episode start and kept throughout | 59.3 | 70.0 | 51.9 |
| RoboAware | family reselected at every P⁵ stage | 73.8 | 90.0 | 90.0 |
The authors read these results as follows: MO and EO are both lower, so the two families need to be coordinated by state; UO beats TF, so the coding agent lacks inherent awareness of execution consequences and coordinator training helps even without counterfactual data; the full method beats UO, which supports the need for paired executions from the same state. The authors call the UO gap modest, but by Table 4 it is 15.3, 15.0 and 36.2 percentage points on the three benchmarks (this site’s arithmetic). FH and ES both fall below per-stage selection. One more number stands out: EO reaches 45.6% on RoboTwin, below the standalone FastWAM (81.9%) and FasterWAM (85.6%); the text this site read does not explain the difference.
Two further analyses appear only as figures. On RoboSuite, with search budgets K of 5, 10, 20 and 50, the success-rate gains diminish as K grows; the authors take the elbow at K = 20, and under matched budgets UCB allocation beats uniform allocation. With three coding-agent backends, Claude Code (the default), Cursor and Codex, and four embodiments, Aloha-AgileX (the default), Franka-Panda, ARX-X5 and UR5-WSG, the average success-rate gap on four RoboTwin 2.0 tasks is small. The authors attribute the small gap between coding agents to P⁵, which has the agent generate only one code block at a time. The exact values for these two analyses are not in the text this site read.
How this relates to existing pages on this site
Physical AI Lab 1.7: Reinforcement Learning covers returns, values and reward shaping. RoboAware’s Qθ(x, c) estimates “the remaining skill- and task-level return after choosing family c next”, and the perception and manipulation scores in its reward are a form of shaping that depends on oracle masks and ground-truth poses in simulation. Lesson 1.7 warns that a badly written shaping term can be gamed; the text this site read gives neither the weights nor a separate analysis of how the shaping terms affect the coordinator’s choices.
Physical AI Lab 1.8: Evaluation covers paired comparison: running the same initial state under each condition so that results can be compared one to one. SCB applies the same idea to training data, comparing Mod and E2E from the same restored state at each decision point so that the two branches do not start from different states. The evaluation of the final method, however, still uses one trial per seed, and Table 3 gives success rates only, with no paired breakdown of gains and losses against the baselines.
Frontier Radar | RESETTLE also involves Harness VLA, but as the base system: RESETTLE is added on top of Harness VLA’s low-level action interface, not compared against it as a baseline. RESETTLE detects disagreement at the action-execution interface and corrects one step during execution; RoboAware decides who executes at a stage boundary, before any code is generated. The two papers use different task splits and protocols, so their numbers cannot be compared with each other.
Limitations
- This is an arXiv preprint and every number is author-reported [R]. The baselines in Table 3 were run under the authors’ protocol with cross-episode memory disabled for memory-based methods; the authors themselves note that single-turn evaluation limits the benefit of accumulated experience for memory-based methods such as CaP-X, RATS and ASPIRE. This site has not reproduced any result.
- SCB depends on simulator save–restore, oracle masks, ground-truth object poses and a terminal evaluator. In the text this site read, training and evaluation both take place in simulation; there are no real-robot experiments, and the paper does not say how paired same-state outcomes could be obtained on a real robot. Simulation results are not a hardware safety validation.
- Per Section 3.1, SCB branches are collected on scene seed 0 and testing uses seeds 1–10; the text this site read reports no results on tasks entirely absent from training. Each seed is run once, the text gives no confidence intervals, and Overall is a column mean rather than a task- or episode-weighted rate.
- Limitations stated by the authors: only modular composition and end-to-end policies are integrated so far, and extending to reinforcement learning policies, retrieval-based policies and others may need new counterfactual data and further training; responsibility changes hands only at P⁵ boundaries, so a single atomic E2E call may span several stages and leave transient failures to its internal controller until a postcondition, failure signal or timeout returns control.
- The sensitivity analyses for the budget K, coding agents and embodiments exist only as figures; the text this site read gives no values for them. The paper HTML this site read ends in the algorithm of Appendix A.2 and does not include the screening details of Appendix B or the task details of Appendix C.
Links
- RoboAware: Learning to Coordinate Embodied Skills from Counterfactual Outcomes (arXiv 2610.11480)
- Full paper in HTML
- Physical AI Lab 1.7: Reinforcement Learning — Working Out One Episode’s Return to See How a Reward Gets Gamed, Then Reading the Paper’s Terrain Curriculum and Time-out Resets
- Physical AI Lab 1.8: Evaluation — Splitting a “Net Gain of 2” into a Paired Table, Then Checking the Failure Labels and Random Seeds
- Frontier Radar | RESETTLE: step in only when a frozen policy’s two action samples keep disagreeing, then execute one demonstration-guided correction
- Physical AI Lab: a physical AI course where every number can be checked (course outline)
