acceptodds
Under review as a conference paper at ICLR 2027

Task-Graph-Guided Demonstration Generation for Multi-Robot Manipulation

Abstract

Learning visuomotor policies for long-horizon multi-robot manipulation requires demonstrations that capture both reliable object interaction and inter-robot coordination. However, collecting coordinated demonstrations through human teleoperation can be costly and increasingly difficult as the number of robots grows. Script-based demonstrations can reduce reliance on human operators, but they impose synchronization that introduces unnecessary waiting. We present Graph2Demo, a task-graph-guided demonstration-generation framework that combines symbolic planning with residual reinforcement learning. Given a task specification in PDDL, Graph2Demo utilizes a task graph to encode the plan into per-agent subtask sequences and inter-agent dependencies, allowing robots to progress independently and synchronize when needed. To guide subtask execution, the task graph provides target poses for a pretrained pose-reaching base policy and subtask-specific rewards for learning a residual policy to correct the action for object interaction. By combining the base policy and the residual policy, we could generate demonstrations for multi-robot manipulation tasks. Averaged across the 11 tasks from the RoboFactory benchmark, diffusion policies trained on Graph2Demo demonstrations achieve higher success rates than those trained on demonstrations from the baselines, highlighting the potential of task-graph-guided demonstration generation for multi-robot manipulation.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Multi-robot manipulation, residual reinforcement learning, long-horizon tasks, PDDL

Reviews

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

Graph2Demo converts PDDL plans into per-robot subtasks and inter-robot dependencies that select target poses, rewards, and synchronization conditions. State-based residual RL builds on a shared pretrained reaching policy to generate demonstrations for per-agent visuomotor diffusion policies. Evaluation covers all eleven RoboFactory tasks with up to four robots in simulation.

Critical strengths
  • The framework provides a practical integration of dependency-aware coordination and residual learning. Explicit dependencies permit independent progress while coordinating joint subtasks, and the shared reaching policy supports reuse across tasks and robots.
  • Generated demonstrations improve average downstream success across the full benchmark, with substantial gains on several difficult multi-robot tasks and shorter successful rollouts. Three independent runs, matched demonstration counts and policy-training settings, and script baselines with noise and asynchronous execution strengthen the empirical evidence.
Critical weaknesses
  • The graph's contribution is not isolated from reward shaping. Removing it also removes intermediate rewards, so the ablation's failure may reflect sparse-reward exploration rather than the specific dependency representation. Alternative scheduling or hierarchical RL with matched targets and rewards would better establish the benefit of the graph design.
  • Practical costs and reliability need further characterization. The method requires PDDL specifications, annotated interaction poses, predicate checkers, and reward functions, plus 100 million residual-training transitions per task. Engineering effort and total generation cost relative to scripting are insufficiently quantified. Substantial regressions on Camera Alignment and Take Photo also lack a failure analysis; shorter completion times conditioned on success do not resolve the reliability tradeoff.
Questions for authors

N/A

5 comments

We thank the reviewer for the thoughtful comments on the ablation, engineering costs and performance regression. We address these concerns below.

W1: The graph's contribution is not isolated from reward shaping.

We agree that the original ablation confounds dependency-aware execution with intermediate reward shaping. To isolate the contribution of the dependency-aware coordination, we added two ablations:

  1. Global Sequential: Subtasks are executed in the order induced by the PDDL plan, with subtasks belonging to the same joint action executed concurrently.
  2. Global Synchronization: Subtasks are assigned to each agent in the order induced by the PDDL plan. Agents execute their k-th subtasks concurrently, and advance to the next subtask only after the k-th subtasks of all agents are completed. Agents with no remaining subtasks are excluded from the synchronization barrier.

Both ablations retain the same subtask rewards and target poses as Graph2Demo. For each ablation, we train residual policies, collect 150 successful demonstrations, and train diffusion policies using the same procedure as Graph2Demo. The table below reports downstream diffusion policy success rates and mean completion steps over successful episodes:

TaskMetricGraph2DemoGlobal SequentialGlobal Synchronization
Take PhotoSuccess rate (%) ↑48.3 ± 3.846.0 ± 2.528.2 ± 4.2
Completion steps ↓38.4 ± 0.753.0 ± 1.644.9 ± 1.2
Three Robots Stack CubeSuccess rate (%) ↑65.7 ± 2.318.5 ± 0.543.1 ± 1.4
Completion steps ↓62.3 ± 1.9140.8 ± 3.486.6 ± 2.5

Since both ablations retain the subtask rewards and target poses, the residual policy can be trained to collect the demonstrations. However, the resulting downstream diffusion policies perform worse than those trained with Graph2Demo demonstrations. Global Sequential produces substantially longer trajectories. This limitation is particularly pronounced in Three Robots Stack Cube, where simultaneous grasping by multiple grippers is beneficial. Global Synchronization introduces unnecessary waiting. For example, an agent that has completed its current subtask must wait for all other agents before proceeding, even when all dependencies of its next subtask are satisfied. In contrast, Graph2Demo’s dependency-aware coordination allows agents to execute independent subtasks concurrently and advance asynchronously as soon as their dependencies are satisfied.

We will replace the “w/o Task Graph” ablation with these newly added ablations in the revised manuscript.

W2 (a): Engineering effort and total generation cost

We apologize for not making the engineering effort explicit in the paper.

PDDL domain and predicates

Our shared PDDL domain comprises 16 predicates and 14 action schemas across all 11 RoboFactory tasks and took approximately 10 hours for writing and debugging. We also implement state-based checkers for 8 out of the 16 predicates, while the remaining predicates are only used for symbolic planning. We implemented these checkers largely by adapting ManiSkill3’s built-in methods or success evaluation code, e.g., the holding predicate checker reuses ManiSkill’s is_grasping method. We do not design additional dense rewards for each subtask and only use predicate satisfaction bonuses.

Annotated assets

For annotations, we reuse the object annotations released with RoboFactory without introducing new ones. These annotations define contact and functional frames for computing end-effector targets and can be reused across tasks involving the same objects. RoboTwin also provides publicly available annotated assets, which can be used or extended when introducing new objects.

Per-task marginal effort

For tasks covered by the shared domain, specifying the initial and goal states in predicates takes 5 minutes on average. Connecting the symbolic object names to simulator objects is straightforward and only takes approximately 1–2 minutes per task. Once the task is specified, the PDDL planner automatically comes up with a symbolic plan with the fewest actions. The resulting task graph selects annotation-derived target poses and provides predicate-based subtask rewards, which can be derived from the predicate checkers and annotated assets.

Training and demonstration collection costs

For RL training, we use a GPU-accelerated simulator, i.e., ManiSkill 3, to maximize the throughput. Using one RTX 3090 GPU, residual policy training averaged 6.5 hours per task. The shared base policy requires an additional 2 hours to pretrain once. After training, collecting 150 successful demonstrations with 32 parallel environments takes an average of 5.3 minutes per task. This is due to the high success rate and low trajectory length of the residual policy trained via RL.

Comparison against script-based demonstration generation

Graph2Demo incurs an additional cost for residual policy training, but the trained policies enable demonstration collection across parallel environments in GPU-accelerated simulation. During the collection of the 150 demonstrations, the RL-trained residual policies achieved a 100% success rate, with no rejected rollouts. With parallel execution and reliable rollout generation, Graph2Demo collects 150 successful demonstrations in 5.3 minutes on average across all 11 tasks, compared with 1 hour and 47 minutes on average for one task using the original RoboFactory scripts.

W2 (b): Substantial regressions on Camera Alignment and Take Photo lack a failure analysis

Thanks for highlighting this issue. We evaluate the teacher used for demonstration generation and the students trained on these demonstrations on the same held-out seeds. The teachers achieved 100100\\% success on both tasks, whereas the students achieved 53.053.0\\% on Camera Alignment and 48.348.3\\% on Take Photo. This indicates that the regression arises primarily during student policy distillation and execution, rather than from teacher failures on these evaluation episodes.

We further inspected the rendered teacher and student rollouts on Camera Alignment and Take Photo tasks, and observed that the students learn aggressive gripper motions from the teacher. In failed student rollouts, these aggressive motions lead to collisions with the camera, unstable grasping, or dropping the camera during grasping. To verify this, we add a smoothness penalty to the teacher's reward for each robot, i.e., −0.01∥ati−at−1i∥22-0.01 \lVert a_t^i-a_{t-1}^i \rVert_2^2, to encourage smooth motion, and then collect new demonstrations and retrain the student policies.

The success rate (%) for the students trained on smoothness-penalized demonstrations is shown below:

TaskOriginal teacherStudent trained on original demonstrationsStudent trained on smoothness-penalized demonstrations
Camera Alignment100.0 ± 0.053.0 ± 3.086.2 ± 2.2
Take Photo100.0 ± 0.048.3 ± 3.862.9 ± 2.6

The smoothness penalty improves student success by 33.233.2\\% on Camera Alignment and 14.614.6\\% on Take Photo. These results support teacher motion style as a contributing factor to the student's performance regression, and narrow the gap relative to the strongest scripted baselines.

If the authors have addressed your concerns or provided clarifications, please join the discussion to indicate whether your concerns have been resolved or if you have any further questions.

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

This paper presents Graph2Demo, a framework for generating demonstrations for multi-robot manipulation. A PDDL plan is converted into per-agent subtask sequences and inter-agent dependencies. The resulting task graph selects annotation-derived end-effector targets, defines subtask rewards, and controls subtask progression. A shared, frozen pose-reaching policy provides base actions, while separate residual policies are trained with IPPO using simulator state. Successful trajectories from these state-based policies are then used to train separate visual diffusion policies for each robot. On all 11 RoboFactory tasks, using 150 successful demonstrations per task and source, Graph2Demo achieves a reported mean downstream success rate of 77.1%, compared with 60.5% for the strongest scripted source on average, and leads on 7 tasks. The paper also reports shorter demonstration trajectories and successful policy rollouts, together with teacher-training ablations on four tasks.

Critical strengths
  1. The evaluation measures the utility of generated demonstrations for downstream learning. The paper evaluates separately trained visual diffusion policies rather than relying only on the success of privileged-state teachers. It covers all 11 RoboFactory tasks with one to four robots, uses matched demonstration counts and student-training settings, and reports means and standard deviations over three runs. The improvement from 60.5% to 77.1% is substantial, particularly on Pass Shoe, Three Robots Stack Cube, and Long Pipeline Delivery (Table 1).

  2. The system provides a coherent interface between task structure and low-level learning. The same task representation supplies prerequisites, intermediate rewards, and pose targets, while a reusable reaching policy reduces the motion-exploration burden. The noise and asynchronous-script baselines are useful controls, and the paper explicitly reports tasks on which the proposed demonstrations perform worse.

Critical weaknesses
  1. Confounded ablation. The “w/o Task Graph” ablation also removes intermediate rewards, making it difficult to distinguish the benefit of dependency-aware execution from that of reward shaping.

  2. Unquantified engineering cost. The paper does not quantify the effort required to specify PDDL models, predicate checks, and rewards, or demonstrate whether the resulting benefits justify this effort relative to scripted or automatically generated demonstrations.

  3. Unexplained performance regressions. Success rates on Camera Alignment and Take Photo are respectively 46 and 31 percentage points below the strongest scripted variants. These substantial regressions on coordination tasks warrant failure analysis beyond their acknowledgment.

  4. Limited external comparisons. The experimental baselines are largely restricted to variants of RoboFactory scripts. Comparisons with external automated generation methods, such as Graph-as-Policy or RoboTwin 2.0, on a feasible shared subset would better establish the method’s distinctive value.

I would be willing to raise my raitng if the authors can clarify these issues.

Questions for authors
  1. Isolating coordination: Can you compare dependency-aware execution with sequential/global synchronization while retaining identical subtask rewards, pose targets, reaching priors, and RL budgets? What exactly remains active in “w/o Task Graph”? A base-only condition would further clarify the residual policy's contribution.

  2. Engineering cost and reuse: How much active person-time and debugging were required for the shared PDDL domain/action schemas, each task problem, new annotations/mappings, predicate checks, and rewards? Which are inherited versus newly authored? How does the marginal cost of obtaining 150 successful demonstrations for a new task compare with writing or generating a script, including RL compute, LLM calls where applicable, and rejected rollouts?

  3. Severe regressions: What causes the 44.7–46.0-point Camera Alignment deficit and the 31.0-point Take Photo deficit relative to the strongest scripted variant? Please provide teacher and student performance on identical held-out episodes, and failure categories that distinguish teacher generalization failures from visual-policy imitation and coordination failures. Which proposed explanation is supported by a targeted experiment?

  4. External comparison: How does Graph2Demo differ in capability, authoring effort and total generation cost from automatically synthesized execution graphs such as GaP, or RoboTwin 2.0's expert-code pipeline? Can you evaluate a feasible shared subset, then train the same visual students on matched numbers of accepted demonstrations? Please specify the source version, required skills/adapters, information and control assumptions, and refinement budget. For GaP in particular, distinguish its paper's research capabilities from its public-beta limitations when explaining what can be reproduced.

  5. Real-World Evaluation: While Graph2Demo primarily targets simulation-based demonstration generation, could the authors provide a small-scale real-world evaluation of visual policies trained on the generated demonstrations, ideally on a representative multi-robot task? This would help establish whether the reported benefits translate into practical improvements in physical robot coordination.

7 comments

We thank the reviewer for the detailed and constructive feedback on our ablations, engineering costs, performance regressions, and evaluation scope. We address each concern below.

W1/Q1: Confounded ablation

We acknowledge that the current ablation does not fully isolate the contribution of the task-graph execution from reward shaping. In the original “w/o Task Graph” ablation, we retain the residual policy architecture and subtask target, but remove the subtask reward. To isolate the contribution of the dependency-aware coordination, we added two ablations:

  1. Global Sequential: Subtasks are executed in the order induced by the PDDL plan, with subtasks belonging to the same joint action executed concurrently.
  2. Global Synchronization: Subtasks are assigned to each agent in the order induced by the PDDL plan. Agents execute their k-th subtasks concurrently, and advance to the next subtask only after the k-th subtasks of all agents are completed. Agents with no remaining subtasks are excluded from the synchronization barrier.

To assess the benefit of the residual policy architecture, we also added a base-only ablation, which removes the residual policy and directly fine-tunes the pretrained base policy using the same rewards.

All ablations retain the same subtask rewards and target poses as Graph2Demo. For each ablation, we train demonstration-generating policies using the same RL budget and base policy initialization, collect 150 successful demonstrations, and train diffusion policies using the same procedure as Graph2Demo. The table below reports downstream diffusion policy success rates and mean completion steps over successful episodes:

TaskMetricGraph2DemoGlobal SequentialGlobal SynchronizationBase-only
Take PhotoSuccess rate (%) ↑48.3 ± 3.846.0 ± 2.528.2 ± 4.244.4 ± 1.3
Completion steps ↓38.4 ± 0.753.0 ± 1.644.9 ± 1.284.5 ± 3.5
Three Robots Stack CubeSuccess rate (%) ↑65.7 ± 2.318.5 ± 0.543.1 ± 1.450.9 ± 1.3
Completion steps ↓62.3 ± 1.9140.8 ± 3.486.6 ± 2.5120.0 ± 3.5

Since all the ablations retain the subtask rewards and target poses, the residual policy can be trained to collect the demonstrations. However, the resulting downstream diffusion policies perform worse than those trained with Graph2Demo demonstrations. Global Sequential produces substantially longer trajectories. This limitation is particularly pronounced in Three Robots Stack Cube, where simultaneous grasping by multiple grippers is beneficial. Global Synchronization introduces unnecessary waiting. For example, an agent that has completed its current subtask must wait for all other agents before proceeding, even when all dependencies of its next subtask are satisfied. In contrast, Graph2Demo’s dependency-aware coordination allows agents to execute independent subtasks concurrently and advance asynchronously as soon as their dependencies are satisfied.

The base-only ablation shows that directly fine-tuning the pretrained base policy can also generate useful demonstrations. However, the residual policy yields shorter successful downstream rollouts on both tasks and a higher observed success rate. These results support the benefit of retaining a frozen reaching prior and learning separate residual corrections.

We will replace the “w/o Task Graph” ablation with these newly added ablations in the revised manuscript.

W2/Q2: Unquantified engineering cost

We apologize for not making the engineering cost explicit in the paper.

PDDL domain and predicates

Our shared PDDL domain comprises 16 predicates and 14 action schemas across all 11 RoboFactory tasks and took approximately 10 hours for writing and debugging. We also implement state-based checkers for 8 out of the 16 predicates, while the remaining predicates are only used for symbolic planning. We implemented these checkers largely by adapting ManiSkill3’s built-in methods or success evaluation code, e.g., the holding predicate checker reuses ManiSkill’s is_grasping method. We do not design additional dense rewards for each subtask and only use predicate satisfaction bonuses.

Annotated assets

For annotations, we reuse the object annotations released with RoboFactory without introducing new ones. These annotations define contact and functional frames for computing end-effector targets and can be reused across tasks involving the same objects. RoboTwin also provides publicly available annotated assets, which can be used or extended when introducing new objects.

Per-task marginal effort

For tasks covered by the shared domain, specifying the initial and goal states in predicates takes 5 minutes on average. Connecting the symbolic object names to simulator objects is straightforward and only takes approximately 1–2 minutes per task. Once the task is specified, the PDDL planner automatically comes up with a symbolic plan with the fewest actions. The resulting task graph selects annotation-derived target poses and provides predicate-based subtask rewards, which can be derived from the predicate checkers and annotated assets.

Training and demonstration collection costs

For RL training, we use a GPU-accelerated simulator, i.e., ManiSkill 3, to maximize the throughput. Using one RTX 3090 GPU, residual policy training averaged 6.5 hours per task. The shared base policy requires an additional 2 hours to pretrain once. After training, collecting 150 successful demonstrations with 32 parallel environments takes an average of 5.3 minutes per task. This is due to the high success rate and low trajectory length of the residual policy trained via RL.

Comparison against script-based demonstration generation

Graph2Demo incurs an additional cost for residual policy training, but the trained policies enable demonstration collection across parallel environments in GPU-accelerated simulation. During the collection of the 150 demonstrations, the RL-trained residual policies achieved a 100% success rate, with no rejected rollouts. With parallel execution and reliable rollout generation, Graph2Demo collects 150 successful demonstrations in 5.3 minutes on average across all 11 tasks, compared with 1 hour and 47 minutes on average for one task using the original RoboFactory scripts.

We discuss the adaptation and graph-refinement effort for GaP in our response to W4/Q4 below.

W3/Q3: Unexplained performance regressions

Thanks for highlighting this issue. We evaluate the teacher used for demonstration generation and the students trained on these demonstrations on the same held-out seeds. The teachers achieved 100100\\% success on both tasks, whereas the students achieved 53.053.0\\% on Camera Alignment and 48.348.3\\% on Take Photo. This indicates that the regression arises primarily during student policy distillation and execution, rather than from teacher failures on these evaluation episodes.

We further inspected the rendered teacher and student rollouts on Camera Alignment and Take Photo tasks, and observed that the students learn aggressive gripper motions from the teacher. In failed student rollouts, these aggressive motions lead to collisions with the camera, unstable grasping, or dropping the camera during grasping. To verify this, we add a smoothness penalty to the teacher's reward for each robot, i.e., −0.01∥ati−at−1i∥22-0.01 \lVert a_t^i-a_{t-1}^i \rVert_2^2, to encourage smooth motion, and then collect new demonstrations and retrain the student policies.

The success rate (%) for the students trained on smoothness-penalized demonstrations is shown below:

TaskOriginal teacherStudent trained on original demonstrationsStudent trained on smoothness-penalized demonstrations
Camera Alignment100.0 ± 0.053.0 ± 3.086.2 ± 2.2
Take Photo100.0 ± 0.048.3 ± 3.862.9 ± 2.6

The smoothness penalty improves student success by 33.233.2\\% on Camera Alignment and 14.614.6\\% on Take Photo. These results support teacher motion style as a contributing factor to the student's performance regression, and narrow the gap relative to the strongest scripted baselines.

Reviewer_vPZzOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents Graph2Demo, which converts PDDL plans into task graphs to guide residual RL for multi-robot demonstration generation. The method combines a pretrained reaching policy with learned residual actions, and its demonstrations improve the average success rate of diffusion policies to 77.1% across 11 RoboFactory tasks.

Critical strengths

The paper evaluates demonstration quality through downstream visuomotor policy performance, which directly supports its main goal. The improvements are substantial on several difficult tasks and the generated demonstrations also lead to faster successful execution.

Critical weaknesses

The current ablations do not fully isolate the contribution of task-graph coordination, since removing the graph also changes the reward structure.

Questions for authors

Could the authors clarify whether graph-based execution improves performance when intermediate rewards and target-pose guidance are kept the same?

3 comments

We thank the reviewer for the thoughtful comments on the ablation. We address the concerns below.

W1/Q1: The current ablations do not fully isolate the contribution of task-graph coordination. How does graph-based execution improve performance?

We agree that the original ablation confounds dependency-aware execution with intermediate reward shaping. To isolate the contribution of the dependency-aware coordination, we added two ablations:

  1. Global Sequential: Subtasks are executed in the order induced by the PDDL plan, with subtasks belonging to the same joint action executed concurrently.
  2. Global Synchronization: Subtasks are assigned to each agent in the order induced by the PDDL plan. Agents execute their k-th subtasks concurrently, and advance to the next subtask only after the k-th subtasks of all agents are completed. Agents with no remaining subtasks are excluded from the synchronization barrier.

Both ablations retain the same subtask rewards and target poses as Graph2Demo. For each ablation, we train residual policies, collect 150 successful demonstrations, and train diffusion policies using the same procedure as Graph2Demo. The table below reports downstream diffusion policy success rates and mean completion steps over successful episodes:

TaskMetricGraph2DemoGlobal SequentialGlobal Synchronization
Take PhotoSuccess rate (%) ↑48.3 ± 3.846.0 ± 2.528.2 ± 4.2
Completion steps ↓38.4 ± 0.753.0 ± 1.644.9 ± 1.2
Three Robots Stack CubeSuccess rate (%) ↑65.7 ± 2.318.5 ± 0.543.1 ± 1.4
Completion steps ↓62.3 ± 1.9140.8 ± 3.486.6 ± 2.5

Since both ablations retain the subtask rewards and target poses, the residual policy can be trained to collect the demonstrations. However, the resulting downstream diffusion policies perform worse than those trained with Graph2Demo demonstrations. Global Sequential produces substantially longer trajectories. This limitation is particularly pronounced in Three Robots Stack Cube, where simultaneous grasping by multiple grippers is beneficial. Global Synchronization introduces unnecessary waiting. For example, an agent that has completed its current subtask must wait for all other agents before proceeding, even when all dependencies of its next subtask are satisfied. In contrast, Graph2Demo’s dependency-aware coordination allows agents to execute independent subtasks concurrently and advance asynchronously as soon as their dependencies are satisfied.

We will replace the “w/o Task Graph” ablation with these newly added ablations in the revised manuscript.

Thanks for the update. The new ablations address my concern by isolating the effect of task-graph coordination, so I’m raising my rating from 2 to 3.

We thank the reviewer for the reassessment and are glad that the new ablations have addressed your concern.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Summary of the changes to the updated manuscript

We thank the reviewers for their constructive feedback. We have revised the manuscript to address the raised concerns. The main changes are:

  • Expanded ablation study. To distinguish the contribution of dependency-aware coordination from reward shaping, we added ablations on dependency-aware coordination alongside an ablation on residual policy architecture. We report training success over three independent runs and add downstream diffusion-policy success rates and completion steps on Take Photo and Three Robots Stack Cube.
  • Added failure analysis. We analyze the teacher–student performance gap on Camera Alignment and Take Photo and examine representative failure cases.
  • Documented authoring effort and computational costs. A new appendix section details PDDL, predicate, and checker development, reuse of asset annotations, per-task setup, policy training, and demonstration collection.
  • Clarified benchmark tasks. A new appendix table summarizes all 11 RoboFactory tasks, their robot counts, and success conditions.

We have further revised the manuscript to improve its positioning. The changes in this revision are summarized below:

  1. Clarified the core contribution (Introduction, page 2, lines 83–93). Stressed that Graph2Demo goes beyond combining existing components through a shared task-graph interface.
  2. Added cost analysis (Experiments, page 8, lines 413–419). Quantified training overhead, demonstration-collection time, and downstream performance gains over RoboFactory scripts.
  3. Added GaP comparison (Appendix C, pages 15–16, lines 781–843). Reported results on seven tasks and documented adaptation, manual refinement, state and annotation use, and limitations.
  4. Updated related work (Section 2.2, page 3, lines 123–127). Discussed GaP’s skill-based computation graphs and feedback-driven refinement.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.