RoboPARA: Dual-Arm Robot Planning with Parallel Allocation and Recomposition Across Tasks
Authors: Shiying Duan
Pei Ren
Nanxiang Jiang
Zhengping Che
Jian Tang
Zhaoxin Fan
Yifan Sun
wenjun wu
Venue: ICLR 2026 Poster (2026)
Keywords: Dual-Arm Robots
LLM-driven Planning
Task Parallelism
Primary area: applications to robotics, autonomy, planning

Abstract: Dual-arm robots play a crucial role in improving efficiency and flexibility in complex multitasking scenarios. While existing methods have achieved promising results in task planning, they often fail to fully optimize task parallelism, limiting the potential of dual-arm collaboration.
To address this issue, we propose RoboPARA, a novel large language model (LLM)-driven framework for dual-arm task parallelism planning.
RoboPARA employs a two-stage process: (1) Dependency Graph-based Planning Candidates Generation, which constructs directed acyclic graphs (DAGs) to model task dependencies and eliminate redundancy, and (2) Graph Re-Traversal-based Dual-Arm Parallel Planning, which optimizes DAG traversal to maximize parallelism while maintaining task coherence. In addition, we introduce the Cross-Scenario Dual-Arm Parallel Task dataset (X-DAPT dataset), the first dataset specifically designed to evaluate dual-arm task parallelism across diverse scenarios and difficulty levels. Extensive experiments demonstrate that RoboPARA significantly outperforms existing planning methods, achieving higher efficiency and reliability, particularly in complex task combinations.Our code is publicly available at https://github.com/AiDuanshiying/RoboPARA.

Published as a conference paper at ICLR 2026
ROBOPARA: DUAL-ARM ROBOT PLANNING WITH AND RECOMPOSITION
PARALLEL ALLOCATION
ACROSS TASKS
Shiying Duan Pei Ren Nanxiang Jiang', Zhengping Che², Jian Tang", Zhaoxin Fan Yifan Sun Wenjun Wu!
Beijing Advanced Innovation Center for Future Blockchain and Privacy Computing, School of Artificial Intelligence, Beihang University
BBejjin Innovation Center of Humanoid Robotics
CCenter for Applied Statistics, School of Statistics, Renmin University of China
Equual contribution.
Corresponniig authors. Prroeect leader.
ABSTRACT
Dual-arm robots play a crucial role in improving efficiency and flexibility in com- plex multitasking scenarios. While existing methods have achieved promising results in task planning, they often fail fully optimize task parallelism, limit- ing the potential of dual-arm collaboration. To address this issue, we propose RoboPARA, novel large language model (LL.M)-driven framework for dual-arm task parallelism planning. RoboPARA employs a two-stage process: (1) Depen- dency Graph-based Planning Candidates Generation, which constructs directed acyclic graphs (DAGs) to model task dependencies and eliminate redundancy, and (2) Graph Re- Traversal-basee Dual-Arm Parallel Planning, which optimizes DAG traversal to maximize parallelism while maintaining task coherence. In addition, we introduce the Cross-Scenario Dual-Arm Parallel Task dataset (X-DAPT dataset), the first dataset specifically designed to evaluate dual-arm task parallelism across diverse scenarios and difficulty levels. Extensive experiments demonstrate that RoboPARA significantly outperforms existing planning methods, achieving higher efficiency and reliability, particularly in complex task combinations. Our code is publicly available at
INTRODUCTION
Dual-arm robot manipulation represents a transformative milestone in embodied AI (Liu al. 2025a), offering unprecedented capabilities to tackle complex and collaborative tasks (Kurosu et al. 2017 Gao & Yu 2022 Takata al. 2022). By leveraging coordinated actions, dual-arm systems overcome the sequential limitations of single-arm robots and significantly enhance both efficiency and precision (Smith et 2012 Gao & Yu 2022).. Central to unlocking these advantages is effective task planning (Guo et al. (023), which bridges high-level objectives with seamless execution. Recently, the rise of large language models (LLMs) has further advanced dual-arm task planning, providing innovative approaches to improve coordination, adaptability, and overall system performance (Huang
al. 2024
Ruan et al. 2023 Sharan et al. 2023).
Indeed, a growing body of research has been proposed that leverages LLMs for task planning in dual-arm robot manipulation (Ahn et al. 2022 Bai al. 2025 Wei et al., 2023 Mu af. 2023). For example, RoCo (Mandi et al. 2023) prompts LLM agents to iteratively improve their plans and waypoints in-context, enabling more refined task execution strategies. Similarly, FLTRNN (Zhang et al. 2024) employs a language-based RNN structure to integrate task decomposition and memory management into the LLM planning inference process. Despite their innovative designs, these methods often result in single-amm aagle-ammmaa sequential execution. This is because they primarily focus optimizing task success rate and completion time, while neglecting a critical factor: parallelism between the arms. As result, the collaborative potential of dual-arm systems is not fully realized.

---

Published as a conference paper at ICLR 2026
Interaction
Planning
Dual- Arm Parallel Execution
Please carrot siices and cream broad.
Chef Bat at your service!
Planning in parallel with both arms- as fast as possible.
before?
Right are Pack plas Boe bull
Right atc: Flace pluk tallle
Rudl ans Pakk treed Beei talo.
t224
(n) Inttal setup
OZ. should de now?
Rigios Perelose ee place
Rightee Lia bullo ouron
west
Right any Play vallint
kals
mms
the action plan?
Right are Park butter Does calliit
Flge caltaat Right better linnd
Right anc Parc batter aibil
Figure I: RoboPARA enables efficient parallel manipulation and collaborative dual-arm execution. resulting in a 30% to 50% reduction in exccution time while maintaining task success. When deployed on a humanoid robot, it demonstrates behaviors closely aligned with human activities.
Specifically, in real-world applications, multiple tasks are often issued concurrently, posing fun- damental challenge: how to plan efficiently under multitasking demands. To address this, we draw inspiration from everyday human behavior. Consider typical morning routine, actions such as boiling water, brushing teeth, and washing your face are naturally interleaved-for example, you may let the water boil while brushing your teeth. This ability to reason about temporal overlap and parallel execution is key to human efficiency. Similarly, in robotic kitchen, the same principle applies. Some tasks require both arms to work together, such as cutting carrots, while others, like chopping vegetables, only require arm, leaving the other free to perform different task. Deciding when to synchronize both arms and when to decouple them becomes crucial for optimizing execution time. Despite its practical importance, this dimension of parallelism- aware dual-arm planning remains largely underexplored in current research.
To tackle the issue, we propose RoboPARA, novel LLM-driven dual-arm robot planning framework. RoboPARA ensures both task correctness and optimal arm utilization through a two-stage architecture: Dependency Graph-based Planning Candidates Generation and Graph Re-Traversal-base Dual-Arm Parallel Planning. In the former stage, RoboPARA processes user instructions by utilizing a local memory module, supported by retrieval augmented generation (RAG) (Gao et al.) 2023), to obtain detailed procedural knowledge relevant to the task. This retrieved information is integrated into a structured prompt, enabling the L.M generate directed acyclic graph (DAG) with correction that outlines the step dependencies. In the later stage, the generated DAG is analyzed and optimized by scheduling algorithms to fully exploit the collaborative potential of dual-arm robots. Together, these two stages form a tightly integrated pipeline that enables RoboPARA to generate task plans that not only ensure accuracy and feasibility but also optimize dual-arm collaboration.
To validate the effectiveness of RoboPARA, we further propose the Cross-Scenario Dual-Arm Parallel Task dataset (X-DAPT dataset), the first dataset designed to evaluate dual-arm task planning parallelism. Our dataset includes more than 1,000 task packages across 10 key scenarios, each divided into three difficulty levels. Experiments demonstrate that RoboPARA achieves outstanding performance, especially in the most complex task combinations. Compared existing methods, RoboPARA exhibits over 4.5x parallel and collaborative steps in average, resulting in 30% to 50% reduction in execution time, significantly improving efficiency. Moreover, RoboPARA achieves 34% higher success rate than the average of other methods in challenging tasks, ensuring greater reliability and stability in task execution.
Our contributions are summarized as follows:
We propose a new dual-arm task planning problem, the Dual-Arm Cooperative Scheduling Problem, specifically designed to optimize parallelism and improve multitasking efficiency in real-world scenarios. Our work establishes a new task and objective, pushing the boundaries of dual-arm robotic manipulation.
New Task:
2

---

Published as a conference paper at ICLR 2026
New Dataset: We design the X-DAPT dataset, the first dataset tailored for evaluating dual-arm task parallelism. It includes over 1,000 task packages across 10 diverse scenarios with difficulty levels, offering a comprchensive benchmark.
We propose RoboPARA, an LLM-driven dual-arm planning framework using a two-stage process: Dependency Graph- Planning and Graph Re-Traversal. It ensures efficient, reliable, and highly parallel task execution, achieving state-of-the-art task success rates and execution efficiency on X-DAPT dataset and real-world scenarios.
New Method:
2 RELATED WORK
Dual-arm Robot Manipulation. Dual-arm manipulation plays critical role in enabling robots
to perform complex, high-precision tasks in various domains (Zhao et al., 2025: Yoshida et al.)
2023). Current approaches to dual-arm manipulation can be broadly categorized into two main paradigms: End-to-end methods train a self-contained model to directly map from task descriptions to robotic trajectory, such as HybridVLA (Liu et al. 2025b), DA-VIL (Karim al. 2024), R3M (Nair et al. 2022), Long-VLA (Fan et al. 2025). However, such methods have limited scalability and flexibility for long-horizon tasks, and generalizing new tasks or environments often requires extensive retraining. Compositional skill learning involves developing multiple meta-skills that can be combined to accomplish complex tasks, offering greater flexibility and reusability (Gu et al.) 2023; Villagrossi et al.] 2021; Gu et al., 2022). Approaches like RoboTwwin (Mu et al.) 2025). RoboCodeX (Mu et al. 2024), and AnyGrasp (Fang et al. 2023) leverage modular representations of skills to enable dynamic recomposition in novel settings. This approach is well-suited for long- mon-zooizon tasks. Our work is built on this compositional paradigm to leverage its generalization capability.
Large Language Models for Task Planning. LLMs have demonstrated remarkable capabilities in robotic task planning, translating high-level tasks into actionable steps and enabling more adaptive, coordinated behaviors (Bai al. 2025 Mandi et al.) 2023 Zhao et al.) 2025). Key planning methods include direct task decomposition and structured coordination. Direct task decomposition use LLMs to break down complex instructions into linear hierarchical sequences of actions (Wake al.)
2024 Xie et al., 2023). Examples include LLM-Planner (Song al. 2023) and DELTA (Liu et al. 2025c), where tasks are structured step-by- step for easier execution. Structured coordination solutions further focus on exploiting the parallel capabilities of dual-arm or multi-agent systems (Bai et al.) (2055) et al.] 2025 Khan et al., 2025). these approaches are designed to promote parallelism through the coordination of concurrent actions. Approaches such as LLM+MAP (Chu et al., 2025), Tree-Planner (Hu et al. 2024). RoCo MMandi ee al, 2023), and emerging graph-based planners (Byeon & Oh 2024||Zhan et al. 2025) fall into this category, enabling structured modeling of task dependencies and parallel exccution potential.
2023 Wu et al. [2033] Huang et al. [2022] Raman et al.)
System-1 + System-2 Framework in Embodied AL Embodied algorithms generally follow two paradigms: end-to-end methods (Liu et al. 2025b Karim et al. 2024] Nair et al. 2022), which directly map task descriptions to trajectories but struggle with long-hood Long-horizon generalization, and the System-1 + System-2 hierarchical framework (Stanovich et al. 22000: Kahneman [011 Liu al. 2025a). where System-2 handles symbolic reasoning and scheduling while System-1 executes low-level actions. The latter has shown greater practicality for complex multi-arm settings (Holladay
al. 2024, Adu-Bredu et al., 2022 Vu et al., 2024 Joublin et al. 2024). Nevertheless, high- level System-2 planning for long- horizon, parallel dual-arm collaboration remains underexplored.
Our work specifically addresses this gap by enhancing System-2 planning to improve efficiency, parallelism, and adaptability in dynamic environments.
3 METHODOLOGY
3.1 PROBLEM FORMULATION
We focus on the S component within the well recognized System-1 + System-2 architecture, and formalize the dual-arm collaborative scheduling problem dual-arm multi-task optimization problem with temporal and structural constraints. Let P {PI. Pa.... , P.,) denote a collection of task packages, where each P; is composed of sequence of meta operations.
3

---

Published as a conference paper at ICLR 2026
Stage1: LLM-Driven Dependency Graph for Planning Candidates Generation
Step Memory Retrieval
Step 2 Graph Candidates Gen.
Step GGaahh Correction
Conversion Checking
Environment
Information
Largo Language Models
Query
Theaee PISHARTAA de:
Memory
User cnstrstion
Language
Malry
Pay Ooga
Embedding
Rain
Knowledge
Lolyy Toddee (TI
Long-Term Memory
Search
Craph
Stage Graph Re-Traverse for Optimal Dual-Arm Planning
Conmited Dep Grepho
Task Dependency
Unlocked Arm Availability
Parallel Execution
Praki cokk
Gily pne S.llo..00 (1)
Occipied Oetigled
Auciett Occoped
Arm
Dused Surheer
Pick
2. Pick
Constraints
Place
Compatibility
3.1
Hode
Prdeetsoo imoeracte
Right State
4. Cut
Scheduling
belligg suleeen
5.1
Event
Queue
Right Anm
Figure 2: The RoboPARA framework. Given user instructions, our two-stage framework outputs a dual-arm execution schedule. Stage generates dependency graph-based planning candidates: it builds an LLM-based DAG from experiences and iteratively refines it via error correction (Appendix 22 and updates. Stage 2 re-traverses the graph to plan parallel execution: it identifies parallelizable tasks and resolves deadlocks (Appendix Alg. and Alg. 3) then finalizes task assignment.
All operations from all packages consolidated into global DAG (V,E), where each node E V corresponds to a meta operation, encoded as (name,, type,, 6g, t.), which defines the action label, semantic type, required number of arms 8, {1, 2). and execution duration fy E. Each directed edge (#: + my) & denotes that vj cannot start before before completes.
{L, R} be the set of available robotic arms. We define an arm assignment function: Let A
p. P(A), with [p(v]] 8,,
(I)
which assigns each operation to its arm(s), respecting exclusivity and synchronization semantics.
We further define a scheduling function o : V - R+, assigning each node a non-negative start time. The pair (a. must satisfy all task dependencies, arm availability constraints, and consistency requirements throughout execution.
The effectiveness of dual-arm execution plan is measured by its makespan the maximum comple- tion time of all operations:
Cmax max (a(v) + tw).
(2)
"EY
Our objective is to find valid schedule and arm assignment that jointly minimize this makespan:
min CHAS:
subject to (a. p)) F(G,S),
where S denotes the environment state, and F(G,S) S) denotes the feasible set of schedule-allocation pairs satisfying structural, temporal, and contextual constraints.
4

---

Published as a conference paper at ICLR 2026
3.2 OVERALL FRAMEWORK
RoboPARA tackles the newly defined Dual-Arm Cooperative Scheduling Problem through a two-stage architecture: Dependency Graph-based Planning Candidate Generation and Graph Re-Traversal-bee Dual-Arm Parallel Planning. The overall framework is illustrated in Fig. 2
The first stage focuses on generating multiple planning candidates, while the second stage performs efficient parallel scheduling. selecting the optimal execution plan. The final output is a complete, time-synchronized execution plan detailing meta operations, durations, and arm assignments, ensuring task correctness and efficient arm utilization. The following sections elaborate on each stage of RoboPARA, detailing the core algorithmic components and innovations underlying our design.
3.3 LLM-DRIVEN DEPENDENCY GRAPH FOR PLANNING CANDIDATES GENERATION
This stage constructs the task-level D = (V.& E), serving as the structural foundation for dual-arm scheduling. Given a user instruction, RoboPARA employs RAG to fetch relevant task knowledge from hybrid memory system. This memory integrates both short-term observations (e.g., object states) and long-term execution history (e.g.. package knowledge base).
The retrieved task steps are then augmented with additional contextual information, such as environ- mental constraints, dependency rules, parallelism guidelines, and structured formatting examples, to form full prompt (Appendix Sec. A.2.2). The prompt is given to an LLM produces initial instance of G. where each node u E V is categorized into operation types such as p ck, use, place, open/c ose and complete. The dependency edges & reflect precedence constraints- for ex- ample, a use action must follow corresponding pi ck of the same tool, and a place must not precede the associated use. Additionally, tool-related action sequences must maintain intra-object dependency consistency. The complete node serves as the unique sink of G, aggregating all terminal dependencies represent the logical end of the task sequence.
Since the initial G may contain errors in dependency relationships, we apply a structural validation routine (Appendix Alg. 2 detect and localize errors. Three key categories of invalid dependencies are identified: (1) an operation (use or place) incorrectly depending on another object's pl place; (2) place node in
sequence directly depends on its pi node instead of the preceding node; (3) any node depending on the use node of an unrelated other object.
Once errors are identified, related nodes and dependency rules are integrated into a new prompt for iterative correction. The updated prompt is re-submitted to the LLM to regenerate a valid G. After validation, the graph & proceeds to scheduling and execution planning.
3.4 GRAPH RE- RE-VRRVERSE FOR PARALLEL OPTIMAL DUAL- ARM PLANNING
Given a validated task graph G EV,E), RoboPARA constructs feasible and efficient dual-arm execution plan (a, assigning each node v E start time (v) and responsible arm set u(v) C A, minimizing makespan Craxx while respecting all structural and physical constraints.
Scheduling Framework. We maintain a dynamic scheduling queue Q with nodes v that satisfy: Ready(v) := {v E V all predecessors u E pred(v) are scheduled]
(4)
Each node in Q is assigned based consistency. Single-arm tasks go to the idle arm, favoring the left in case of tic. Dual-arm tasks require both arms free and not lbjkct-locked.
availability, task type (ő, 1 or 2), and object-holding
Formal Constraints. To ensure correctness and feasibility, the plan (a, 1) must satisfy the following four categories of constraints:
1. Task Dependency. Each task w E V can only be scheduled after the completion of all its predecessors. Formally:
(v) Z max (a(u) + l.), uEpred(e)
where pred(u) = {u E E / (u v) E }} denotes the set of immediate predecessors of c.
Unlocked Arm Availability, Each arm E A performs most one operation a time. Operation is schedulable only if all arms in (av) stay free during execution, formally:
Ve, o' E V, # v', p(v) pp(o') # e (a(v), (v) (.) (o))))))) (v)) b.))) 23. (6)
5

---

Published as a conference paper at ICLR 2026
3. Arm Lock Compatibility. Each pick-use-place sequence involving the same object must be executed by the same arm(s):
((ppicks Muse Oplace) ) E S, [((psee)) ((usse = (T(place))
where S denotes the set of all pick-use papie-sssepppeeeeeeeeee triples extracted from G.
4. Deadlock Prevention. If dual-arm task dy becomes ready but cannot be executed because each arm a E pl(v)) {L, RR is currently locked to a different object, a potential deadlock is detected. To resolve it, we identify the pick action Vlate that was executed later among the two conflicting chains and rolls it back along with its dependent subtree:
Ro Dollback(Dhnd) (escendants(Maae)) U {Mlate)
These removed operations are then re-inserted into the scheduling queue Q. freeing the related arm and allowing the earlier pick chain to proceed. The dual-arm task Ua is subsequently rescheduled once both arms are synchronized and one side hold the object chain.
Execution Procedure. Scheduling proceeds iteratively by selecting feasible task pairs from and assigning them to arms based on priority and constraints. For dual-arm tasks 5g = 2, both arms synchronize: 0z ( n(v)) = (v)). After each pick, object lock status updates, binding all related tasks to the same arm (Constraint 3). If no feasible pair exists due to conflicts or readiness issues, rollback triggered per Constraint 4, favoring earlier actions. The full scheduling and rollback algorithm is detailed in Appendix Alg.
4
DUAL- ARM PARALLEL TASK DATASET
To benchmark our new task and method, we introduce the first dataset for long-horizon parallel optimization, covering 10 diverse scenes: kitchen, agricultural greenhouse, office, factory, supermar- ket, hospital, disaster rescue, hotel, pet shop and library. Each scene presents distinct task planning challenges, which are further exacerbated when handling multi-task instructions. The dataset is structured across three difficulty revels-easy, medium, and hard, where task complexity increases with the number of steps required, allowing for structured assessment of the method across tasks with varying complexity and scene diversity. The dataset emphasizes efficient parallel operations and prioritizes the effectiveness of dual-arm coordination in multi-task scenarios. Fig. provides statistical evaluation of our X-DAPT dataset. See Appendix Sec. for detailed dataset information.
AL PRID
K-CAPT
0014
10%
5%
4%%
0%
Ray
dlde.
xtann
mark
Action stops coch package
Figure 3: Statistical evaluation X-DAPT dataset. The pie charts show the appearing skills (outer circle) and required number of arms (inner circle) of the 10 scenes. The bar chart shows the percentage of instructions with different action steps. X-DAPT is larger in scale, richer in scenes, and more diverse in skills than previous datasets (Wu al. 2023 Shridhar et al. 2020). It is closely aligned with daily life and specifically designed to highlight parallel execution.

---

Published as a conference paper at ICLR 2026
Table Quantitative results of dual-arm task planning under 4 scenes with GPT-4o foundation model. 1: higher is better, 4: lower is better. The red orange and yellow colors denote the best, the second best, and the third best results, respectively.
Kinchen
Agriculural Greenhouse
Factory
?
1FR.L L
PPR
AFR
TFR.L
FPR
APR 1
11:1
PPR 1
APR
161
1
APR
LLMP
0.805
0.333
0.000
0.059
0.985
0.267
0.000
0.009
0.785
0.400
0.000
0.026
0.913
0.013
0.000
0.000
CharGP Prompts
0.817
01081
0,000
0.010
1,024
0.360
0.900
0,013
0.934
0.112
0.000
0,032
0.789
0.190
0.000
0,013
VOYAGER
0.000
1.000
0.000
0,000
0.000
1.000
0.900
0.000
0.000
1.000
0.000
0.000
0.800
1.000
0.000
0,000
Embodiee TaPA
0.839
0.200
0,000
0,090
0.929
0.333
0,000
0.019
0.923
0.073
0,000
0.029
0.927
0.004
0.000
0
LLM Planner
10888
0.200
0,000
0,077
1377
0.000
0.300
12019
12875
0.352
0.000
0,027
0.991
0.214
0,000
0,116
Fl TRNN
0.912
0.000
0.000
0.006
1.014
0.300
0
0.019
0.934
0.009
0.000
0.032
0.915
0.005
0
0.013
RoCo
0.709
0.153
0.000
0.016
0.979
0.173
0.000
0
0.890
0.142
0.000
0.058
0.845
0.148
0.000
0.013
KODOPAKA
3.000
1.217
0007
5
EXPERIMENTS
5.1 EXPERIMENTAL SETUP
We utilize the m3e-basd model as the memory retriever, and employ OpenAI GPT-4g and DeepSeek 7 APIS as foundation LLMs. For the System-1 phase, we employ the ACT (Zaao al. 2023a). DP (Zhao et al. 2023b), and my (Black et al. (024) algorithms to train the action model. To evaluate RoboPARA, we conduct tests across four scenes and perform hardware verification using a humanoid robot, Franka Research 3 (GmbH) 2024). and URSe (Robots) 2024) robotic arms (see Appendix Sec. E.T for details).
5.2 BASELINES
Seven representative LLM-based agents are adopted baseline algorithms. We integrated the task settings and constraints into the prompts of all baseline methods with minimal necessary modifications, while retaining their core methodologies, to evaluate the robot's detailed prompt comparison between RoboPARA and prior works can be found in Appendix Table
planning capability. A
Wang et al. 2024) uses LLM to jointly generate and iteratively refine symbolic actions and motion parameters based on failure feedback. We provide it with our environment states and fit our tasks and scenes to its background settings. ChaiGPT-Prompe translate human instructions into structured robot actions using CharGPT. We provide the prompt with our execution constraints and overall settings. VOYAGER (Wang et al. 2023) is a GPT-4-powered lifelong agent in Minecraft that explores reusable skills through iterative self-refinement. We re- implement VOYAGER to do task decomposition under our experimental scenes. Embodied TaPA (Wu) et al. 2023) uses multi view perception and GPT-3.5 to generate grounded action plans in physical scenes. We adapt it with GPT-4o and DeepSeek V3 for task decomposition. L.LM-Planner (Song et al., ) generates subgoals with GPT-3 and replans upon failures. We re-implement it using GPT-4o and DeepSeek V3 for our scenarios. FLTRNN (Zhang et al. 2024) uses RNN framework to enhance long-horizon planning through subgoal decomposition, rule tracing, and external memory. We simply replace the environment state and tasks. RoCo (Mandi et al.) (023) lets agents communicate via dialogue to decompose tasks, allocate goals, and iteratively refine plans through replanning. We map the two agents, Chad and Dave, to our two robotic arms.
LLM
(Wake et al.. 2023) iteratively
5.3 EVALUATION RESULTS
We systematically evaluate RoboPARA and baselines their planning efficiency, failure rate, parallelism manipulating across packages, and dual-arm simultaneous execution. Formal definitions of the metrics are explained in Appendix Sec. E.I.1 We present the quantitative results with GPT-4o foundation under different scenes and package difficulties in TableT Table respectively. Results with DeepSeek V3 foundation is presented in Appendix Sec. E.4 We proceed with a closer analysis.
thtpps///pemmii.co//// www.://www..a..mnm/w//lloooooooo hwtpr//nnww..coooooocceccaeeeeee
7

---

Published as a conference paper at ICLR 2026
Table 2: Quantitative results of dual-arm task planning under different task difficulties with and yellow
GPT-4o foundation model. t: higher is better, 4: lower better. The red orange
colors denote the best, the second best, and the third best results, respectively.
Easy Packages
Medium Packages
Hard Packages
Package Difficulty
TEL 1
TFR
PPR
APR 1
TEI
TFR
PPR 1
APR
TEI
TFR
PPR
APR
L.MM
1.406
0.000
0.000
0.051
0.829
0.300
0.000
0.014
0.382
0.459
0.000
0.012
ChatGPT-Prompp Prompts
1.349
0.035
0.000
0.020
0.869
0.123
0.000
0.011
0.455
0.249
0.000
0.020
VOYAGER
0.000
1.000
0.000
0,000
0.000
1,000)
0.000
0.000
0.000
1.000
0.000
0.000
Embodied TaPA
1.367
0.050
0.000
0.051
0.910
0.150
0.000
0.024
0.451
0.258
0.000
0.031
I.M Planner
1.494
0.000
0.000
0.119
0.952
0.013
0.000
0.032
0.404
0.412
0.000
0.028
FLTRNN
1.406
0.000
0.000
0.051
0.943
0.050
0.000
0.029
0.481
0.111
0.000
0.039
RoCo
1.226
0.110
0.000
0.029
0.888
0.131
0.020
0.221
0.000
0.024
RoboPARA
1.956
0.025
0.057
0.342
1.347
0.063
0.033
0.321
0.869
0.041
0.121
0.351
RoboPARA
Embodled TaPA
Arm motion conflict,
terminated.
Fastest!
ChatGPT P-oopps FLTRNN// RoCo
Total action stops:
LLM-PPanner
Initial Setup
will bath pack cucumbers and prepare the seed trey for sprouting paraliel.
Total
action steps: (Sequential Execution)
steps: 10
Figure 4: Real-world deployment comparison of RoboPARA and baselines on Franka Research robot an agricultural greenhouse scene. Voyager excluded because it cannot provide explicit plans for each arm. See Appendix Sec, E.7.2 for details and specific plans regarding this field test.
Significantly higher efficiency. RoboPARA's superiority is evident in its ability to achieve sub- stantial reduction in execution time while maintaining high task success (Fig- DD. RoboPARA consistently achieves at least 1.5x, 1.4x, 1.3x, and 1.4x the number of successful steps executed per unit time compared to baseline methods in the kitchen, office, greenhouse, and factory scenes, respectively. On the other hand, methods such as FLTRNN and ChatGPT-PP Prromppp-- increase their failure rates as they strive to improve execution efficiency on harder cases.
Robust failure resilience. The DAG output verification algorithm (Appendix Alg. plays crucial role timely detecting node dependency and resource usage conflicts, ensuring the feasibility and accuracy of task planning. Especially in hard packages, baseline methods exhibit planning failure rates over 2.7x higher than RoboPARA, highlighting the lack of robustness M.MM-nly agent approaches when faced with complex planning scenarios. VOYAGER fails to generate concrete execution steps, while RoCo almost unable to solve any task after more than 50 prompting iterations.
Integrated execution across packages. RoboPARA effectively reasons over both intra-pace sitra-package logic and inter package dependencies tasks, enabling successful merging of redundant operations. This reduces unnecessary repetition, in contrast to baseline methods that treat each package as isolated unit (c.g., two tasks with pick knife + cut carrots + place knife and pick kni fe cut. apples place knife, be merged into single optimized sequence:
8

---

Published as a conference paper at ICLR 2026
Table Ablation study of our method in kitchen scene. Upper block: Ablation studies for environ- ment information and instructional constraints. RoboPARA outperforms almost all the alternatives, demonstrating the critical role of each prompt component. Lower block: Ablation studies for the arm selector logic and scheduling algorithm. RoboPARA surpasses almost all the other options, showing the significance of iterative LLM interaction and deadlock-aware algorithmic design.
Easy Packagos
Medium Packages
Hard Packages
Package difficulty
TTR
APR
T111
TIR L
T111
TIR
wio eav info
0.535
0.080
0.181
0.281
0.363
0.182
0.035
0.373
0.426
0.588
0.381
0.151
w/o instructional constraints
1.379
0.123
0.000
0.272
0.467
0,742
0.000
0.086
0.316
0.676
0.007
0.041
wio deadlock check
0,855
0.447
0.170
0.234
1.061
0.184
0.056
0.353
0.428
0.618
0.402
0.156
w/o DAG correction
L.772
0.181
1.345
0.038
0.488
0.438
0.177
Tull model
1.785
0.000
0.181
0.321
1.469
0.000
0.038
0.457
0.965
0.000
0.412
0.225
pick knife + cut carrots cut apples + place knife). In our experiments, RoboPARA reduces the number of executed steps by 7% while ensuring correct task completion.
Dual-arm simultaneous execution. RoboPARA demonstrates superior dual-arm parallelism across all scenes. In simple packages, its number of parallel steps is over 2.8 that of all baselines; in medium and complex packages, this advantage increases to over 10x. Baseline methods tend to fall back to sequential execution when processing complex package prompts, due to their inability to model step dependencies. While Embodied TaPA and LLM-Planner attempt to increase parallel execution, they suffer from elevated failure rates, generating infeasible plans. Under the DeepSeek V3 backbone (Appendix Table S and Appendix Table D baseline parallelism improves significantly, yet RoboPARA still outperforms all of them by over 1.3x. We present the comparison between RoboPARA and baselines on real Franka Research robotic arms in Fig.
Robustness across scenes, difficulty levels, and model backbones. RoboPARA consistently outperforms all baselines across evaluation metrics under both GPT-40 and DeepSeek V3 backbones (Appendix Fig. 7 and Fig. G) demonstrating strong robustness.
Others. Due to space limitations, additional results are provided in Appendix E.5 These include the full of experiments on the X-DAPT dataset, evaluations on the RoboTwin (Mu et al., 2025) dataset, as well as extended real-world trials across a broader range of scenarios. Additionally, we report results on closed-loop error handling and replanning. demonstrating RoboPARA's ability to adapt to execution failures and dynamically adjust task plans.
5.4 ABLATION STUDIES
We ablate two prompt choices (environment information and instructional constraints) and two algorithm components (arm selector deadlock check and DAG correction) in RoboPARA and study their impact on planning performance (see Appendix Sec. E.3 for details of each ablated variant). Results can be found in Table We highlight the key findings below:
Environment information is crucial in ensuring correction and enhancing parallelism. Failure rate increases by 28% and parallel execution decreases by 25% without environment information in prompts. This finding corroborates recent studies in the literature (Mandi et al. 2023
Instructional constraints and DAG correction algorithm ensures successful plannings. Re- moving either of the two mechanisms individually leads to a significant increase (on average 51% and 18%) in failure rates, especially hard packages. Prompt constraints and the verification algorithm are critical for generating correct DAG nodes, as incorrect node dependencies can result in deadlocks infinite loops during the scheduling process.
Arm selector (Appendix Alg. 3) is the core component of RoboPARA framework. Without timely deadlock detection and case-specific reasoning, execution efficiency drops by an average of 22%, while the failure rate increases by an average of 18%.
5.5 LIMITATION AND FUTURE WORK
The limitations of RoboPARA primarily lie in cost, accuracy, and generalization. First, the use of GPT-4o and DeepSeek V3 APIs incurs significant costs, with RoboPARA consuming average

---

Published as a conference paper at ICLR 2026
of x more tokens than baselines due to iterative DAG corrections. Second, despite the iterative prompting mechanism, inaccuracies persist as the agent struggles to self-correct plamning errors for complex packages with intricate dependencies within the limited correction rounds. Finally, the current skill library is tightly coupled to predefined scenarios and package templates, limiting its ability generalize to unseen tasks environments. Looking ahead, advancements in L.M,, along with more adaptive DAG generation and verification mechanisms, hold promise for addressing these challenges and enabling RoboPARA scale across a wider range of dual-arm robotic applications.
CONCLUSION
In this work, we propose RoboPARA, novel LLM-driven framework address the Dual-Arm Coop- erative Scheduling Problem. RoboPARA employs two-stage process: (1) Dependency Graph-based Planning, which models task dependencies and eliminates redundancy, and (2) Graph Re- Travervessl based Parallel Planning, which maximizes parallelism while maintaining task coherence. To evaluate its effectiveness, we introduce the X-DAPT dataset, designed benchmark dual-arm task parallelism across diverse scenarios. Experimental results show that RoboPARA significantly outperforms exist- ing methods efficiency and reliability, particularly for complex tasks, demonstrating its potential for real-world dual-arm robotic applications.
ACKNOWLEDGEMENTS
This work was supported by the New Generation Artificial Intellieenee-National Science and Tech- nology Major Project (Grant No. 2025ZD0122603). was also supported by the Postdoctoral Fellowship Program and the China Postdoctoral Science Foundation (Grant Nos. 2024M764093 and BX20250485), the Beijing Natural Science Foundation (Grant No. 4254100), and the Beijing Advanced Innovation Center for Future Blockchain and Privacy Computing. This work also supported by Beijing Innovation Center of Humanoid Robotics.
10

---

Published as a conference paper at ICLR 2026
REPRODUCIBILITY STATEMENT
We have taken extensive measures to ensure the reproducibility of our work. Section E.6 outlines the experimental setup (including the knowledge base construction across 4 initial scenes, task package grouping by difficulty,, and test protocol design), adopted backbone models (m3e-base as the RAG retriever, GPT-4o and DeepSeek V3 as foundation LLMs), hardware environment (Franka Research 3, URSe robotic arms, and humanoid robot), and baseline configurations (7 representative LLM-based agents with adapted prompts), with additional implementation details (such as the full prompts for RoboPARA and baselines) and adopted hyperparameters (e-g., retry limits for DAG correction in Stage 1) provided Appendix A and Appendix F All datasets used in our study, including the newly proposed Cross-Scenarii Dual-Arm Parallel Task dataset (X-DAPT dataset) and the reorganized RwboTwin dataset, are detailed in Section 4 Appendix B and Appendix E.3.2] with X-DAPT spanning 10 diverse scenarios and 3 difficulty levels. To further facilitate reproducibility, include the complete source code (for DAG generation, graph re- ce-traversal scheduling, and closed-loop handling), all experiment scripts (for scene-specific and difficulty model configurations in the SUPPLEMENTARY MATERIALS, and we will make the full codebase and resources publicly available upon publication.
tests), and relevant

---

Published as a conference paper at ICLR 2026
REFERENCES
Deepseek-v3 v3 technical report. https//axiivoorrab//212211131
sgenffiant-graaiiasaatt--- An experimental open-source attempt to make gpt-4 fully au-tonomous. 2023.
Alphonsus Adu-Bredu, Nikhil Devraj, and Odest Chadwicke Jenkins. Optimal constrained task planning as mixed integer programmingg In 2022 JEEE/RSJ International Conference on Intelligent Robots and Systems (IROS). pp. 12029-12036, IEEE, 2022.
Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Chuyuan Fu, Keerthana Gopalakrishnan, Karol Hausman, Alex Herzog, Daniel Ho, Jasmine Hsu, Julian Ibarz, Brian Ichter, Alex Irpan, Eric Jang, Rosario Jauregui Ruano, Kyle Jeffrey, Sally Jesmonth, Nikhil J Joshi, Ryan Julian, Dmitry Kalashnikov, Yuheng Kuang, Kuang-Huei Lee, Sergey Levine, Yao Lu, Linda Luu, Carolina Parada, Peter Pastor, Jornell Quiambao, Kanishka Rao, Jarek Rettinghouse, Diego Reyes, Pierre Sermanet, Nicolas Sievers, Clayton Tan, Alexander Toshev, Vincent Vanhoucke, Fei Xia, Ted Xiao, Peng Xu, Sichun Xu, Mengyuan Yan, and Andy Zeng. Do as i can, not as i say: Grounding language in robotic affordances, 2022. URL https://arxiv.on http://aaxvvvv/.. org/ abs 2204.01699
David Bai, Ishika Singh, David Traum, and Jesse Thomason. Twostep: Multi-agent task planning using classical planners and large language models, 2025. httpt://aaaa/ org abs/
2403. 17246
Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, Szymon Jakubczak, Tim Jones, Liyiming Ke, Sergey Levine, Adrian Li-Bell, Mohith Mothukuri, Suraj Nair, Karl Pertsch, Lucy Xiaoyang Shi, James Tanner, Quan Vuong, Anna Walling, Haohuan Wang, and Ury Zhilinsky, my A vision-language- action flow model for general robot control, 2024. StLhttts: /ttp/aaaiivv/..////iv//e../....v orq abc//bb//220 24164
Seongwan Byeon and Yoonseon Oh. Task planning algorithm with graph-based state representation. The Journal of Korea Robotics Society, 19(2):196-200 202, 2024.
Kun Chu, Xufeng Zhao, Cornelius Weber, and Stefan Wermter. LIm+map: Bimanual robot task planning using large language models and planning domain definition language, 2025. URL
https://arxxiz http:///aaax..oorr////////55... wtwp://.orr//a/2255.1111
Yiguo Fan, Pengxiang Ding, Shuanghao Bai, Xinyang Tong, Yuyang Zhu, Hongchao Lu, Fengqi Dai, Wei Zhao, Yang Liu, Siteng Huang, et al. Long-vla: Unleashing long-horizon capability vision language action model for robot manipulation, 2025.
Hao-Shu Fang, Chenxi Wang, Hongjic Fang, Minghao Gou, Jirong Liu, Hengxu Yan, Wenhai Liu, Yichen Xie, and Cewu Lu. Anygrasp: Robust and efficient grasp perception in spatial and temporal domains. IEEE Transactions on Robotics, 39(5)3929933945, 2023.
Kai Gao and Jingjin Yu. Toward efficient task planning for dual-arm tabletop object rearrangement. In 2022 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 10425- 10431. IEEE, 2022.
Yunfan Gao, Yun Xiong, Xinyu Gao, Kangxiang Jia, Jinliu Pan, Yuxi Bi, Yixin Dai, Jiawei Sun, Haofen Wang, and Haofen Wang. Retrieval-augmmenee generation for large language models: survey. arXiv preprint 2rXiv:2312.10999 2:1, 2023.
Franka Robotics GmbH. Franka robotic, 2024. URL https://franka.de/
Jiayuan Gu. Devendra Singh Chaplot, Hao Su, and Jitendra Malik. Multi-skil mobile manipulation for object rearrangement. arXiv preprint amXiv:2209.02778 2022.
Jiayuan Gu, Fanbo Xiang, Xuanlin Li, Zhan Ling, Xiqiang Liu, Tongzhou Mu. Yihe Tang, Stone Tao, Xinyue Wei, Yunchao Yao, et al. Maniskill2: A unified benchmark for generalizable manipulation skills. arXiv preprint arXiv:2302.oerm 04659, 2023.
12

---

Published as a conference paper at ICLR 2026
Huihui Guo, Fan Wu, Yunchuan Qin, Ruihui Li, Kegin Li, and Kenli Li. Recent trends in task and motion planning for robotics: A survey. ACM Computing Surveys, 55(13s):1136 2023.
Rachel Holladay, Tomás Lozano-Pérez, and Alberto Rodriguez. Robust planning for multi-stage forceful manipulation. The International Journal of Robotics Research, 43(3):330-353, 2024.
Mengkang Hu, Yao Mu, Xinmiao Yu, Mingyu Ding, Shiguang Wu, Wenqi Shao, Qiguang Chen, Bin Wang, Yu Qiao, and Ping Luo. Tree-planner: Efficient close-loop task planning with large language models, 2024. URL
abs 2310. 08582
Wenlong Huang, Pieter Abbeel, Deepak Pathak, and Igor Mordatch. Language models as zero-shot planners: Extracting actionable knowledge for embodied agents, 2022. https:
org/abs 2
Xu Huang, Weiwen Liu, Xiaolong Chen, Xingmei Wang, Hao Wang, Defu Lian, Yasheng Wang, Ruiming Tang, and Enhong Chen. Understanding the planning of Ilm agents: A survey. arXiv preprint 10X.::22002.02116. 2024.
Frank Joublin, Antonello Ceravola, Pavel Smirnov, Felix Ocker, Joerg Deigmoeller, Anna Belardinelli, Chao Wang. Stephan Hasler, Daniel Tanneherg. and Michael Gienger. Copal: Corrective planning of robot actions with large language models. In 2024 IEEE International Conference on Robotics and Automation (ICRA), pp. 8664-667400 IEEE, May 2024, doi: 10.1 URL http::///o..d...or/1100100000 1tw.:11199///A551111
10610443
Daniel Kahneman. Thinking, fast and slow. macmillan, 2011.
Md Faizal Karim, Shreya Bollimuntha, Mohammed Saad Hashmi, Autrio Das, Gaurav Singh, Srinath Sridhar, Arun Kumar Singh, Nagamanikandan Govindan, and K Madhava Krishna. Da-vil: Adaptive dual-arm manipulation with reinforcement learning and variable impedance control, 2024.
UtRlhhtss://axxiii http://////aaavv..o.r////aaa//1.
Azal Ahmad Khan, Michael Andrev, Muhammad Ali Murtaza, Sergio Aguilera, Rui Zhang, Jie Ding, Seth Hutchinson, and Ali Anwar. Safety aware task planning via large language models in robotics, 2025. URL URLLbttps://artt http://aaxvvv... wwtp:/wwwwwww//////..e..//// 15707
Jun Kurosu, Ayanori Yorozu, and Masaki Takahashi. Simultaneous dual-arm motion planning for minimizing operation time. Applied Sciences, 7:1210. 11 2017. doi: 10.3390/ap77121210..
Huaping Liu, Di Guo, and Angelo Cangelosi. Embodied intelligence: A synergy of morphology, action, perception and learning. ACM Computing Surveys, 2025a
Jiaming Liu, Hao Chen, Pengju An, Zhuoyang Liu, Renrui Zhang, Chenyang Gu, Xiaoqi Li, Ziyu Guo, Sixiang Chen, Mengzhen Liu, Chengkai Hou, Mengdi Zhao, KC alex Zhou, Pheng- Aenng-Ann Heng, and Shanghang Zhang. Hybridvla: Collaborative diffusion and autoregression in a unified vision-tanguagc-actiin model, 2025b.
2061.
Yuchen Liu, Luigi Palmieri, Sebastian Koch, llche Georgievski, and Marco Aicllo. Delta: De- composed efficient long-term robot task planning using large language models, 2025c. URL
httts:://axxiv org/ abs
Zhao Mandi, Shreeya Jain, and Shuran Song. Roco: Dialectic multi-robot collaboration with large language models, 2023. http::/t:: http::::://xxvv.xrro// org/ abs/ 2etp:///3777333333
Yao Mu, Qinglong Zhang. Mengkang Hu, Wenhai Wang, Mingyu Ding, Jun Jin, Bin Wang, Jifeng Dai, Yu Qiao, and Ping Luo. Embodiedgpt: Vision-language pre-training via embodied chain of thought, 2023. URL
org. abs/ 2305. 15021
Yao Mu, Junting Chen, Qinglong Zhang, Shoufa Chen, Qiaojun Yu, Chongjian Ge, Runjian Chen, Zhixuan Liang, Mengkang Hu, Chaofan Tao, et al. Robocodex: Multimodal code generation for robotic behavior synthesis. arXiv preprint 240. 2024.
Yao Mu, Tianxing Chen, Zanxin Chen, Shijia Peng, Zhiqian Lan, Zeyu Gao, Zhixuan Liang, Qiaojun Yu, Yude Zou, Mingkun Xu, Lunkai Lin, Zhiqiang Xie, Mingyu Ding, and Ping Luo. Robotwin: Dual- arm robot benchmark with generative digital twins, 2025, URL https: : //tpxix.oogg//////
abs/ 2504 10004.13555 13059
13

---

Published as a conference paper at ICLR 2026
Suraj Nair, Aravind Rajeswaran, Vikash Kumar, Chelsea Finn, and Abhinav Gupta. R3m: A universal visual representation for robot manipulation, 2022. URL htlthttss///xxii/ wrt. attp//bb//220
12601
OpenAl. Gpt-4 technical report. https://arkixoor/abb22333.......
Shreyas Sundara Raman, Vanya Cohen, Ifrah Idrees, Eric Rosen, Ray Mooney, Stefanie Tellex, and David Paulius. Cape: Corrective actions from precondition errors using large language models, 2024. URL BtRthttss///axxiiii
abs 221 2211.111 09935
Universal Robots. Universal robots ur5e, 2024. URL https:/www..uivvrssttbbosoccccc
Jingqing Ruan, Yihong Chen, Bin Zhang, Zhiwei Xu, Tianpeng Bao, Hangyu Mao, Ziyue Li, Xingyu Zeng, Rui Zhao, et al. Tptu: Task planning and tool usage of large language model-basee ai agents. In NeurlPS 2023 Foundation Models for Decision Making Workshop, 2023.
SP Sharan, Francesco Pittaluga, Manmohan Chandraker, et al. Llm-assist: Enhancing closed-loop planning with language-based reasoning. arXiv preprint arXiv:2401 2000:2200..0225,, 2023.
Noah Shimn, Federico Cassano, Edward Berman, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning, 2023.
Mohit Shridhar, Jesse Thomason, Daniel Gordon, Yonatan Bisk, Winson Han, Roozbeh Mottaghi, Luke Zettlemoyer, and Dieter Fox. Alfred: A benchmark for interpreting grounded instructions for everyday tasks, 2020. URL /
http://axxivv..
/1.2. 734
Christian Smith, Yiannis Karayiannidis, Lazaros Nalpantidis, Xavi Gratal, Peng Qi, Dimos V Dimarogonas, and Danica Kragic. Dual arm manipulation-a survey. Robotics and Autonomous systems, 60(10))1340-1335 2012.
Chan Hee Song, Jiaman Wu, Clayton Washington, Brian M. Sadler, Wei-Lun Chao, and Yu Su. Lim-planner: Few-shot grounded planning for embodied agents with large language models, 2023. URL https: /atp:i/aaavv... org/ abs/ abs/2212. /2///2222222 04088
Keith E Stanovich, Richard West, and JE Alder. Individual differences in reasoning: Implications for the rationality debate?-open peer commentary-three fallacies. Behavioral and Brain Sciences, 23(5):665 665, 2000.
Kota Takata, Takuya Kiyokawa, Ixchel G Ramirez--a Ramirez-Alpizar, Natsuki Yamanobe, Weiwei Wan, and Kensuke Harada. Efficient task/motion planning for dual-arm robot from language instructions and cooking images. In 2022 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 12058-12065. IEEE, 2022.
Moka Al Team. M3e: Multilingual massive embedding models. URL htt.ttt//ggtthb.....
moka mooaaaiimm ai/m3e
Enrico Villagrossi, Nicola Pedrocchi, and Manuel Beschi. Simplify the robot programming through an action-and-skill manipulation framework. In 2021 26th IEEE International Conference on Emerging Technologies and Factory Automation (ETFA), pp. 1-6. IEEE, 2021.
Brandon Vu, Toki Migimatsu, and Jeannette Bohg. Coast: Constraints and streams for task and motion planning. In 2024 IEEE International Conference on Robotics and Automation (ICRA), pp. 14875-14881. IEEE, 2024.
Naoki Wake, Atsushi Kanehira, Kazuhiro Sasabuchi, Jun Takamatsu, and Katsushi Ikeuchi. Chatgpt empowered long-step robot control in various environments: A case application. IEEE Access, 11:95060-95011 2023. ISSN 2169-3536. doi: N0.1109/ccess222233319999 //dx. org/ 110.1.....111.11.... www.011119//AASSS2000 2C23. 3313333
URL http!
Guanzhi Wang, Yugi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models, 2023.
httpst /tattps://axiiae wwtp:/wwvorrr///ooooo.. abs. wtt.o//////./........ 6291
14

---

Published as a conference paper at ICLR 2026
Shu Wang. Muzhi Han, Ziyuan Jiao, Zeyu Zhang, Ying Nian Wu, Song Chun Zhu, and Hangxin Liu. Llm3glarge language model-based task and motion planning with motion failure reasoning, 2024.
URL httpss:/aaxii.. org/ abs/2403.........o.............a 11552
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoe Le, and Denny Zhou. Chain-of-thought prompting elicits reasoning in large language models, 2023.
11903
Zhenyu Wu, Ziwei Wang. Xiuwei Xu, Jiwen Lu, and Haibin Yan. Embodied task planning with large language models, 2023. / http://///a/xxooooo///////////// 2307 01848
Yaqi Xie, Chen Yu, Tongyao Zhu, Jinbin Bai, Ze Gong, and Harold Soh. Translating natural language to planning goals with large-language models, 2023, URL http:/ttpssr/axxi...rrg////// 2302
051 28
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao.
React: Synergizing reasoning and acting in language models, 2023. URL https://axxiv arg/abs/2210- 03629
Tatsuya Yoshida, Go Tanaka, Ken Kobayashi, and Masayuki Inaba. Automated harvesting by dual-arm fruit harvesting robot. Robotics and Computeer-ntegraated Manufacturing, 83:102569,
2023.
Jiatao Zhang, Lanling Tang, Yufan Song, Qiwei Meng, Haofu Qian, Jun Shao, Wei Song, Shiqiang Zhu, and Jason Gu. Fitrnn: Faithful long-horizon task planning for robotics with large language models. In 2024 IEEE International Conference on Robotics and Automation (ICRA), pp. 6680- 6686, 2024. doi: 10.1099CCKA511412224...001
Shiqi Zhang, Xinbei Ma, Zouying Cao, Zhuosheng Zhang, and Hai Zhao. Plan-over-graph: Towards parallelable Ilm agent schedule. arXiv preprint arXiv:2502. 14563, 2025.
Tony Z. Zhao, Vikash Kumar, Sergey Levine, and Chelsea Finn. Learning fine grained bimanual ma- nipulation with low-cost hardware, 2023a. URL URRK/ttpps///rrxv..or////b b23///4..././...../ 13705
Tony Z. Zhao, Vikash Kumar, Sergey Levine, and Chelsea Finn. Learning fine-grained bimanual ma- nipulation with low-cost hardware, 2023b. URL/ecpes//aaxi1...///////////03
Zhendong Zhao, Xiaotian Yue, Jiexin Xie, Chuanhong Fang, Zhenzhou Shao, and Shijie Guo. dual- agent collaboration framework based on Iims for nursing robots to perform bimanual coordination tasks. IEEE Robotics and Automation Letters, 10(3):2942-2949 2025. doi: 10.1109/LR..2025. 3533476.
15

---

Published as a conference paper at ICLR 2026
A METHODOLOGY
A.1
ROBOPARA ALGORITHM
The RoboPARA framework comprises two stages: Dependency Graph-based Planning Candidates Generation and Graph Re-Traversal-based Dual-Arm Parallel Planning. The overall pseudocode is presented in Alg. !
Algorithm 1 RoboPARA Algorithm
Input: Natural language instruction I
Stage 1: Dependency Graph-based Planning Candidates Generation
S SCENELDENTIPY (I)
p Extract task-related scene
R RAGGENERATE(Z.S. ENVIDESCRIPTIONSS)
Retrieve and generate scene-specific description
Load environment constraints
b DAG Construction and Correction
Po <- PROMPTFORMAT(RR
Formulate first prompt
Go STRUCTUREDGGEEEKAV((P)))
Obtain initial DAG description
No BUILDGRAPH
Parse DAG nodes
r + VERIFYGRAPH(NN)
Check structural consistency
while * 0 and Grazy S do
GENERAATECORRECCTOOPPPMMM.... Geum STRUCCUREDDGENEAATTPPP....
P Pour
No +- BUILDGRAPHIG....
VERIFYGRAPH
Crrry Guny
end while
Stage 2: Graph Re- Se-Trraversal-bsse Dual-Arm Parallel Planning
(Planies P1 aright Twai)) + SCHEDULE(N))
Output: Plante Planrighh Twuil
A.2 STAGE 1: DEPENDENCY GRAPH-BASED PLANNING CANDIDATES GENERATION
OpenAl ChatGPTT44 allow users to specify the role of each prompt message as one of three types:
High-level instructions that define the model's 's behavior and tone across the entire interaction.
System:
User:
Specific instructions that guide the assistant's next response.
Assistant: The model-generated reply. For more details, see the OpenAl Chat Completions Guide.
To reduce token consumption, we avoid multi-tun turn interactions by concatenating the system and user prompts into a single input when generating each assistant response. Check https::/p/// //pp aa form apenaaa.ccm//cccs///l/eeeee////e
ion for detailed information.
A.2.1 COMPONENTS THE PROMPT
We design two prompt templates to guide the LLMs in Stage 1: Dependency Graph-based Planning Candidates Generation. Below we detail the key components of each template.
Template 1: Structured Package Step Generation. In this template, structured prompt is used to
convert natural language instructions into step-wise package descriptions. The prompt is carefully designed to include:
Scene Retrieval: The LLM retrieves the corresponding environment context (e.g..
kitchen, fff based on the instruction.
Example-based Alignment: An in-context example is given to help the LLM generate consistently structured outputs (step ID, action, source/target, number, time).
16

---

Published as a conference paper at ICLR 2026
Error Resilience: The LLM is explicitly prompted to revise any logical or ordering mistakes in the given instruction.
Canonical Output Format: The response is constrained rigid textual format (e.g.. Al: pick (source=.... target=... (Single arm, 5 seconds)) ) en- abling downstream parsing.
This template transforms vague instructions intermediate grounding between human intent and robotic execution. See Sec. A.2.2 for the full prompt.
into semiistructured procedural steps, serving as the
Template 2: Dependeney-Aware Graph Construction and Refinement. Based on the generated package steps and retrieved environment state, a second prompt is issued to the LLM to construct valid DAG that captures execution dependencies. The prompt incorporates the following elements:
Environment-Aware Reasoning: All assets and object locations are embedded into the prompt to ground spatial and contextual preconditions.
Tock-Use-Place Semanties: Nodes required to follow strict pick-use-pel pplace chain. Tool usage must follow prior pick actions, and multiple uses of the same tool must form linear dependency.
pick nodes can have multiple edges; use and place nodes must have exactly one dependency.
Edge Constraints:
Tool Sharing Optimization: Shared tools (e.g., kni ves) should be reused across compati- ble steps to reduce motion cost.
Container Efficiency: The model is instructed minimize redundant open close operations by grouping relevant actions together.
Temporal Encoding:
Waiting steps are encoded delay_after after fields in the dependent node, avoiding redundant nodes.
the initial DAG violates structural rules (c.g.. tool usage relying unrelated objects), error messages auto- geoergeeeeted and used to prompt corrected version.
Mouti-Round Correction:
This template transforms procedural steps into DAG nodes with awareness of execution dependencies. See Sec. A.2.2 for the full prompt.
Overall, prompting framework transforms high-level task goals into executable plans with explicit structure and robot-aware constraints. We conduct a prompt comparison Table with prior works.
Table 4: Prompt component comparison between RoboPARA and prior works. Embodied TaPA is not included because its prompt does not include any listed components.
Prompt Components
LLM
ChanGPT-Prompts
VOYAGER
LLM-Pllnner
FLTRNN
RoCo
RoboPARA
Environment Information
Instructional Constraints
Skill Library
(pre-detined)
(pre-defined)
(pre-delined)
(pre-defined (pre-delined)
(RAG generated)
Output Format
(JSON)
Memory Management Examples Visible Objects
A.2.2 FULL PROMPT
Template 1: Structured Package Step Generation.
You need to adjust the package steps: (context. The order of the packages and the steps within the packages that I provided may contain output the corrected result. Example format: factory scene
issues. Please revise them accordingly and
17

---

2) tool usage node can depend on another tool usage node that uses the same source object, or on a "pick" node whose target object is the same as the tool usage node's s source object. When there are multiple tool usage nodes, the first "pick" node, while each subsequent one depends on the previous tool usage node. A "place" node can depend on a "pick" node whose target matches the "place" node's source, or on another "place" node that shares the same source object. For example, when adding water to pot, the pot should placed first, then the water picked up. Therefore, the water's "pick" node should depend on node Published as a conference paper at ICLR 2026
Package A; Assemble Tools
Al: pick (source="tool target="wrench") (Single arm, seconds) A2: place (source="wrench", target="assembly tablee))))) (Single arm, 6 seconds)
A3:
pick (source="tool rack", target= (Single arm, 5 seconds)
A4: place (source= (souroe="srewwrrieerr) tärget= target""asemblyytabbee"" (Single arm, seconds)
factory scene
Package B: Prepare Tools
B1: pick (source="tool_shel== target="voltmeter"" (Single arm, 5 seconds)
place Placesssorr=="ooottttt"""""" "arget="wozkbench" (Single arm, seconds)
32:
83: pick (source=" target="cables (Single arm, 5 seconds) 84:
place (sourcce Ltrget="tool "toolhodrrr (Single arm, 5 seconds)
factory scene
Package C: Wipe Surface
Cl: diccssoure==cleennnngg.eee
target="rag") (Single arm, 5
seconds)
C3: (sorccee" "asmb"""ascmlly_aaall"" (Single arm, 10 seconda)
"aaarrraaaannnggttttitio" (Single arm, C2: wipe (sourco="rag" target= seconds)
Do not output any extra text--only the packages with the corrected step order.
Template 2a: Dependency-Awee Aware Graph Construction (First Call).
You are a right hand man for two-armed robot to combine several well-defined packages into directed acyclic graph (DAG) You need convert DAG chart.
package steps entered into you into
Environment Information: (target_eng
Missions: (instruction) (rag_output) You must follow the following criteria:
1) Create DAG according to the package steps, and consider all nodes to complete the task.
should depend on the
the pot's s "place" node, rather than the water's depending on a tool usage node involving the pot.
3) Each robotic arm can only hold one object at time and must place it down before picking up another object. After picking up an object, the next step must be either to use it or to place it. You do not need to strictly follow the step-by-step order of the package; you may arrange steps flexibly as long as the dependency rules outlined above are followed.
4) "pick" node can have multiple dependency ecges, but tool usage node and "place" node edge. In other words, the "edge" field of pick node can include multiple nodes, whereas for tool usage and place nodes, the edge field must contain only one node.
each have only dependency
18

---

Published as a conference paper at ICLR 2026
5) Tool usage nodes include actions such as push_te, wipe, stick_on, pour_into, cut, stir, etc. Please refer to the skill set below for full list.
6) Nodes are divided into four types, container switch node, tool use node, take node, place nodc. The nodes used by the tool include push_to, wipe, stick_on, pour_into, cut, stir, etc. The operations for opening and closing containers slide_close flap_open, flap_close, open_cap, close_cap, etc. The pick node is "pick" and the place node is "place". Dependencies need to follow pick-use-place form.
slide_open,
7)
The tool use node only relies on "pick" node the tool when it is used only once. when the tool is used multiple times, the first tool uses the dependency tool "pick" operation, and the subsequent tool use node depends on the last tool use node. The "place" node "pick" node.
only depend the of the object the
8)
The generated edge is prerequisite not only for executing the node, but also for completing the task objective. For example, in the task of cutting apples and cucumbers, the apple and banana are placed on the cutting board before taking the knife and cutting.
9) The steps using the same tool in different packages can be combined under certain conditions, such as using knife the object be cut, using brush to brush the object at one time, which can save the overall execution time.
10) The cutting operation can only begin when all objects are placed in the designated area, and all objects need to be ready when making the first cut. For exanple, if you want to cut mushrooms, apples, cucumbers, you need to put the mushrooms, apples, and cucumbers on the cutting table during the first cut and then start cutting. The
is true for wiping.
11) Minimize container interaction on: After opening the container, retrieve all the objects you need, and then close it. when putting items back into the container, make sure all items are placed before closing. Avoid redundant on/off cycles.
12) The direct dependent chain of the picked up object: After the picked object, all subsequent nodes must be directly involved placement. Do not insert unrelated steps (such as
in its closing the door, handling other objects) between. picking up and putting down
13) "Take" and "put" are always interdependent, because can't put something down until you pick it up. Pick up object, use the object, and then drop the object.
14) Do not create nodes when waiting operations (such as waiting for baking) are encountered. Instead, the 'delay_after' property is added to subsequent nodes that depend the wait period. For example, if step C12 is the wait after CI1 (turning on the oven) and before C13 (turning off the oven), the wait is merged into c13 by setting del and edge=[C11] for C13.
15) The operations of each object must form continuous Pick-Use-Place chain. When the Use operation requires a tool (such as cutting with a knife), for example, when cutting carrots, the cut node should rely on the pick of the knife, and the pick operation depends the place of the carrots.
16) The Use node should rely on the Pick step of the "scurce" object, but not on the Pick and Place steps of the "target" object, and the fetch and place operation of the "target" object of the Use operation should be completed before the fetch of the "source" object. For example stick (ssorcce="chese"" target="bread") (sourcce===" target="plate") should be completed before pick (source=" reffugerrrrriigerattor" target="cheese")
19

---

Published as a conference paper at ICLR 2026
17) Use tool nodes include: push_to, wipe, stick_on, pour_into, cut, stir, etc. You can't use tool until you pick it.
18) Once you' ve put everything on the cutting board, take the knife and try to pick it up only once, cutting everything you need to cut before putting the knife down.
19) After the graph is generated, create task completion node.
List of skills: (List of skills)
You should only reply in the following format and do not reply to anything else.
Do not use Json format output.
Response format:
Nodes:
node_index
3... type: indicates the node type.
name: indicates the node name.
arm_num: specifies the arm number of a noae. take_time: ihe time requi red for each step. edge: Edge list of nodes.
Example:
Missions: Complete Package A.
Package A: Make carrot slices
Al: pick pick(sourc=="table", target="carzots) (Single arm, seconds)
A2: place (couroo"""""arr"""" target""cut.inggboxrdd)) (Single arm, 7 scconds)
A3: pick (sourco="counter") target="knife") (Single arm, seconds)
A4: cut (source="knife" target="carrots") (Dual arm, 10 seconds)
A5:
place (f"frf"="knife", ccrget=")) (Single arm, seconds)
Example output:
Nodes:
node_1:
type: pick
name: pick (source="table", "caret=""
arm_num: take_time: 5
edge: []
node_2: 2:
type: place
name: place (saurccc===""""rtt"""" targgt=
arm_num:
take_time:
edge: [1]
node_3: 3:
type: pick
name: pick (scrrcce==co target="knife")
arm_num:
take_time; 5
edge: [2]
node_4:
type: cut
name: cut (source="knife" target="carrots"
arm_num:
take_time: 10
edge: [3]
node_5:
type: place
name: place (source="knife", "arget="counerr""
arm_num: take_tine: 5
20

---

Published as a conference paper at ICLR 2026
edge:
[4]
node_
type: task bask_completinn
name: task caak__oopletion
arm_num:
take_time: 0
edge: [5]
Template 2b: Dependency-Awart Graph Construction (Refinements).
[response]
The above the result a dual-arm rebet decomposing task into a DAG graph, where the edge field indicates which other node a given node depends en. Some of the nodes in the above DAG contain dependency errors--in other words, there are problems with the edge field cartain rodes. The following are the nodes with issues and the corresponding problems identified.
aproblems_sectivne
You need to ensure that the DAG graph meets the following requirements:
1) All operations between the "pick" and "place" nodes must be related to the sare object. No other operations be performed the object before it has been placed.
2) Tool usage nodes include: push_to, wipe, stick_cn pour into, cut, stir, etc. Container open/close operations include: slide_open, slide_close close, flap_open, flap close, open_cap: close_cap, press_open, press_close. The pickup node "pick", and placement node is "place", The dependency relationship must follow the pick use place pattern.
3) Tool usage nodes object. If they currently do, move that "place" node into the "edge" of the corresponding "pick" node for the tool.
depend the "place" node another
4) there is only one tool usage node,
should depend only the tool's s "pick" node. If there are multiple tool usage nodes for the same tool, the first tool usage depends on the "pick" node, and each subsequent tool usage node depends on the previous tool usage node.
5) The "pick" node for a tool can depend on another object's "place" node.
6) When placing an object back into container, the container must opened before picking up the object that is to be returned.
1) "pick" node can have multiple dependency eages. Tool usage nodes and "place" nodes must other words: the "edge" field of "pick" node can contain multiple nodes, but the "edge" field of a tool usage or "placs" node can contain only one node.
have only dependency edge.
You should only reply in the following format and do not reply anything else.
Do not use json format output.
You must output the entire DAG, not just the modified nodes. Your output format must be: Nodea:
node_index 1, 2, 3...
type: indicates the node type.
name: indicates the node nane.
num: specifies the take time: The time required for each step. edge: Edge list of nodes.
number of node.
Example: ... (same as first call)
21

---

Published as a conference paper at ICLR 2026
A.2.3 SKILL LIBRARY
The of skills covered by all task packages retrieved via RAG across our 4 test scenarios is summarized in Table
Table 5: Skill library covering all task packages retrieved via RAG across test scenarios.
Skill Name
Parameters
Description
Arm Req.
pick
source, target
Pick the "target" "bjjet from the "source" place- ment.
Left/Right
place
source, target
Place the "source" object into/on the "target" Left/Right area.
slide_open
target
Slide open prismatic-joint object (c.g., drawer).
Left/Right
slide_close
target
Slide close prismatic-joint object (e.g., drawer). Rotate open revolute-joint object (e.g., microwave). Rotate close revolute-joint object (e.g., oven). Push the "target" object to specified location. Lift the "source" object from the "target" sur- face.
Left/Right
flap_open target
Left/Right
flap_close
target
Left/Right
push_to
source, target source, target
Left/Right
lift_from
Dual
open_cap
target target
Open the cap of the "target." object.
Dual
close_cap
Close the cap of the "target" object.
Dual
wipe
source, target source, target source, target
Wipe the "target" using the "source" object. Stick the "source" object onto the "target". Pour the "source" substance into the "target" container.
Left/Right Left/Right Left/Right
stick_
pour into
out
source, target source, target target
Use the "source" tool to cut the "target". Use the "source" tool to stir the "target", Press open the "target" object. Press close the "target" object. Use "source" to write on the "target". Inspect the "target" area using the "source". Bind the "source" to the "target" support. Weld the "target" using the "source" welding tool.
Dual
stir
Dual
press_open
Left/Right
press_close target
Left/Right
write
source, target source, target source, target
Left/Right
inspect
Left/Right
bind
Dual
weld
source, target
Dual
scan
source, target
Scan the "target" object with the "source" scan- ner.
Left/Right
tighten
source, target
Tighten the "target" component using the "source". Align the "target" component its correct pose. Left/Right Assemble the "target" part with the "scurce" tool.
Left/Right
align target
assemble
source, target
Dual
drill
source, target
Drill holes into the "target" with the "scurce" Dual drill.
mark
source, target
Mark the "target" object using the "source". Left/Right
Note: Arm requirements specify whether tasks be done (LeftRight) both arms.
A.2.4 DAG OUTPUT VERIFICATION
We develop customized rule-based validation algorithm to systematically verify the structural integrity and action closure of LLM-ggnerated DAGs. Our validator ensures that each place node is properly preceded by corresponding pick, and that all object manipulations comply with single- possession constraints under dual-arm execution. The criteria and conditions considered in our validation are illustrated Table The pseudocode of our validation algorithm is shown Alg
Table 6: Validation criteria and associated conditions in Alg.
Problem Index
Problem Description
P1
Depends another object's place node.
P2
Does not depend the tool usage node but directly depends the pick node. Depends on another object's 's tool usage node.
P3
22

---

Published as a conference paper at ICLR 2026
Algorithm 2 DAG Output Verification
Input: DAG node set V (MI..... na generated by LLMs Output: {0, 1} indicating whether logical conflicts found
Initialize violation sets
Pl, P2, P3 Ø
D. Check node-level logical consistency
for n, E ENo do
if mapeyp Aswitch then
for n, E P(n.) do < (n:.yyp- = pick)
P(n): predecessors
(nj.type pick)
nq.surree, 8, ny. source, t, n na.tageet
U, 3m, E E((n) s.t. type Ause A source t,
D. A my.type place # 8y then
P1 < P1U {n:}
& Invalid: wrong object dependency on place
clse if uj A v2.ttpp pllpplaceeae A = then
P2 4- P2 U {n.}
Invalid: place skips required tool-use
else type Ause A 8; + sy then
P3 - P3 U {n:}
> Invalid: cross-object use dependency
end if
end for
end if
D Return verification result
if P11 o BV@2PP22 #0 P3 * Ø then
return
Conflicts detected
else
return 0 end
> All logical constraints passed
A.3
STAGE 2: GRAPH RE-TR RE--TRAEERSAL-BASEE DUAL-ARM PARALLEL PLANNING
We define the dual-arm coordination and scheduling policy through two central routines:
Arm Selector: Determines which robot arm (left, right, or both) should execute the upcom- ing task node based on current system state.
Temporal Scheduler: Simulates time progression via a priority queue and dispatches ready tasks appropriate arms following dependencies, lock constraints, and deadlock avoidance.
A.3.1 ARM SELECTOR
This selector implements symbolic decision rule to resolve which arm(s) should execute a task. handles several scenarios:
Constraint-aware placement: For place tasks, the arm that originally picked the object is foreibly reused ensure object consistency.
Dual-arm execution: For dual-arm tasks, we attempt to acquire both arms while maintaining consistency of task chains across arms. It allows partial reuse if only one arm holds the source object.
Lock-sensitive fallback: If one is locked on a conflicting chain, the algorithm selects the free arm only if it does not violate dependency or chain constraints.
Default heuristic: In unconstrained settings, the selector defaults to the carliest-availabee arm (preferring left in ties).
The pseudocode of our arm selector is presented in Alg.
A.3.2 TEMPORAL SCHEDULER
This algorithm follows the execution timeline:
23

---

Published as a conference paper at ICLR 2026
Algorithm Arm Selector S(T, F, L)
Domain: {L.
Left/right arm
Return set: > {L, R, both, 1}
> Decision choices
Input:
T (Types
Targes, Tarms)
D Task descriptor Free-time function
:F:A A RR+
A + {locked e B, chain OU
Lock state
function own(a,
Check whether arm holds object
return chain = o)
end function
function lock(a)
b Check lock state of arm
return L., locked
end function
function is dual(r)
return (Tarms = 2)
end function
if Type place then return max IK [own(a, Tsourre) P(a)= Teanl] aEA
Find arm holding source and ready
if va E A, (oc then
Case I: both locked
Turget:
Type =
pick
Tsource
otherwise
(a) own o*)
is dual(T) then
if (L) A M (R) then return both else if ML) T...chiin return both
M(R)) LL-chain then
end if
else
D. Single-arm task in locked setting
if M(L) (R) A F(L) S Tean then return L
else (R) A (L) F(R) S Tsan then return R
else if (L) (R) then
return arg min F(a)
end if end if return if is dual(7) then return both end
end
Case II: free dual-arm operation
3la A, lock(a) then
Case III: only one locked
Let a be the locked arm, = A {a}
if Type = place oa Tscune) A F(a) S Taan then
return
else if own Twomce) F(a) Tann then
return
else if F(b) & Tame then
return
else
return 1
end if
end
return arg min F(a)
D Case fully free, pick earliest
4C.A
24

---

Published as a conference paper at ICLR 2026
Event-Driven Time Simulation: It uses min-heap priority queue where each event corresponds to either task readiness (available) or task completion (completed).
Dependency-Driver Activation: Tasks are only pushed into the queue when all predecessor nodes have completed.
Lock Tracking & Synchronization: After a pick, the arm marked as "locked" and associated with the corresponding object; After place, the arm is unlocked, releasing the associated object.
Deadlock Resolution Mechanism: notable innovation is runtime deadlock detection and recovery in scenarios where: a) Two arms each hold a distinct object via pick, and b) A subsequent task requires both arms for a dual-arm action involving only one object. this case, the scheduler identifies the conflict and rolls back one of the previous p ck operations (by removing its event and schedule entry) break the circular wait. then reassigns the dual-arm task to the arm with the matching chain, ensuring forward progress.
Delay Propagation: Each node may specify a soft constraint modeling post-condition stabilization time. This added the successors' carliest time.
By combining fine-grained chain tracking, resource-aware dispatch, and aggressive yet safe deadlock recovery, this scheduling architecture achieves robust task coordination for dual-arm manipulation in complex, multi-object environments. The pseudocode of our scheduler is presented in Alg. 4
A.4 OVERALL EXAMPLE
We present an example the kitchen scene, utilizing the whole RoboPARA framework. For detailed coding implementations, please refer to our codebase in supplementary materials.
Overall Example: RoboPARA input.
mmagine you are a robot programmed for task planning, You possess long-term memory: <knowledge base> and short-term memory <recent divvvveriss>. Your assigned task is: please make carrot slices, apple salad and
bread.
Overall Example: Memory retrieval output. These are the execution instructions of each task package used for DAG generation in Stage 1: LLM-Drivee Dependency Graph for Planning Candidates Generation.
Package A: Make carrot slices
pick (source="table", target="carrots" (8ingle arm, seconds) place (source="carrots" barget="cuttinggbbarre (Single arm, seconda)
A1:
A2:
A3: pick (ourcce""""","""" target="carzots") (Dual arm, 10 seconds)
A5: place (scourcc==""ccuutee target="knife" (Single arm, 5 seconds)
A4: cut (source="knife" target="counter" (Single arm, 5 seconds)
Package B: Make apple salad
B1: pick (source=""table"" target="applos") (Single arm, 5 seconds)
32: place (sourrc===p="pples target="autiing (Single arm, seconds)
B3: pick "cotte"""===" target="knife") (Single arm, seconds)
B4: cut (source="knifff" target="apples"" (Dual arm, seconds) carget="counter") (Single arm, seconds)
35:
Package C: Make cream bread
cl: pick (source="ghe1 target="plate") (Single arm, 5 seconds)
C2: (surreeeoore target="table") (Single arm, 6 seconds)
C3: pick (tourceetata target="bread") (Single arm, 5 seconds)
C4: place (source"""b"aaadd target="plate") (Single arm, 8 seconds) open wtt.ppptttteeeeeeeeiiiirrtrrtt (Single arm, 3 seconds)
C5:
C6: pick blccksouuree
target="buttest (Single arm, 5
seconds)
c7: Tbap_ellesttarrotttooooriiieneee (Single arm, 3 seconds)
25

---

Published as a conference paper at ICLR 2026
Algorithm 4 Temporal Scheduler
Input: node set N = {n:), each with type,, dep,, succ,, take, start;, arms; source, target;
Initialize:
II, min-heap event queue
(left, right)
execution trace Di free time
F(a) < 0 for a E (left,
L(a) (locked <- False, chain +)
enqueue all with |dep, 0 as (start, available, into Q
while 2 * 0 do
(t. type, i) available then
Q.pop ()
if type
a +- choose arm (F, n.,
Deadlock Check: If a
arms, = 2A both arms last action is pick Determine arm a' matching source,, delete latest pick in other arm a" Remove successors of that pick from Q and reheapify
Schedule nu F(a'), update both arms, Thets TTighs F, T.
enqueue (f + take;, cowpletep. i, both) and deleted pick
continue
af I then enqueue (L + available, i) and continue end if
if type, = place * both L(a" ).chaiin source, then
enqueue (t + available, i) and continue
end if
if type, pick L(a") ".c'kedooded then available, and continue else type, = pick then T(aa).locked < True, I(aa).chain <- target,
enqueue
end if
if a both then
$ + max(F(left), (right)), e + take; F(left), F(right) + II + IT, U [(s, name,)) for E (left, right}
Set L(-) according to which arm held source:
else
8 +- max(F(a))) starts), e a take; F(a") + e. HI +- II U [(x, e, name;)]
end if
enqueue (e, cowpletep i, a,)
else if type completed then
Update L(a): release lock if place or both ends chain for all j succ; do
dep, dep, -1
start; + max(starty, delay,)
if dep, then enqueue (start,, available.
end if
end for
end if end while
Return: (Tiar HTight, max F(right)))
output full schedule plan and total time cost
26

---

Published as a conference paper at ICLR 2026
c8:
stick_on (sou target="bread") (Single arm, 8 seconds) place (source- "butterr,, target= (Single arm, seconds)
C9:
Overall Example: DAG nodes output. These node information serve the input of Stage 2: Graph Re-Traverse for Parallel Optimal Dual-Arm Planning.
Nodes:
node_l:
type: pick
name: pick (source="aabll"" target="carrots"
azm_num: take_time: 5
edge: []
node_2:
type: place
name: place (source==carrota" carget="otting_barr
arm_num:
take_time: 7
edge: [1]
node_3:
type: pick
name: pick (sorccetete=" target="apples")
arm_num:
take_time:
edge: []
node_4:
type: place
name: place "spurce=""pplee"" target=
arm_num:
take_time: 7
edge: [3]
node_5:
type: pick
name: pick (soorccc==count)) target="knife")
arm_num:
take_time: 5
edge: [2, 4]
node_6:
type: cut
name: cut (sourc=="kniie"" "caret=*carrots")
arm_nuu:
take_time: 10
edge: [5]
node_7:
type: cut
name: cut (source=""kk,,""" target="apples"
arm_num: take_time: 10
edge: [6]
node_8:
type: place
name: place (source==knite"", Sarget="counter"
arm_num:
take_time: 5
edge: [7]
27

---

Published as a conference paper at ICLR 2026
node_9:
type: pick
(ssrcscrre"="steel" target="plate")
arm num:
take_time time: 5
edge: []
node_10:
type: place
name: (saucceeouee target="table")
arm_num: take_time: 6
edge: [9]
node_ll:
type: pick
name: pick "talrc"""aabll"" target="bread")
arm num:
take_time: 5
edge: [10]
node_12:
type: place
name: (sarcessaur"e targst="plate"
arm_num: take_time:
edge: [11]
node_ 13:
type: flap_open
name: flap_open (target="
arm_num: take_time: 3
edge: []
node_14 14:
type: pick
name: pickf targot="butter")
arm_num: take_time: 5
edge: [12, 13]
node 15: type: flap close
name: close "targge==rririigeaattr"""
arm_num:
take_time; 3
edge: [14]
node_16:
type: stick_or
name: stick_on (sorcoobbrtt,,,"",,, target="bread")
arm_num:
take_time:
edge: [14]
node_17:
type: place
name: place (source""bbtt",""""" target="table")
arm_num:
take_time: 8
edge: [16]
28

---

Published as a conference paper at ICLR 2026
node_18:
type: task_comples i on task comppeiinit arm num:
take_ time: 0
edge: [8, 17]
Overall Example: RoboPARA output. Final schedule table with dual-arm parallel operation and cross-task step integration.
Total execution time: 82 seconds
Left arm schedule table:
0-5 (source=""tabll"" target="carrots))
5-12 place (larcccccsr""""""rrttts" target="outting board")
12-17 pick (sourcc=""ccunterr" [ target="Knife")
17-27 out (source="knife", target="carrots")
27-37 cut (storcc=="kiffe", target="apples")
37-42 place (sorcc"=oo"" target="counterr))
48-53 pick (soorrcee""""...l" target="bread")
53-61 place (sorccceerr"" target="plate")
66-69 (trpccc
Right arm schedule table:
0-5 picx (sorcceeee",,, target="apples")
5-12 place (solece""appleee" "orget="outtinngbbbrrd"")
17-27 cut (source-"knife", target="carrots")
27-37 cut (sourcee""""n target="apples")
37-42 pick (serrrcce"="" target="plate")
42-48 (saurcccccr" target=*table")
48-51 flap_ opgeeatttrreeee=eeferrrrtttt""""
61-66 pick [iccktsouro==
target="butter")
66-74 stick_on (coorccooooorr target="brca"")
74-82 place (source="butter", target="table")
B X-DAPT DATASET
The X-DAPT dataset is the first benchmark specifically designed to evaluate the parallelism of dual- arm task planning. It contains over 1,000 task instances, each annotated with executable dual-arm action sequences generated by our RoboPARA system. X-DAPT spans a wide range of realistic scenarios including 10 typical scenes, covering tasks closely aligned with everyday human activities.
Each scene is categorized into three levels of difficulty: Easy. Medium, and Hard. Easy packages typically contain fewer than 10 steps and involve basic object manipulations. Medium packages range from 11 to 15 steps and introduce more diverse skills and branching dependencies. Hard packages feature 16 to 20 steps and require complex coordination, including both single-arm and dual-arm manipulations.
For example, the kitchen scene, easy tasks include "making carrot slices" "assembling cream bread"; medium tasks involve multistage preparations like "making carrot noodles" or "packing lunchbox"; while hard tasks such as "making stir-fried rice with green peppers" require tightly coordinated dual-arm sequences with logical dependencies and cross-arm tool reuse. Similarly, in the factory setting, tasks span from grasping and placing tools to intricate dual-arm operations like drilling and assembling.
Moreover, the dataset structured to support DAG-bass reasoning, where each task sequence naturally forms directed acyclic graph with explicit temporal and logical dependencies. This makes X-DAPT a compelling testbed for evaluating not only parallelism and coordination efficiency but also action reordering, causal inference, and plan repair in embodied planning systems.
29

---

Published as a conference paper at ICLR 2026
To the best of our knowledge, X-DAPT is the most comprehensive dataset for dual-arm task planning to date, combining large scale, rich diversity, and fine-grained control signals, enabling rigorous evaluation of real-world robotic planning algorithms. The percentage of packages with different numbers of implementation actions is shown in Fig.
20%
Easy Packages
Medium Packages
16%
Hard Packages
12%
10%
10%
7%
6%
6%
6%
6%
5%
4%
1%
1%
0%
0%
096
2
6
10
211
13
16
19
20
Figure 5: The percentage of packages with different numbers of implementation actions.
C SYSTEM-1 / SYSTEM-2 ARCHITECTURAL DECOUPLING
RoboPARA is explicitly designed within the well-established System-1 / System-2 paradigm of embodied AI. In this hierarchy, System-2 is responsible for high-level symbolic planning: it generates global task dependency graphs. reasons about action order and concurrency, and optimizes for dual- arm parallelism. By contrast, System-1 executes these plans the low-level, handling physical feasibility, motion control, conflict detection, and environment feedback. This division ensures that RoboPARA can focus on logically consistent and parallelizable plans without being encumbered by embodiment details, while System-1 rigorously enforces physical constraints such grasp validity, collision avoidance, and end-effector differences. Importantly, this decoupling also enables RoboPARA to generalize across heterogeneous dual-arm systems, since the same high-level plan can be executed by different System-1 controllers tailored to specific hardware. short, RoboPARA contributes a robust System-2 planner that complements existing System-1 execution layers, together forming a complete and feasible dual-arm manipulation system.
D COMPARISON OF MAINSTREAM TASK PLANNING METHODS
Mainstream task planning methods can generally be divided into categories: is step-by-step or reactive planning, where the robot continuously perceives the environment during execution and generates the next action in real time. This approach is highly flexible and capable of handling unexpected environmental changes, but it lacks global perspective, is prone to falling into local optima, and tends be inefficient in tasks with multi-step dependencies or collaboration requirements. The other is global planning, such as the proposed RoboPARA in this paper, which performs unified modeling and optimization of the entire task before execution. This enables systematic consideration of task dependencies and resource constraints, thereby avoiding conflicts and redundant actions, and making it easier to achieve globally optimal or near-optimal execution efficiency. Compared with the former, global planning demonstrates more significant advantages in complex, multi-arm collaborative, and assource-consrriig scenarios, greatly enhancing the coherence and predictability of task completion.
30

---

Published as a conference paper at ICLR 2026
E EXPERIMENTS
E. EXPERIMENTAL SETUP
To evaluate the effectiveness of the RoboPARA framework, first constructed comprehensive knowledge base containing all task packages across four distinct scenes: kitchen, office, agricultural greenhouse, and factory. Each scene features 15 standardized task packages, categorized by difficulty into 5 easy, medium, and 5 hard packages. To assess performance at different difficulty levels, we design the following test protocol.
For each difficulty level of a selected scene, we create five cumulative task groups:
Group includes only the 1st task package of this scene;
Group 2 includes the 1st and 2nd task packages of this scene;
Group 5 includes all five task packages of this scene.
For each baseline method (See Sec. 1.2 and RoboPARA, we conduct experiments across environments difficulty levels cumulative task groups 60 test units. Final performance metrics-such as TEI, TFR, PPR, and APR (See definitions at Sec. E.I.I) are averaged over the five task groups within each difficulty level to ensure robust and representative evaluation.
The characteristics and definition methods of task packages with different difficulty levels can be found in 7
Table 7: Definition, characteristics and detailed implementation of difficulty levels out experiments.
Package difficulty
Characteristics
Cumulation of knowledge base
Package A
Package A, B
Each standard package contains fewer than 10 steps; actions are simple.
Easy Packages
Package A,
Package A, B, C, D
Package A, B, C, D.E
Package
Package F.
Each standard package contains around 1 11-15 steps; actions are more complex and diverse.
Medium Packages
Package F. G. H
Package F. G. H,
Package G. H,
Package K
Package K. L
Each standard package contains more than 15 steps; actions are more complex and diverse.
Hard Packages
Package K.
Package K, L. M.
Package K, L. M,N.O
E. EVALUATION METRICS
To provide a comprehensive assessment of the performance, efficiency, and correctness of dual-arm robotic planning, we introduce the following quantitative evaluation criteria:
1) TEI (Task Efficiency Index)
S
TEI 100
| T
T: the set of all scheduled steps (across all packages in the test group)
S C T: the subset of successfully completed steps
T: total task completion time (including planning time, in seconds)
TEI measures the step-level execution efficiency by combining success rate and speed. Higher TEI indicates more steps completed in less time.
31

---

Published as a conference paper at ICLR 2026
2) TFR (Task Failure Rate)
TFR = 1 S
(10)
TFR quantifies the proportion of steps that failed during execution, reflecting system robustness. Lower TFR indicates higher reliability and task success.
3) PPR (Package Parallelism Rate)
S
PPR
(11)
Sideal
Saiiall number steps actually executed (after step merging and reuse across packages)
S number of steps required if each package executed independently (i.e., from the knowledge base)
PPR reflects the efficiency gained by merging redundant steps across multiple packages. A higher PPR suggests that steps like "cut with knife" or "place cutting board" are successfully reused when they appear in multiple packages, instead of executing repeatedly.
APR (Arm Parallelism Rate)
APR
Σ min (1,,()8n(()) IET
(12)
I: the set of all time intervals where both arms concurrently active
(t), (t)t): number of actions being executed by the left/right arm at time t, respectively For dual-arm actions (c.g., out and stir), both arms are considered to be active
APR captures the degree of parallel utilization of both robotic arms. Higher APR indicates better concurrency and scheduling efficiency. rewards not just simultaneous activity but also balanced utilization.
1.1.2 BASELINES
LLM Waag et al. 2024 introduces a novel conventional task and motion planning framework that utilizes a pre-trained LT. to jointly generate symbolic action sequences and continuous motion parameters, while iteratively refining plans through reasoning over motion failure feedback. The framework operates in a closed-loop fashion: at each planning round, the LLM is prompted with plan, followed by motion
the current state and trace of past planning feedback to produce feasibility validation. If failure occurs, categorized feedback (e.g., collision or unreachability) is synthesized and re-fed into the LLM guide subsequent refinements.
ChatGPT-Prompts Waaee et al. 2023) proposes a practical prompting strategy for translating natural language into robot actions using ChatGPT in few-shot setup. The system receives human instruc- tions and environment descriptions, then generates structured JSON outputs detailing robot actions and environment updates. It supports multi-step task planning by reusing post-action environment states, thereby mitigating the token limit issue.
VOYAGER (Wang et al., 2023) is the first lifelong embodied agent powered by GPT-4 in Minecraft. It autonomously explores, learns skills, and builds a compositional skill library without human intervention. VOYAGER operates
ReAct-style loop with three innovations: (1) an automatic curriculum that proposes increasingly complex tasks to drive exploration, (2) a skill library storing reusable action programs, and (3) an iterative prompting mechanism that incorporates environment feedback, execution errors, and GPT-4 velffieriiination for robust code refinement. VOYAGER outperforms ReAct Yao et al. 2023). Reflexion (Shinn et al. (023). and AutoGPT (aut) 2023) across all metrics.
embodied task planner that grounds action plans in realistic physical scenes using multi-vies object perception pipeline. It collects RGB images from multiple viewpoints, applies vocabuluyy detection to generate an object list, and conditions GPT-3.5 to produce executable plans.
Embodied TaPA (Wu et al. 2023) introduces an
32

---

Published as a conference paper at ICLR 2026
LLM-PPannne (Song et al. 2023) performs few-shot high-level planning for embodied agents using GPT-3, grounded in the agent's 's current observation. Given an instruction and detected objects from the scene, it generates sequence of subgoals using in-context prompting with retrieved examples. The planner executes one round of goal prediction, followed by execution via a separate low-level controller. If subgoal fails due to timeout invalid actions, the agent re-queries the environment and replans grounded on updated visible objects.
FLTRNN (Zhang et al., 2024) addresses the faithfulness problem in long-horizon task planning with language-based RNN framework. Given a high-level
LLMs by introducing a task goal, first decomposes the instruction into subgoals using a pretrained LLM, then solves each subtask sequentially with long-short term memory to retain relevant rules and execution summaries. The model incorporates Rule Chain-of-Thooue mechanism and an external memory graph to enhance reasoning and prevent rule violations.
RoCo (Mandi al. 2023) introduces multi-robot collaboration framework driven by LLM-based dialogic planning and motion execution. Each robot is equipped with an LLM agent that decomposes high-level tasks into spatially grounded subtasks through natural language communication. Robots engage in multi-turn dialogue to allocate goals, reason over constraints, and jointly refine execution plans. After each subtask is assigned, motion plans are generated and validated; execution failures trigger replanning via updated dialogue rounds.
For all the baselines, we implemented their respective methods and adapted the specific tasks in their prompts fit our scenes. For detailed prompts of the baselines, please refer to codebase in supplementary materials.
E.2 BACKBONE MODELS
We adopt m3e-base Team
as the retriever of RAG.
To evaluate RoboPARA, we conducted the full set of experiments on top of two LLM backbones OpenAl 4hatGPT-40 (OpenAl) (https://chatgpt) com/) and DeepSeek V3 (dee) (https)
w/www.c www.:edeepee..coom com/).
E.3 ABLATIONS
We ablate four design choices (environment information, instructional constraints, arm selector, and DAG correction) in VOYAGER and study their impact on exploration performance.
w/o environment information: We exclude environment information from the prompt for
DAG generation.
w/o instructional constraints: We exclude instructional constraints 2) to 18) from the prompt for the first call of DAG generation. See full system prompt for DAG stage (First Call) in Sec. A.2.2 for details.
w/o arm selector deadlock check and rebuild: We only apply Case IV (basic selecting strategy: choose the earliest free arm) in Alg. excluding arm state check, deadlock check and rescheduling.
w/o DAG correction: We exclude checking structural consistency and rebuilding DAG graph in Alg. [ only remaining the first call.
E.4 MORE RESULTS ON DIFFERENT LLM FOUNDATIONS
The main text presents experimental results based on the GPT-4o foundation model. Here, we additionally report results of the full set of experiments under the DeepSeek V3 foundation model. Across both LLM backbones, our framework consistently outperforms all baselines, highlighting its robustness to variations in underlying models.
33

---

Published as a conference paper at ICLR 2026
Table 8: Quantitative results of dual-arm task planning under scenes with DeepSeek V3 foundation model. t: higher is better, 4: lower better. The red orange and yellow colors denote the best, the second best, and the third best results, respectively.
Agriculural Greenhouse
Factory
TFR.
PPR
AFR
1bl
TFR.L
PPR
APR
1
APR.1
Tkl
1
APR
LLMP
0.934
0.467
0.000
0.129
1.573
0.000
0.223
1.171
0.179
0.000
0.190
1,280
0.351
0.000
0.235
CharGPT: Prompts
0,762
0.200
0,000
0,000
2/A
0.208
0.900
0,000
2/A
0.394
0.000
0,000
N/A
0.450
0.000
0,000
VOYAGER
0.000
1.000
0.000
0,000
0.000
1.000
0,900
0,000
0.000
1.000
0.000
0.000
0.000
1.000
0.000
0.000
Embodiee TaPA
0.858
0.479
0,000
0.059
L,37
0.461
0,000
0.094
0.906
0.553
0.000
0.091
0.657
0.467
0.000
0.027
LLM Phance
10:55
0.304
02004
0300
1933
0.490
0,800
1,039
13951
0.431
0,000
0,084
0.885
0.356
0,003
0,043
Fl TRNN
0.912
0.000
0.000
0.000
1.072
0.050
0.800
0.000
0.921
0.057
0.000
0.000
0.875
0.162
0
0.034
RoCo
1.001
0.084
0.000
0,045
0,000
0.057
0.933
0.159
0.000
0.101
0.905
0.013
0.000
0.063
RoboPARA
1,30
0.033
1,539
1.251
0,000
0.319
1.445
0.008
0,000
Table 9: Quantitative results of dual-arm task planning with different package difficulties with
DeepSeek V3 foundation model. t: higher is better, 4: lower is better. The red orange and
yellow colors denote the best, the second best, and the third best results, respectively.
Easy Packages
Medium Packages
Hard Packages
Package difficulty
PPR
1
TH1 f
1
1
TFR
LLM
1,869
0.125
0.000
0.238
1.225
0.327
0.000
0.192
0.609
0.401
0.000
0.152
ChatGPT
ChaiGiT-Proopit Prompts
NIA
0.227
0.000
0.000
N/A
0.131
0,000
0.000
N/A
0.430
0,000
0.000
VOYAGER
0.000
1.000
0.000
0.000
0.000
1.000
0.000
0.000
1.000
0.000
0.000
Embodied TaPA
1.482
0.265
0:000
0.099
0.774
0.591
0.000
0.052
0.435
0.614
0,000
0.053
-lannern
1.630
0.210
0.003
0.080
0.889
0.298
0.000
0.077
0.354
0.678
0.000
0.020
FLTRNN
1.406
0.000
0.000
0.000
0,930
0.087
0.000
0.003
RoCo
1.551
0.083
0.000
0.117
0.958
0.061
0.000
0.043
0.479
0.148
0.000
0.040
RoboPARA
2.053
0.000
0.047
0.309
1.385
0.000
0.013
0.333
0.787
0.057
0,056
0.327
E.5
OTHER EXPERIMENTS
E.5.1
ADDITIONAL RESULTS ON OTHER SCENES
Due to space constraints, the main text reports results from only four scenarios. Here, we provide the complete test results for the remaining six scenarios in the X-DAPT dataset.
E.5.2 ADDITIONAL RESULTS ON ROBOTWIN DATASET
To further test the generalization and robustness of our planning method across existing datasets, extend experiments the RoboTTwin (Mu et al. 2025) dataset, which provides 50 dual-arm manipulation tasks of varying difficulty. While RoboT is originally designed for validating low-level execution (System-l), its tasks inherently atomic and short-horizon. To align with our focus on high-level durl-arm planning, we reorganize RoboTwin by grouping and integrating multiple related tasks into coherent scene-level configurations. This result the following dataset in Table
RoCo
RTRMM
LIM3
Embosied th LIMs
RybePARA
3 9.46
7.51
6.89 7.38 7.02 6.888
7.09
6.54
11.99
7.23
9.71
1.49
110.99
7.04
4.64 7.57
0.02
B.52
6.07
13.79
72
11.53 9.05
5.30
4.88
4.73
5.10
3.84
5.03
7.75
4.23
6.10 3.03
4.05
3.83 4.57
5.03
3.75
5.15
6.67
6.55
2-2.41
2.64 2:00 3-1.6
2.21
3.88
2.75
2.88
3.664
1.78
1.45
2.15
1.01
5.2.25
3.78
3.18
oth Ciben Paleyaptiooo
on...
Othe Elibes Fallyapnddon
Figure 6: TEI performance across different frameworks with DeepSeek V3 foundation model. The heatmap shows the total TEI scores (higher is better) aggregated over all packages for each combination of scene (horizontal axis) and package difficulty level (vertical axis). RoboPARA consistently achieves the highest TEI across all scenarios, particularly excelling in harder packages and complex scenes. VOYAGER (Wang et al. 2023) and CharGPT-Prompts (Wake et al, 2023) are not included due to incompatibility.
34

---

Published as a conference paper at ICLR 2026
Table 10: Quantitative results on the Supermarket. Hospital, and Disaster Rescue scene. 1: higher better, 4: lower is better. The red orange and yellow colors denote the best, the second best, and the third best results, respectively.
Supermarket Scene
Hospital Scene
Disaster Rescue Scene
Soene
TEL 1
TFR 4
PPR 1
APR
TEI 1
TFR
PPR
APR |
TEI
TFR
PPR
APR 1
LLM3
0.81
0.33
0.00
0.00
0.94
0.25
0.00
0.01
0.87
0.24
0.00
0.00
ChrmPP--rrompis
1.02
0.83
0.00
0.79
0.12
VOYAGER
0.00
1.00
0.00
0.00
0.00
1.00
0.00
0.00
0.00
1.00
0.00
0.00
Embodied TaPA
0.85
0,20
0.00
0.01
0.76
0.08
0.00
0.01
0.91
0.18
0.00
0.01
LLM-Planner
1.21
0.00
0.16
1.08
0.21
0.00
0.14
1,10
0.22
0.00
FLTRNN
1.05
0.00
0.00
0.01
1.03
0.02
0.00
0.02
1.04
0.00
0.00
0.01
RoCo
1.01
0.15
0.00
0.01
0.95
0.19
0.00
0.01
1.01
0.16
0.00
0.02
RoboPARA
1.34
0.00
0.12
0.39
1.29
0.00
0.00
0.41
1.35
0.01
0.17
0.43
Table 1I: Quantitative results on the Hotel, Pet Shop, and Library scene. t: higher is better, 4:
lower is better. The red orange and yellow colors denote the best, the second best, and the third best results, respectively.
Hotel Scone
Pet Shop Scene
Library Scene
Scene
TEI
TFR
PPR
APR
TEI
TFR
1.
PPR
APR
TFI
1
TFR
PPR
APR
LLM3
0.88
0.26
0.00
0.01
0.91
0.22
0,00
0.01
0.89
0,28
0.00
0.01
ChaiGPT-
0.93
0.19
0.00
0.01
0.86
0.00
0.00
0.00
0,92
0.12
0.00
0.01
VOYAGER
0.00
1.00
0.00
0.00
0.00
1.00
0,00
0.00
0.00
1.00
0.00
0.00
Embodied TaPA
0.84
0.00
0.00
0,01
0.82
0.25
0,00
0.01
0,87
0.23
0.00
0,01
LLM-Plamner
1.09
0.23
0.00
0.16
1.07
0.19
0.00
0.15
1.13
0.18
0.00
0.15
FLTRNN
1.00
0.00
0.00
0.02
1.02
0.00
0.00
0.02
1.06
0.01
0.00
0,02
RoCo
0.97
0.18
0.00
0.01
0.94
0.16
0.00
0.01
0.98
0.21
0.00
0.01
RoboPARA
0.00
0.00
0.22
1.36
1.32
We compare RoboPARA with the baselines on the extended RoboTwin dataset, as shown in Table Across all difficulty levels, RoboPARA consistently generates valid and executable plans while most baselines suffer from frequent task failures in more complex scenarios. Morcover, RoboPARA demonstrates stronger utilization of dual-arm concurrency, leading to higher efficiency and smoother coordination between arms. These results underscore RoboPARA's generalizability and robustness across diverse planning domains and datasets.
E.6 CLOSED-LOOP ERROR HANDLING
Closed-loop capability is recognized cornerstone of embodied AI systems. Unlike open-loop pipelines, where planning is executed once without feedback, closed-loop systems can perceive the environment, detect failures, and dynamically replan. This ensures robustness when execution diverges from the original plan due to uncertainties in perception, manipulation, or external distur- bances. RoboPARA operates at the System-2 level of high-level planning, yet it explicitly designed with mechanisms to respond to System-1 execution contingencies. In practice, when unexpected physical realities occur (such as an object being dropped, misplaced, or obstructed), RoboPARA can immediately update its task description with the new environment state and generate revised plan.
To make this process concrete, we provide the following illustrative example: the robot is tasked with preparing two simple dishes, "make carrot slices (A1 (A1-A5)" and "make apple salad (B1-B5)". The step-by-step breakdown is presented in Table 14 and Table I5
RoboPARA then generates the execution plan, shown in Table 16
We assume that at the 12-second mark, the robot's right arm accidentally drops the apple onto the table while attempting to place it on the cutting board, interrupting the task. RoboPARA is capable of updating the prompt, re-executes the planning process, and generates a new plan starting from that moment. It can be observed that RoboPARA successfully resumes and completes the task. The new plan from that moment is presented in the following Table Despite these disturbances. RoboPARA demonstrates the ability to replan by updating the latest observations. This design enables seamless
35

---

Published as a conference paper at ICLR 2026
RoCo
FUTRNN
LLM3
ChatGPT-Prompis
Embodied TaPA
LLM-Planner
RoboRARA
8
4.834.099.00
5,90
82 6.68
7.09 6.54
7.82 6.68
6.54 3.79 5.58 7.09 6.54
7.04 6.687.00
1.82 6.68 8.85
00736.911..0 18
1067665..71
22662 2.322.322.32222
2.60 2.36
2.3 2.30
2.16 2.36 1.57
-2.41
2.232.12
2.355
2.35
2.6601990
2.66
2.39
3. 2727771
1.55 664.722
9.514.893.79 3.25
Di Eicletatee d6n
05 Cheeeteeetie Ap
Amn
A64
A6t
Figure 7: TEI performance across different frameworks with GPT-4o foundation model. The heatmap shows the total TEI scores (higher is better) aggregated over all packages for each combina- tion of scene (horizontal axis) and package difficulty level (vertical axis). RoboPARA consistently achieves the highest TEI across all scenarios, particularly excelling in harder packages and complex scenes. VOYAGER (Wang et al. 2023 is not included due incompatibility.
Table 12: Complete list of the reorganized RoboTwin dataset for high-level planning.
Difficulty
Task ID(s)
Easy
3, 4,4,
Medium
24, 26, 26-27, 28-30, 29-31
Hard
1-6, 8-10, 22-24, 32-34, 38-339 48-50
continuity between planning and replanning, reinforcing RoboPARA's robustness across dynamic environments.
Building this illustrative case, further conduct broader set of evaluations to systematically assess the robustness RoboPARA's closed-loop replanning capability. Specifically, we select nine representative tasks of varying difficulty levels from the X-DAPT kitchen dataset. For each task, introduce artificially designed execution errors to simulate realistic System-1 failures. Despite these disturbances, RoboPARA consistently replan and complete the tasks, confirming its ability adapt dynamically and sustain reliable performance under error-prone conditions. The summarized settings and results are presented in Table 18
E.7
FIELD TESTS
We select several representative samples from the benchmark dataset in our experiments for real- world testing. The hardware setups and representative testing environments of the three dual-arm robotic platforms are shown Fig.
E.7.1 HUMANOID ROBOT
The results of the real-world tests on Humanoid robot are presented in Fig. I The results are based on GPT-4o foundation LLM.
Table 13: Quantitative results on the RoboTwin dataset. t: higher is better, 4: lower better. The red. orange and yellow colors denote the best, the second best, and the third best results, respectively.
Easy
Medium
Hard
Method
TEI 1
TFR
APR 1
TEL
TFR. J
APR
TEI
TFR
APR
LLMB
6.7
0.0
0.0
2.1
0.2
0.1
1.0
0.4
0.1
ChamGPT-Prompts
8.0
0.0
0.2
1.7
0.0
Embodied TaPA
8.0
0.0
0.3
4.5
0.2
1.8
0.0
0.2
PLM--en
6.7
0.0
0.1
2.2
0.2
0.1
1.0
0.4
0.1
FLTRNN
6.7
0.0
0.0
3.1
0.2
1.8
0.0
RoCo
7.3
0.0
0.2
1.4
0.2
RoboPARA
10.6
0.6
2.4
36

---

Published as a conference paper at ICLR 2026
Table 14: Detailed breakdown of the task "make carrot slices"
Step
Action
Source
Target
Arm Type
Duration
A1
pick
table
carrots setting_board knife
Single arm
sec
A2
place carrots
Single arm
7 sec
A3
pick counter
Single arm
sec
A4
cut knife
carrots counter
Dual arm
10 sec
A5
place
knife
Single arm sec
Table 15: Detailed breakdown of the task "make apple salad"
Step
Action
Source
Target
Arm Type
Duration
B1
pick
table
apples cutting_boar knife
Single arm
sec
B2
place apples
Single arm
7 sec
pick counter
Single arm
sec
B4
cut
knife
apples
Dual arm
10 see
B5
place
knife
counter
Single arm
sec
E.7.2 FRANKA RESEARCH STATION
We perform real-world experiments using the Franka robotic arms in agricultural greenhouse scene with DeepSeek V3 foundation LLM. The task is defined as "pack eucumbers and prepare seed tray for sprouting", and all baselines are evaluated under this task.
Retrieved packages and steps for task "pack eucumbers and prepare seed tray for sprouting".
Package A: Harvest and Pack Cucumbers
Al: pick [iAccocoucccctttrrage_eelllll seconda)
target="cucumben (Single arm, 5
A2: place (source="cucumber) target-"basket") (Single arm, seconds)
A3: pick (source="cauntse kni (Single arm, seconds)
A4: cut (source="knite" target="cucumber (ttpeuuuubrereeeee_eaeeeaa
stem") (Dual arm, 10 seconds)
A5:
place (source="kniie", target==counter") (Single arm, seconds)
Package B: Prepare Seed Tray for Sprouting B1: pick
target="seed_tray") (Single arm, 5
seconda)
32: place (sooroco=== seconds)
target="work_table"" (Single arm,
B3: piccee target="seeds") (Single arm, 5 seconds)
B4: pour_into (solreteoossorrreseeesssss carget="seed_tra" (Single arm, seconds)
Lettuce_seedeeeeeeeeeeeeeeeeseee (saurcee"Ltttucceeeeeed seconds)
B5: place (source=
(Single arm, 5
Crine
Fand
(a) Humanoid Robot
(b) Franka Research Station
(c) URSe Station
Figure 8: Hardware configurations of the dual-arm robots used in the experiments.
37

---

Published as a conference paper at ICLR 2026
Table 16: Original execution plan generate by RoboPARA.
Time (8)
Left Arm Action
Right Arm Action
pick ("table", "carrots") place ("carrot.s", poattingg_bord"" place (ance(aagn ("apples", "cutting_boardy"
pick ("table", "apples")
5-12
12-17
pick ("counter", "knife") ("knifee"" "cazrota") cut ("knife", "apples") place ("knife", "counler")
17-27
("knifeeee" "carrots") cut ("knife", "apples")
27-37
37-42
Table 17: The new plan generated by RoboPARA at the 12-second mark.
Time (s)
Left Arm Action
Right Arm Action
0-5
pick ("table", "apples") place ("apples", "cutting_board") place ("apples",
5-7
7-12
pick ("counter", "knife")
boarrd") cut ("knife", "carrots") cut ("knife", "apples")
12-22
out ("knife", "carrots")
22-32
cut ("knife", "apples")
32-37
place ("knife", "counter")
B6: pick "eoorrce""aaer_sttee seconda)
(Single arm, 5 (Single arm, place (source= can"", target= statioosstatin") (Single arm, 5 seconds)
B/:
pour into (source="watering can",
seconds)
39:
The initial setup of the scene is shown in Fig. 9 Planning results of RoboPARA and all baselines are shown Fig. 10 RoboPARA enables reordering and parallel execution while maintaining correctness by uncovering latent logical dependencies between task steps, thereby achieving optimal parallelism and outperforming all baseline methods (Table 19
Pack cucumbers and prepare seed tray for sprouting.
Of course! Let me get started right away.
Arm
Right Arm
counter
knife
storage shelf
seed
seed
watering
seeds
water station
can
cucumber
basket
Figure 9: Initial setup of the agricultural greenhouse scene for RoboPARA and all baselines. Two Franka Research 3 robotic arms used in this experiment.
38

---

Published as a conference paper at ICLR 2026
RoboPARA
(a) t+0
(b) 1
(c) 1111
(d) 1-1
(e) 20
commber
Cac
them lask tix
(+0
11
1-16
(e) 1=26
(1) (-31
LLM
well Oven duef
I. Flave Imyy
X-
Lackedie cocemter
(c)
Pick natrrin Bon nuiciing
mubiiiig waseraa
Embodied TaPA
LLM-Planne lanner
(b) 8m
tr11
tm
(e) bm23
fiam ceceaherte
Pak cossur
(1) 2-
( 36
(h) tm
H t
① 56
ChatGPT SEIrGPT-Promppst Prrompps/ FLLRNN// RoCo
(Sequential execution)
[b) 1-
(b) D
( 1+11
[d) 16
(e) 2+
Nuk tee center
the sale sie nemkee
flan laft cener
(
[8)
()
feeiie suat
Raw and Mnniltale
(K) t:89
E64
Figure 10: Real-world experiments using the Franka robotic arms in agricultural greenhouse scene. L and denote the left and right arms, respectively. VOYAGER (Wang et (203) is not included because it cannot provide explicit plans. Embodied TaPA (Wu et al. 2023) fails because it generates next action (cutting the cucumber) that requires both arms, while the right arm still occupied. RoboPARA outperforms all baseline methods.
39

---

Published as a conference paper at ICLR 2026
Table 18: Closed-loop error handling evaluation. RoboPARA successfully replan in all cases, demonstrating robust recovery across various difficulty levels.
Difficulty
Task
Execution Error
Replan Success
Easy
make carrot and apple slices
apple fell off the cutting board
Easy
make cream bread
bread fell the plate
Easy
set the table
fork fell while taking out of the cabinet
Medium
make
spinach and
when placing
counter
Medium
make fruit salad
banann fell while getting it from the fridge plate
Medium
assemble a sandwich
fell
Hard
make seaweed mushroom soup
mushroom fell while picking it up from the cutting board cheese fell while taking it out fridge
Hard
make creamy pasta
Hard
make stir-ftied rice with green peppers
knife slipped while cutting green pepper
Table 19: Comparison between RoboPARA and baselines using Franka robotic arms in a real- world agricultural greenhouse task with DeepSeek V3 foundation LLM. RoboPARA exhibits the best parallelism and task completion rate, highlighting its high efficiency and strong adaptability to specific application scenarios.
Package difticulty
Total execution time (scoonds)
Execution success rate
Number parallel intervals
LLM [LMg 2024
66
100.0%
ChatGi PPPumplss Wake et al.
2023
77
100.0%
VOYAGER (Wang dal 2025
Embodied [u
Wu
11 (Fail)
46.2% (6 of total 13 steps)
(Fail)
L.M Planner (Sng el al 0026
61
100.00
FLTRNNN (Zhang
77
100.0%
RoCo (Makdi et al. 2025
77
100.0%
E.7.3 URÉE STATION
We conduct real-world validation across 4 different test scenes (kitchen, office, agricultural green- house, factory) using two UR5e robotic arms. The initial setup of the four scenes are illustrated in Fig. I1 The corresponding results are presented in Fig. 12 Fig.
13
Fig. [4] and Fig. 15 respectively.
The results are based on GPT-4o foundation LLM.
(a) Kitchen
(b) Office
(c) Agri- grehhgree
(d) Factory
Figure 11: Initial setup of the scenes for real-world experiments upon UR5e station.
LLM USAGE STATEMENT
Large Language Models (LLMs) used in this work only for grammar checking and light language refinement of certain parts of the INTRODUCTION and CONCLUSION sections to improve readability and presentation quality. All core contributions, including the design of the method, theoretical formulations, experimental setup, and analysis are independently conceived and implemented by the authors without the involvement of LLMss. The full implementation code, experimental scripts and datasets are prepared entirely by the authors, ensuring the accuracy and reproducibility of the reported results. The authors take full responsibility for the limited use of LLMs language polishing and for all claims made in this paper.
40

---

Published as a conference paper at ICLR 2026
(b) 6=5
(c)
(e)
RoboPARA
1: Pidk appño free lakle
Placeppiin catlin boand
Pids kalls Dren counier
Ube knilt sppiic
Lo kailc eut Issesco
Flacs knil bo crusier
Plas
(a) t=
(b) t=5
(c) 1212
(d) 1=17
(6) 2-24
M1 I-29
Sequential Execution
Pidk Inamuna tublle
Plas humasa bucutlag
Let
Use
applie
Pkd kalls faam ouater
R: kuilic sppto
(g) t039
(h) 4-44
(1) t=
①1 t-59
Une kinls henanes US hasfeituee borerton
Ti Plare batli causter
kuiile la couster
Pork Bem muste
Figure 12: Real-world experiments in kitchen scene using the UR5e robotic arms. The task is "cut apples and bananas". Compared with sequential exccution, RoboPARA excels at step consolidation and action merging, leading reduced execution time. This improvement is enabled by the DAG- based dependency reasoning (Sec. 3.4), which accurately captures inter-step dependencies and reveals optimal execution paths.
t=
F
RoboPARA
SBdd spen drower
Li
Siid-cles draver
dessing
deennng
FO
1-
2-21
Exécution
Fldk disntng duth Tress draneer
Place dianting durth deck certur NiBdl cles draneet
Figure 13: Real-world experiments in office scene using the UR5e robotic arms. The task is "clean the office desk".. Compared with sequential execution, RoboPARA emphasizes real-world dual-arm collaboration that closely resembles human behavior. For example, person typically opens drawer with one hand and picks an item with the other, rather than using the same hand to open, fetch, and close the drawer sequentially.
41

---

Published as a conference paper at ICLR 2026
RoRO
tmo
(b) 5
(c)
(d) t0
(e) t=25.
1:31
our Eara presedd
3: cuupuet
(b) t
(C) 1-15
(d) 1-20
(e) F-25
M FS
Sequential Execution
preskig deursta
L. Pick ran Dant couter
(g)
1-36
(h) 1=42
Figure 14: Real-world experiments in agricultural greenhouse scene using the UR5e robotic arms. The task is "cut and sort tomato vines". Compared with sequential execution, RoboPARA emphasizes intra-package parallelism, which fully leverages dual-arm -rmm resources and greatly boosts task completion efficiency.
(a) D
(b) 5
(c) 1-11
(d) t 16
24
(1) 2-27
RoboPARA
Pilk exreri Faee rail
Plae exnelite monell Fall welterr wartbbock
srem drteer
Palk
Ple Fall
Fkk calie 2um
Plax
(a)
(b)
Sequential Execution
to anuully
veltnakera natthacc
Palk calle Sacx
Daucalla stick voluute cabla bolder
Figure 15: Real-world experiments in factory scene using the UR5e robotic arms. The task "assemble tool components and prepare electrical tools". Compared with sequential execution. RoboPARA highlights pross-package parallelism, demonstrating higher-level task planning and integration capabilities.
42


Reviews:
[{"review_id": "06WqHZqIVH", "reviewer": "Reviewer_Eb8e", "summary": "This paper introduces RoboPARA, an LLM-driven framework for dual-arm parallel task scheduling in robotic manipulation, addressing the limitations of existing methods in exploiting temporal overlap across sub-tasks. RoboPARA adopts a two-stage pipeline: (1) dependency-graph-based candidate plan generation, and (2) graph re-traversal-based concurrent execution scheduling for dual-arm coordination. To evaluate parallel execution capabilities, the authors present X-DAPT, the first benchmark dataset dedicated to dual-arm temporal parallelism, encompassing diverse scenarios and task complexities. Extensive experiments demonstrate that RoboPARA outperforms baseline methods in terms of parallel step count, execution time reduction, and task success rate.", "questions": "1.Unclear details of real-robot experiment implementation: How to construct the Graph during real-robot experiments? Is it necessary to pre-abstract objects in the scene? Additionally, how are the execution times of different actions defined and determined?\n\n2.Lack of exploration of Visual-Language Models (VLMs): The paper only uses LLMs for dual-arm task planning, while existing state-of-the-art VLM models have shown strong task planning capabilities. It is questioned whether attempts have been made to use SOTA VLM models for dual-arm parallel tasks, and if so, what their efficiency is and whether they can ensure safety during execution.", "limitations": "", "rating": 4, "confidence": 5, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "1.The two-stage architecture of RoboPARA effectively models task dependencies and optimizes dual-arm parallelism, fully exploiting the collaborative potential of dual-arm robots.\n\n2.The X-DAPT dataset is the first dedicated to evaluating dual-arm task parallelism, covering diverse scenarios and difficulty levels, providing a comprehensive benchmark.\n\n3.RoboPARA demonstrates excellent performance in experiments, with significant improvements in parallel steps, execution time reduction, and task success rate compared to baselines.", "weaknesses": "1.Limited generalization capability: RoboPARA relies on predefined skill libraries and scenario templates, requiring abstraction for novel tasks or environments. This hinders its scalability to long-horizon, multi-stage and complex tasks and out-of-distribution scenes.\n\n2.Mismatch between optimization objective and real-robot deployment: The planning stage minimizes estimated action duration, but accurate execution latency is hard to obtain and estimate accurately in real-world settings. As a result, the optimized schedule may not be truly time-optimal on physical hardware, raising concerns about its perfect application in real-robot experiments.\n\n3.Lack of safety considerations: Safety is a critical metric in dual-arm parallel task execution, but how to avoid collision problems during execution is not discussed. For example, the paper mentions that single-arm tasks are preferentially assigned to the left arm when both arms are idle, and it is questioned whether this is reasonable.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "1s20DsRH00", "reviewer": "Reviewer_qpfb", "summary": "This paper introduces RoboPARA, a novel framework for dual-arm robot task planning that prioritizes the optimization of task parallelism. The authors formulate a new problem, the \"Dual-Arm Cooperative Scheduling Problem\", which aims to minimize the makespan (total execution time) by effectively scheduling tasks across two arms. The proposed RoboPARA framework operates in a two-stage process : first, it uses an LLM, augmented with a memory module (RAG) , to generate a Directed Acyclic Graph (DAG) representing task dependencies. Second, a \"Graph Re-Traversal\" algorithm, which is non-LLM based, optimizes this DAG to schedule operations, maximize parallel execution, and resolve conflicts.\n\nTo evaluate this framework, the authors also introduce the \"Cross-Scenario Dual-Arm Parallel Task dataset\" (X-DAPT) , a new benchmark containing over 1,000 tasks across 10 scenarios designed specifically to test dual-arm parallelism. Experimental results claim that RoboPARA significantly outperforms existing methods, achieving a 30% to 50% reduction in execution time and demonstrating superior parallel step execution, particularly in complex tasks.", "questions": "1. Can the authors explain the 0.000 performance of all baselines on the PPR/APR metrics on X-DAPT? Does this not suggest the benchmark is built exclusively to validate the RoboPARA architecture, rather than to provide a fair comparison? Why is the performance gap so much smaller on the RoboTwin dataset?\n\n2. How much manual effort is required to adapt the 19-point prompt template  to a completely new domain with new objects and dependencies? Does the reliance on such extensive, hard-coded domain knowledge not fundamentally limit the \"LLM-driven\" nature of the approach?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "The paper's primary strength is its formalization and direct confrontation of parallelism in dual-arm manipulation. While prior work often results in sequential execution , this paper defines a new, relevant problem (\"Dual-Arm Cooperative Scheduling\") and proposes a solution explicitly designed to optimize for it. This focus on decoupling tasks for parallel execution, rather than purely sequential or fully synchronous collaboration, is a significant and practical contribution.\n\nThe two-stage, hybrid architecture is a sound engineering approach. It leverages the LLM's strength in parsing human instructions and understanding task semantics to generate an initial plan (the DAG). It then wisely offloads the \"System-2\" optimization—a constrained scheduling problem—to a deterministic, algorithmic \"Graph Re-Traverse\" stage. This avoids the unreliability of using LLMs for complex, multi-step symbolic reasoning and allows for the implementation of robust logic, such as deadlock prevention and arm-lock compatibility checks .\n\nSimilar to the method, the X-DAPT dataset is a valuable contribution. The authors correctly identify that existing benchmarks often lack tasks with complex, inter-package dependencies that can be parallelized. By creating a dataset with multiple difficulty levels and a focus on long-horizon, multi-package scenarios , the authors provide a new and challenging testbed for the community to evaluate this specific dimension of robotic planning.\n\nThe paper is clearly written, and the framework is well-illustrated. The separation of Stage 1 (LLM-driven DAG generation) and Stage 2 (Algorithmic scheduling) is logical and easy to follow. The inclusion of detailed prompt templates in the appendix, while extensive, adds to the paper's transparency and reproducibility", "weaknesses": "The authors designed both the solution (RoboPARA) and the primary benchmark (X-DAPT) on which it demonstrates overwhelming superiority. The results in Tables 1 and 2 show that RoboPARA achieves high scores on the new parallelism metrics (PPR and APR), while all seven baseline methods score 0.000 or near-zero on these metrics in almost every single category. This result is suggesting that the X-DAPT benchmark is overtuned to the specific graph-based, parallel-aware architecture of RoboPARA. This suspicion is reinforced by the results on a neutral, third-party benchmark (a reorganization of the RoboTwin dataset) . On RoboTwin (Table 13), RoboPARA still performs best, but the gap is far less dramatic. For example, on \"Easy\" tasks, RoboPARA's efficiency (TEI) is 10.6, while two baselines achieve 8.0. This is a reasonable improvement, not the 10x+ gap seen in the X-DAPT parallelism metrics. The overwhelming superiority vanishes on a benchmark the authors did not design.\n\nThe paper's core claim is a 30-50% reduction in \"execution time\", which is commendable. However, the paper's own limitations section admits that RoboPARA \"consumes an average of 1.3x more tokens than baselines due to iterative DAG corrections\". This suggests a significantly higher planning latency before execution can even begin. For many real-world, dynamic tasks, a 30-second reduction in execution is not a net gain if it requires an extra 60 seconds of planning. The paper's primary metric, TEI, is defined as successful steps divided by total task completion time in seconds , which seems to include planning time, but this is not explicitly stated. This ambiguity around the planning-time vs. execution-time trade-off is a major omission.\n\nThe method's success in Stage 1 is heavily dependent on extremely detailed, hard-coded prompt engineering. The appendix reveals that \"Template 2a: Dependency-Aware Graph Construction\" contains 19 separate, highly specific rules (e.g., \"Rule 10: The cutting operation can only begin when all objects are placed...\") . This raises serious questions about the method's generality. It appears less like a general-purpose planner and more like a system purpose-built and meticulously tuned for the 10 scenarios in the X-DAPT dataset. It is unclear how this method would scale to a new domain (e.g., \"car repair\" or \"lab automation\") without a similarly exhaustive, manual-engineering effort to define all domain-specific dependency rules.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "feQrTkBKCj", "reviewer": "Reviewer_F7jN", "summary": "This paper addresses the problem of parallelism optimization in dual-arm robot task planning. It introduces a two-stage architecture that combines LLM-based dependency graph generation with graph re-traversal-based parallel planning. The proposed method achieves state-of-the-art quantitative performance and is validated on a real dual-arm robotic platform. The paper also presents a benchmark dataset for evaluating parallelism in dual-arm manipulation tasks.", "questions": "1. If one arm fails during task execution, how does the system respond? Does it restart the full plan or perform immediate rescheduling?\n2. Can the proposed method be extended beyond dual-arm setups, for example, to systems with three arms or super-limb robots?\n3. What LLM model was used for dataset construction, and how many human annotators were involved in verifying the structures?\n4. What is the API usage or token cost associated with the full planning pipeline?\n5. What is the total planning time, including both dependency graph construction and scheduling optimization?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 4, "contribution": 3, "strengths": "1. While minimizing task time or improving efficiency in dual-arm robots is not a new problem, the paper’s approach is novel in leveraging the semantic reasoning capability of LLMs to extract task dependency graphs from complex multitasking instructions to maximize parallelism. \n2. Once released, the proposed dataset could make a meaningful contribution as a dual-arm task dependency dataset, potentially serving as a valuable benchmark for studying parallel manipulation and LLM-based task planning. (Note: since the dataset is not yet released and details such as its size and format are missing, this strength is currently conditional.)\n3. The experimental design and analysis are appropriate, and the framework is successfully deployed on a real dual-arm robot, demonstrating practical feasibility.\n4. The problem formulation is clear, the paper is well organized, and the visualizations are strong and intuitive.", "weaknesses": "1. While the paper includes a DAG validation and correction step to ensure logical consistency, it seems that this process lacks deep physics-aware validation. Crucial physical constraints like spatial conflicts, reachability, and precise timing are not rigorously checked during the initial DAG generation or correction phase, potentially leading to logically sound but physically infeasible plans that might only be detected later during execution or scheduling.\n2. The paper introduces a rollback mechanism in Stage 2 to resolve deadlocks arising from parallel execution attempts. While it is important, the paper lacks in-depth analysis on how frequently this rollback was triggered during experiments and its associated performance cost (e.g., increased makespan compared to an ideal parallel plan). This lacking of analysis makes it difficult to fully assess the real-world efficiency impact of the deadlock resolution strategy.\n3. The paper does not provide a formal or empirical analysis of computational complexity as the number of DAG nodes increases. Since both graph construction and re-traversal rely on LLM-based reasoning, the computational cost may grow quadratically or even combinatorially with larger task graphs. While the authors mention scalability, no details about timing or efficiency results are discussed. An discussion or ablation on graph size scalability would strengthen the paper.\n4. The paper shows that RoboPARA’s components are necessary, but it does not fully disentangle the effects of Stage 1 and Stage 2. The analysis focuses on outcomes (e.g., increased parallelism) rather than underlying causes, and it is not specified whether the improvement in Stage 2 comes from enhanced LLM self-consistency or simply from iterative refinement.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "fqUOFohbkc", "reviewer": "Reviewer_4Bah", "summary": "This work proposes RoboPARA, a framework for using large language models (LLMs) for dual-arm task parallelism planning. The framework employs a two-stage process: (1) Dependency Graph-based Planning Candidates Generation and (2) Graph Re-Traversal-based Dual-Arm Parallel Planning. Highlight of the proposed framework is constructing and traversing directed acyclic graphs (DAGs) that model task dependencies and eliminate redundancy. The authors also introduce the Cross-Scenario Dual-Arm Parallel Task dataset (X-DAPT dataset), designed to evaluate dual-arm task parallelism across diverse scenarios and difficulty levels. Extensive empirical results are provided to demonstrate that RoboPARA significantly outperforms existing planning methods, especially in complex task combinations and in requiring less execution time than baseline methods while achieving similar task performance.", "questions": "1. The authors mentioned \"GPT-4o and DeepSeek V3 APIs incurs significant costs\" -- besides financial costs, does using the LLM APIs incur delays in between queries, and does that pose a problem for smooth robot action execution? \n\n2. What kind of inaccuracies do the robot agents struggle to self-correct or re-plan? Again, providing video results would be very helpful.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "1. The paper has high presentation quality and easy-to-follow writing. The appendix section provides extensive details on various aspects of the method details and experiment settings. \n\n2. Real world experiments span multiple robot setup and various tasks, which speak for the generality of the proposed framework and applicability to real robot systems. \n\n3. The proposed framework achieves clear reduction in execution time while maintaining task success. Comprehensive experimental results and dedicated efforts to re-implement and compare against various baselines, which had different assumptions and task settings in the original works.", "weaknesses": "1. Lack of video results. Although various figures throughout the manuscript show task setups and robot configurations, a video of actual task completion will be much more convincing and conveys more clarity on the task settings. \n\n2. Minor grammar issues, e.g. lack of spacing (Line 1834, 1835, RoboPARAsuccessfully, RoboPARAdemonstrates). \n\n3. The proposed framework treats bimanual manipulation as a planning problem over two arms, but concurrently there is also many efforts on learning end-to-end policies from bimanual teleoperation data. It is unclear whether the two-arm planning approach is still needed or would need a major modification when bimanual policies can easily leverage two arms at once to perform many complex task motions.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)