acceptodds
Under review as a conference paper at ICLR 2027

RoboBranch: Branching Exploration as a New Scaling Axis for Robot-Use Agents

Abstract

General-purpose AI agents are moving from browsers and terminals to robot bodies. These robot-use agents perceive through cameras, act through navigation, perception, and manipulation tools, and improve without any weight updates by learning task guidance from interaction. However, existing agents learn from independent rollouts, which reveal only one outcome at each state they visit: testing another action means replaying a similar trajectory and reaching a state that differs in both context and action. This raises a question: can a robot-use agent learn from many outcomes of the same state, rather than one outcome of many states? We answer it with RoboBranch, the first framework that makes branching exploration in simulation a new scaling axis for robot-use agents, featuring three designs: (i) Shared-State Branching, which executes multiple candidate actions from identical copies of each decision state; (ii) Outcome-Grounded Guidance Learning, which revises task guidance from every outcome, selected or not, successful or failed; and (iii) Width-Scalable Runtime, which proposes all candidates in one response and executes branches in parallel, so that wider exploration yields more outcomes without a proportional increase in wall-clock time. Across LIBERO-Pro, RoboCasa365, and RoboTwin C2R, RoboBranch improves over Harness VLA built on the same open-source Qwen model by 10.6 points on average and brings the open-source agent into the range of proprietary agents built on Claude Code and Codex. We show that simulation can do more than run additional trajectories: it lets an agent learn more from every state it reaches.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Embodied Agents, Agent, Robotics, Multimodal

Reviews

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

This paper proposes RoboBranch, a framework that improves task success on robotic benchmarks by 1. allowing each state in the robot simulation environment to be snapshotted and hence can be used to execute >1 actions for exploration; 2. prompting the backbone model to revise the task guidance (i.e., hints) using these explored branches; and 3. after N iterations, the final task guidance is used to solve the task in one go. The authors show that RoboBranch outperforms strong baselines such as equipping Qwen with Harness VLA, and also brings open-source agent performance near proprietary agents built on Claude Code and Codex.

Critical strengths
  • The writing is clear and easy to follow. The proposed method (RoboBranch) is generally intuitive and sound.
  • The experiment and baseline setups are sound. Since RoboBranch uses "more compute" as it additionally branches per state, the authors performed additional comparisons with independent rollouts matching the compute (Section 5.4) as well as efficiency analysis (Section 5.5) to ensure a fair comparison.
  • The overall positive results on multiple benchmarks such as LIBERO-Pro and RoboCasa365 shows the effectiveness of the proposed methods compared to strong baselines such as Harness VLA and proprietary agents build with Claude Code or Codex.
Critical weaknesses
  1. The idea of using branching to improve exploration or subsequently used for reflection (e.g., revising the task guidance) is established in prior work such as [1] and [2]. The authors should provide a more detailed comparison against these methods in the related work.

  2. The idea of branching requires snapshots (for backtracking and exploring alternatives). This is applicable only to simulated environments such as the ones used in this paper. How could the author extend this to scenarios where the environment cannot be easily snapshot/restored (e.g., robot rollouts in physical world)?

References

[1] Zhang, Kai, et al. "Agent learning via early experience." arXiv preprint arXiv:2510.08558 (2025).

[2] Yu, Xiao, et al. "Exact: Teaching ai agents to explore with reflective-mcts and exploratory learning." International Conference on Learning Representations. Vol. 2025. 2025.

Questions for authors
  • Generally speaking, search like methods requires a decently strong model (as errors in certain components such as reflection can easily compound and bottleneck the whole system). Have the authors tried RoboBranch with other smaller models, and I wonder what is the minimum model size for RoboBranch to be effective?
1 comment
AuthorsOpenReview ↗

Response to Reviewer zogt

We thank the reviewer for the valuable feedback and acknowledgments of:

  • Clear and sound method: the writing "is clear and easy to follow", and RoboBranch is "generally intuitive and sound".
  • Fair comparison under matched compute: "comparisons with independent rollouts matching the compute (Section 5.4) as well as efficiency analysis (Section 5.5) to ensure a fair comparison".
  • Effectiveness against strong baselines: results on multiple benchmarks show "the effectiveness of the proposed methods compared to strong baselines such as Harness VLA and proprietary agents".

W1: Comparison with Early Experience and ExACT.

RoboBranch's guidance update advances over Early Experience and ExACT in three ways: (i) Branching from the agent's own intermediate states. RoboBranch restores any state the agent reaches during exploration and tries NN actions from it, judging each by its task progress and success; Early Experience branches only from states in expert demonstrations and records only the immediate next state of each alternative action. (ii) Learning from every outcome. RoboBranch revises task guidance from the complete branch set, grouped by its shared state; Early Experience explains why the expert action beats each alternative, and ExACT reflects only on its most erroneous actions. (iii) No expert data, no weight updates, and branching only at learning time. RoboBranch keeps the agent, learner, and VLA frozen and evaluates with a single trajectory under the learned guidance, so deployment needs no state restoration and no extra search cost; Early Experience requires expert demonstrations and fine-tunes the policy, and ExACT runs tree search on every test task and further fine-tunes the model.

What is comparedWhat is learnedModel weights
ExACTActions inside a test-time reflective tree search (R-MCTS)Reflections on selected erroneous actions, plus search traces distilled into the modelUpdated
Early ExperienceAlternative actions from states of expert demonstrations, by their immediate next statesWorld-modeling and self-reflection training targetsUpdated
RoboBranchAll NN candidate actions from identical copies of the same intermediate decision stateTask guidance revised from every outcome, selected or notFrozen

We will cite Early Experience and add this comparison to the related work.

W2: Environments that cannot be snapshotted, such as physical robots.

RoboBranch needs snapshots only while learning guidance. The learned guidance is plain text that a frozen agent follows during single-trajectory execution, so it applies wherever that agent runs; RoboTwin C2R already tests this separation, since guidance is learned in the clean setting and evaluated in the randomized setting. We see three routes to physical robots:

(i) Learn in simulation, execute on hardware: learn guidance in a simulator or a digital twin of the target scene, then run the frozen agent on the robot.

(ii) Approximate restoration: for tasks with resettable scenes, re-create a decision state by resetting the scene and replaying the selected prefix.

(iii) Learned world models: branch inside a learned world model, with progress estimated from observations rather than read from the simulator (Section 6).

We will expand this discussion in Section 6.

Q1: Smaller models, and the minimum model size.

We appreciate this insightful question. We ran RoboBranch with two smaller models as both the agent and the learner on all 50 RoboTwin C2R tasks, learning from scratch with the same setting as the paper (10 candidates), and evaluated each learned guide on the same 250 held-out episodes against the same model without guidance learning:

Agent and learnerWithout guidance learningRoboBranch, Run ARun BMean
Qwen3.5-9B39.2 (98/250)44.0 (110/250)44.8 (112/250)44.4
Qwen3.8-27B50.4 (126/250)60.8 (152/250)55.6 (139/250)58.2

Minimum model size: RoboBranch remains effective down to 9B, the smallest model we tested. Guidance learning improves every model in every run: by 5.2 points on average for Qwen3.5-9B (39.2% to 44.4%) and by 7.8 points for Qwen3.8-27B (50.4% to 58.2%). At 9B, whose model fits on a single GPU, the gain is still positive, so we have not yet found a size below which RoboBranch stops helping.

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

The paper proposes RoboBranch, a mechanism for branching exploration in simulation for robot-use agents. The paper revolves around the idea that agents should learn from many outcomes of the same state instead of learning from independent rollouts. The authors achieve that by executing multiple candidate actions from identical simulator snapshots, revising task guidance from all branch outcomes, and proposing all candidates in one structured VLM response and executing branches in parallel. The method shows improvements over Harness VLA across three different benchmarks using an open-source model (Qwen) in terms of success rate.

Critical strengths

1- The idea is simple and easy to follow, and, to my knowledge, this is the first framework to systematically exploit shared-state branching for robot-use agents in simulation (an idea that had been previously explored for RL and pure language agents). The design is sound: shared-state branching ensures controlled comparisons; outcome-grounded guidance learns from all evidence, not just selected trajectories; and width-scalable runtime makes branching feasible in practice. Moreover, results of the algorithm are very strong, as RoboBranch beats Harness VLA on all benchmarks when using open-source agents.

2- Empirical evaluation is extense and complete. The paper compares against strong baselines (HarnessVLA + different agents) across three diverse benchmarks (LIBERO-Pro, RoboCasa365, and RoboTwin C2R). The paper also provides an ablation study to isolate the contribution of each component and efficiency metrics in Appendix E

Critical weaknesses

None

Questions for authors
  • Why did you choose task progress as the primary selection criterion (Algorithm 1, Line 9)? And how is "task progress" defined? Also, to me it is a bit confusing line 9 of the algorithm, which says "most task progress, preferring task success". Aren't those trajectories that have task success the ones with the most task progress?
  • How sensitive is the method to learner prompt design? Have you experimented with different guidance-learning prompts? If you have negative results on that it would be interesting to see.
  • The paper does not report the VLM parameters used to generate the candidate actions (e.g. temperature, top-k...). For reproducibility purposes, you should include that information.
  • I see you use 32 NVIDIA H100 GPUs. Is RoboBranch practical for researchers with limited resources? Have you tried the method using more modest hardware?
1 comment
AuthorsOpenReview ↗

Response to Reviewer iwmb

We thank the reviewer for the valuable feedback and acknowledgments of:

  • First systematic use of shared-state branching: "the first framework to systematically exploit shared-state branching for robot-use agents in simulation", with a design that "is sound".
  • Strong results: "results of the algorithm are very strong, as RoboBranch beats Harness VLA on all benchmarks when using open-source agents".
  • Thorough evaluation: comparisons against "strong baselines" across "three diverse benchmarks", with an ablation study "to isolate the contribution of each component".

Q1: How is task progress defined, and is Line 9 of Algorithm 1 redundant?

(i) Definition. Task progress is read from the simulator. Each benchmark exposes the intermediate conditions that its success check requires (e.g., "drawer open" or "object inside the basket"). For every branch, RoboBranch records these conditions before and after the action, and a branch makes progress when a required condition changes toward its value at success (Branch Evidence appendix, "Task-progress feedback").

(ii) Line 9 is a two-level rule. If any branch passes the environment's official success check, the selector must pick one of them. Otherwise, it picks the branch with the most supported progress toward the remaining task while preserving completed subgoals; tool completion, hand motion, or gripper closure alone do not count. The two levels are not redundant: success is a hard rule from the official check, and progress ranks the candidates at the many decision states where no branch succeeds.

(iii) Why progress. Continuing from the branch that advances the task furthest lets each exploration round reach later stages of the task, so the learner sees branch sets at those stages.

We will rewrite Line 9 as "select a successful branch if one exists; otherwise, the branch with the most task progress" and add the definition to Section 3.

Q2: Sensitivity to the learner prompt.

We evaluated two alternative guidance-learning prompts on all 50 RoboTwin C2R tasks: a concise version of the guidance-update prompt in the appendix and a reordered version. We repeated this in two independent runs. In each run, the three guides are evaluated on the same 250 held-out episodes.

Learner promptRun A (%)Run B (%)Mean of 2 (%)
Original (paper prompt)58.4 (146/250)58.4 (146/250)58.4
Concise63.2 (158/250)58.0 (145/250)60.6
Reordered58.8 (147/250)59.2 (148/250)59.0
Harness VLA + Qwen (paper)46.8

(i) The gains come from RoboBranch itself, not from prompt tuning. Across the three prompts and two runs, all six learned guides reach 58.0–63.2%, at least 11.2 points above Harness VLA + Qwen (46.8%), and the three prompt means lie within 2.2 points.

(ii) Both alternatives perform on par with or slightly above the paper prompt, which leaves further headroom for prompt refinement. We will describe both variants in the appendix.

Q3: Sampling parameters of the VLM.

Thank you for pointing this out; we will add them to the implementation details. The agent and the learner use the same Qwen3.8-Flash-Next model with temperature 1.0, top-pp 0.95, top-kk 20, repetition penalty 1.0, reasoning effort xhigh, and a 65,536-token output limit. All NN candidates come from one structured response (Section 4), so candidate diversity comes from the model proposing distinct actions within that response, not from repeated sampling.

Q4: Is RoboBranch practical with limited resources?

Yes. Here are the reasons:

(i) The 32 H100 GPUs serve all three benchmarks at once. The 125B Qwen3.8-Flash-Next model needs 8 H100s per replica; a 27B model needs 2, and a 9B model needs one.

(ii) The entire 9B learning run fits on one node. With Qwen3.5-9B as both agent and learner, learning guidance for all 50 RoboTwin C2R tasks ran on a single node with 8 H100 GPUs: one GPU serves the model, and the other seven run the simulators and the frozen VLA. Learning all 50 tasks took 49.6 hours of wall-clock time, and RoboBranch still improves this model from 39.2% to 44.4%.

(iii) Width trades GPUs for time. The runtime executes as many branches in parallel as there are simulator workers; with fewer workers, a branch set runs in more passes.

With the paper's model, the full cost of learning is at most 5.8 H100-hours per RoboTwin C2R task.

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

RoboBranch helps a robot-use agent improve through practice in a simulator. During exploration, it saves a decision state and tries several actions from separate copies of that state. It selects one resulting state to continue the task, while keeping all the outcomes for comparison. A language model then uses these successes and failures to update a written guide for the task, called task guidance. The agent and its VLA tools remain frozen; only the guide changes. During evaluation, the agent uses the completed guide and follows a single trajectory, without branching. The paper also describes how to run the branches in parallel. Across LIBERO-Pro, RoboCasa365, and RoboTwin C2R, the authors report an average improvement of 10.6 percentage points over Harness VLA using the same Qwen model (Sections 3–5).

Critical strengths
  • The method improves task performance across three robot benchmarks. The comparison with Harness VLA uses the same Qwen model, and the evaluation uses different seeds from exploration. The agent also stops branching during evaluation and uses the guide it has already learned. This shows that experience gathered during exploration can help later execution, rather than the reported gain simply coming from trying several actions at every evaluation step (Section 5.1).
  • The experiments test whether comparing actions from the same starting state is useful. In Section 5.4, the authors keep the exploration data and update schedule fixed but present the outcomes as separate transitions, without their shared starting-state grouping. Success on RoboTwin C2R falls from 57.6% to 53.6%. This supports giving the learner the outcomes together so it can compare what different actions did in the same situation. Table 3 also checks what happens when the learner sees only selected outcomes or only successful outcomes (Sections 5.3–5.4).
Critical weaknesses
  • The novelty over existing systems for learning from robot execution is not yet clear. ASPIRE already searches over multiple candidate robot programs, uses execution traces to diagnose failures, and saves validated repairs as reusable skills and in-context guidance (Lu et al., 2026). RoboBranch's more specific distinction is to restore the same intermediate simulator state, try several actions, and use the complete set of outcomes to update task guidance. This is a meaningful difference from ASPIRE's program-level search, but the paper does not isolate its benefit against that alternative under comparable conditions. AutoGuide and ExAct also provide precedents for learning guidance or reusable reflections from execution outcomes. The existing ablations show that RoboBranch benefits from its chosen inputs and grouping, but leave its incremental contribution over these prior approaches insufficiently established.
  • The evidence that more branches reliably improve performance is still limited. On RoboTwin C2R, increasing from five candidates to ten raises success from 56.4% to 57.6%, which amounts to three additional successes in 250 evaluation episodes. This may be a useful gain, but repeated runs of the full exploration and guidance-learning process are needed to show that it is stable.
Questions for authors
  • Could you compare RoboBranch more directly with ASPIRE, using the version released before the submission deadline? Please explain what Shared-State Branching and Outcome-Grounded Guidance Learning add beyond ASPIRE's search over candidate programs and reuse of validated repair knowledge. A controlled comparison using the same base model, compatible robot tools, exploration budget, and held-out evaluation would help show whether branching from the same intermediate state improves success or exploration efficiency over an ASPIRE-style approach. Since the systems expose different interfaces, please make any necessary adaptations explicit. Could you also clarify how the guidance update differs from the outcome-based updates in AutoGuide and ExAct?
  • How many independent task-guidance learning runs support each branch width and ablation? Could you report paired or task-clustered uncertainty, particularly for five versus ten candidates and the removal of shared origin? For the Width-Scalable Runtime, what is the total exploration time or GPU-hour cost including continuation selection and guidance updates, beyond the proposal-plus-rollout measurements?
3 comments
AuthorsOpenReview ↗

Response to Reviewer 1pcA (1/3): Controlled Comparison with ASPIRE

We thank the reviewer for the valuable feedback and acknowledgments of:

  • Consistent gains under a fair comparison: RoboBranch "improves task performance across three robot benchmarks", using "the same Qwen model" as Harness VLA and "different seeds from exploration".
  • Gains come from learned experience: "experience gathered during exploration can help later execution", rather than "trying several actions at every evaluation step".
  • Validated shared-state design: Shared-state grouping raises RoboTwin C2R success from 53.6% to 57.6%, which "supports giving the learner the outcomes together".

Q1 & W1: Controlled comparison with ASPIRE.

Under a controlled comparison on LIBERO-Pro, RoboBranch reaches 77.8%, versus 71.6% for the full ASPIRE pipeline, which uses more adaptation tokens (21.3M vs. 18.6M), and 59.0% for ASPIRE's fix loop. Following the protocol suggested by the reviewer, we ran the ASPIRE version released before the submission deadline (NVlabs/ASPIRE, commit 7ba73d3, Aug. 21, 2026; arXiv v1, Jun. 30, 2026):

(i) Same base model. Both methods use the same Qwen3.8-Flash-Next server (ASPIRE originally uses Claude Opus), and ASPIRE runs with its original prompts.

(ii) Same held-out evaluation. All 80 LIBERO-Pro tasks (8 splits) are evaluated on exactly the 800 held-out episodes of our main table (official initial states 1–10). ASPIRE develops on instances 11–25 and validates on instances 26–40, kept separate from evaluation by the environment. RoboBranch's guides are those of the paper, re-evaluated together with ASPIRE in the same environment and under the same conditions (77.8%; the paper's 73.4% included episodes that timed out under cluster load), and we will update Table 1.

(iii) The full ASPIRE pipeline with its full budget. We run the fix loop, skill promotion, and evolutionary search (K=8K=8, up to 5 iterations) on every task below 80%, and select programs on the validation set, all following ASPIRE's own rules and with the full budget the pipeline requests.

(iv) Native robot interfaces. Both methods act in the same simulator with the same camera observations. ASPIRE keeps its own perception and planning API (SAM3, Contact-GraspNet, PyRoKi IK), and RoboBranch uses its VLA executor.

(v) Minimal adaptations to run ASPIRE in this setting. With ASPIRE's original mechanism unchanged, we made the following adaptations so that it can run in this setting: (a) The Qwen server provides an Anthropic-compatible API, and a thin adapter translates the few Claude-specific request fields it does not support, with the prompt content kept as is. (b) ASPIRE's coordinator dispatches its sub-agents as background tasks, which the Claude Code runtime stops after 10 minutes. We therefore run the sub-agents in the foreground, so every replay runs to completion. (c) Environments reset to LIBERO-Pro's official initial states and ASPIRE's seed ranges are remapped as in (ii), so ASPIRE is evaluated on exactly our held-out episodes. The revised appendix will list every change.

Method (same Qwen model)Adaptation input tokens / task (median)Task-macro success, 8 splits (%)
ASPIRE, fix loop14.4M59.0
ASPIRE, full (with evolutionary search)21.3M71.6
RoboBranch18.6M77.8 (+18.8 over the fix loop)

Tokens are all input tokens (uncached plus cache reads) of every model request made while learning each task, counted the same way for both methods.

RoboBranch outperforms the full ASPIRE pipeline by 6.2 points with fewer tokens. Even with its evolutionary search, which raises ASPIRE's cost to 21.3M tokens, the full pipeline remains below RoboBranch (71.6 vs. 77.8 at 18.6M), with the largest gains on goal (+13.5), object (+8.0), and LIBERO-10 (+4.5). The fix loop alone is 18.8 points lower.

LIBERO-ProObject swapObject taskGoal swapGoal taskSpatial swapSpatial taskLIBERO-10 swapLIBERO-10 taskAvg.
ASPIRE, fix loop897757526662333659.0
ASPIRE, full938469627885485471.6
RoboBranch979680788278456677.8
AuthorsOpenReview ↗

Response to Reviewer 1pcA (2/3): Comparison with Prior Work, Independent Runs and Uncertainty

Q1 (cont.): How does the guidance update differ from ASPIRE, AutoGuide, and ExACT?

RoboBranch's guidance update advances over prior work in three ways: (i) Same-state branching instead of independent rollouts. RoboBranch restores one intermediate state and tries NN actions from it, so the outcomes differ only in the action; ASPIRE executes each candidate program from the task's initial state, so its candidates are compared over whole episodes, and AutoGuide contrasts a successful and a failed trajectory from independent rollouts of the same task. (ii) Learning from every outcome. RoboBranch revises task guidance from the complete branch set, grouped by its shared state; ASPIRE keeps only validated repairs, as reusable skills and in-context guidance, AutoGuide learns from one trajectory pair at a time, and ExACT reflects only on its most erroneous actions. (iii) Branching only at learning time. RoboBranch evaluates with a single trajectory under the learned guidance, so deployment needs no state restoration and no extra search cost; ExACT runs tree search on every test task and further fine-tunes the model.

What is comparedWhat is learnedModel weights
ASPIREWhole candidate programs, each executed from the task's initial stateA repaired task program, plus validated repairs kept as reusable skills and in-context guidanceFrozen
AutoGuideA successful and a failed trajectory of the same task, from independent offline rolloutsContext-conditioned guidelines retrieved at test timeFrozen
ExACTActions inside a test-time reflective tree search (R-MCTS)Reflections on selected erroneous actions, plus search traces distilled into the modelUpdated
RoboBranchAll NN candidate actions from identical copies of the same intermediate decision stateTask guidance revised from every outcome, selected or notFrozen

Grouping outcomes by their shared state improves the learned guidance. Grouping cuts the run-to-run standard deviation (SD) from 3.2 to 0.5 points and raises RoboTwin C2R success from 56.8% to 58.1% on average over three independent runs (53.6% to 57.6% in the paper run; Q2 below).

We will include this comparison in the revision.

Q2 & W2: Independent runs, and uncertainty for 5 vs. 10 candidates and shared-origin removal.

For this response, we reran the full exploration and guidance-learning process on all 50 RoboTwin C2R tasks twice (reruns A and B, different exploration seeds) for 10 candidates, 5 candidates, and the no-shared-origin variant, learning from scratch with the same setting as the paper. Every frozen guide is evaluated on the same 250 held-out episodes.

(i) Three independent learning runs per setting. Width 10, width 5, and no shared origin each have three independent learning runs: the paper's run and two reruns. Success is over 250 episodes per run.

Setting (RoboTwin C2R)Paper run (%)Rerun A (%)Rerun B (%)Mean of 3 (%)SD
10 candidates (full)57.658.4 (146/250)58.4 (146/250)58.10.5
5 candidates56.457.2 (143/250)54.0 (135/250)55.91.7
No shared origin53.656.8 (142/250)60.0 (150/250)56.83.2

(ii) Paired, task-clustered bootstrap (50 tasks) of the full method against each variant. A single run has 250 episodes, so per-run intervals are about ±6 points wide; the conclusions below therefore rest on all three runs:

Full method vs.Rerun A: diff. (95% CI)Rerun B: diff. (95% CI)
5 candidates+1.2 [−5.2, +7.6]+4.4 [−2.4, +11.2]
No shared origin+1.6 [−4.0, +7.6]−1.6 [−8.0, +4.8]

(iii) Ten candidates outperform five candidates in all three runs, by +2.3 points on average (+1.2, +1.2, +4.4).

(iv) Shared-state grouping makes guidance learning both better and more stable. It raises mean success from 56.8% to 58.1% and reduces the run-to-run SD from 3.2 to 0.5 points: without grouping, the quality of the learned guidance is left to chance, and a single run may land high or low.

We will add these runs and intervals to the appendix.

AuthorsOpenReview ↗

Response to Reviewer 1pcA (3/3): Exploration Time and GPU-Hours

Q2 (cont.): Total exploration time and GPU-hours, including continuation selection and guidance updates.

Thank you for the question. The table reports serial hours (each task's elapsed time, summed over the 50 RoboTwin C2R tasks), learning from scratch with the same setting as the paper:

SettingProposal + rolloutContinuation selectionGuidance updateSetup & otherTotal
10 candidates53.424.453.018.9149.7
5 candidates49.328.348.618.4144.6

(i) Time. With 10 candidates, learning guidance takes 3.0 serial hours per task, of which continuation selection takes 0.49 h and guidance updates take 1.06 h.

(ii) Doubling the branch width adds almost no cost. Ten candidates take 149.7 serial hours versus 144.6 for five (+3.5%), because one structured response proposes the full candidate set and the branches run in parallel simulators (Section 4).

(iii) GPU-hours (NVIDIA H100 80GB). Learning guidance with 10 candidates for all 50 tasks costs 288.8 H100-hours, or 5.8 per task, with every phase included. This is a conservative upper bound: we charge every reserved GPU for its whole wall-clock span, including idle time:

SettingSimulator + VLALLMTotal GPU-hPer task
10 candidates168.4120.4288.85.8

(iv) Summary. Learning guidance for all 50 RoboTwin C2R tasks with 10 candidates costs at most 289 H100-hours (5.8 per task) with every phase included. We will add this accounting to the appendix.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.