MODAP: Makespan-Optimized Dual-Arm Planner

• MODAP is a makespan-optimized dual-arm planner that combines discrete task planning with continuous motion optimization for efficient tabletop rearrangement.
• It employs a three-stage pipeline: makespan-oriented MCHS planning, IK-based sub-task decomposition, and GPU-accelerated collision-aware trajectory refinement.
• Experimental results show MODAP reduces execution time by 13%-44% vs. baselines while ensuring collision-free, dynamically feasible trajectories.

Searching arXiv for the cited paper and closely related methods to ground the article. MODAP, short for Makespan-Optimized Dual-Arm Planner, is a tightly integrated planning and control optimization pipeline for fixed-base dual-arm rearrangement in a shared workspace. It targets long-horizon task and motion planning under strong coupling between discrete task assignment and continuous trajectory generation, with the explicit objective of reducing actual clock time rather than only discrete plan length. In the reported formulation, MODAP jointly optimizes synchronous high-level actions and time-parameterized dual-arm trajectories for constrained tabletop multi-object rearrangement, while enforcing collision avoidance, kinematic validity, and joint velocity, acceleration, and jerk limits (Gao et al., 2024).

1. Problem setting and design objective

MODAP is formulated for a real dual-arm system in which two arms operate in close vicinity to solve highly constrained tabletop multi-object rearrangement problems. The input is a start arrangement $\mathcal A_s$ and a goal arrangement $\mathcal A_g$ for $n$ tabletop objects in a planar workspace $\mathcal W$. The output is a dual-arm trajectory $\mathcal T=(q^1(t),q^2(t))$ that is collision-free, dynamically feasible, and close to makespan-optimal in continuous time (Gao et al., 2024).

The central design choice is to optimize makespan across both planning layers. At the discrete level, this means minimizing the number of synchronous action steps. At the continuous level, it means minimizing the overall completion time $T$ of the executed trajectory. This is consequential because a dual-arm rearrangement system can admit plans with similar symbolic structure but markedly different wall-clock execution time once inter-arm conflicts, velocity limits, and time scaling are taken into account.

The paper places MODAP within the broader difficulty of long-horizon task and motion planning, noting that the interleaved task and motion planning phases are tightly coupled and that each phase on its own is frequently NP-hard or even PSPACE-hard. MODAP addresses this by avoiding a strict separation between symbolic planning and geometric control, instead using a pipeline in which discrete planning decisions constrain continuous optimization and continuous conflict handling feeds back into effective parallel execution (Gao et al., 2024).

2. Three-stage pipeline

MODAP proceeds in three tightly coupled stages: discrete task planning, sub-task decomposition with IK sampling, and continuous motion planning with optimization (Gao et al., 2024).

In the first stage, MODAP invokes a makespan-oriented task planner, MCHS, to produce a synchronous high-level plan. Each plan step is one of three action types: an overhand pick-and-place by arm $r_1$ or $r_2$, a handoff between $r_1$ and $r_2$, or idle for one arm while the other works. The resulting sequence has length $\mathcal A_g$0 and minimizes the number of action steps, thereby minimizing joint makespan in the discrete sense.

In the second stage, each high-level action is immediately decomposed into arm-specific lower-level sub-tasks. These are Traveling Tasks (TT), corresponding to motion between home, pre-pick, pre-place, or pre-handoff poses; Manipulation Tasks (MT), corresponding to straight-line in/out motions for pick, place, and handoff; and Gripper Tasks (GT), corresponding to open/close dwell. This decomposition provides the interface between symbolic coordination and motion generation.

A key feature of this stage is intelligent seeding of the inverse-kinematics solver in cuRobo. For sub-tasks with end-effector pose $\mathcal A_g$1, MODAP biases IK toward well-conditioned solutions rather than allowing an unconstrained return of many possible arm postures. For TTs, the seed is chosen so that the end-effector lies approximately 30 cm above the reachable workspace. For MTs, the current joint configuration is used as the seed. The stated purpose is to avoid “elbow-down” or overly contorted solutions, prune poor sub-task configurations, reduce downstream search complexity, and prevent spurious detours (Gao et al., 2024).

In the third stage, MODAP interleaves single-arm planning through GPU-accelerated cuRobo with collision-aware conflict resolution until both arms’ sub-task buffers are empty. Every appended trajectory segment is then post-processed by Toppra for time-optimal path parameterization under joint velocity, acceleration, and jerk bounds. The final product is a time-parameterized trajectory that avoids self-collision, inter-arm collision, and workspace collision while nearly minimizing actual clock time (Gao et al., 2024).

3. Optimization formulation and dynamic constraints

At the continuous level, MODAP seeks trajectories

$\mathcal A_g$2

that minimize the completion time $\mathcal A_g$3:

$\mathcal A_g$4

The optimization is subject to boundary and sub-task constraints, dynamic bounds, collision avoidance, and kinematic reachability (Gao et al., 2024).

For each arm, the trajectory must pass through IK-feasible sub-task sets at designated times. The paper states that there exist time-stamps

$\mathcal A_g$5

such that, for sub-task $\mathcal A_g$6,

$\mathcal A_g$7

where $\mathcal A_g$8 encodes the IK solution set for the $\mathcal A_g$9th pick, place, or handoff pose.

Dynamic feasibility is imposed through componentwise infinity-norm bounds:

$n$0

These limits are important because MODAP is not only a geometric planner; it is intended to generate trajectories that can be executed while conforming to specified acceleration and jerk limits.

Collision avoidance is enforced for self-collision, inter-arm collision, and static scene obstacles. The paper expresses this as

$n$1

Kinematic validity is additionally constrained through workspace reachability and joint-limit compliance, with the two arm workspaces $n$2 and $n$3 characterized by an overlap ratio

$n$4

The implementation strategy is not a monolithic global solver. By discretizing time and encoding sub-task times $n$5 a priori from the discrete plan, MODAP solves the problem through a sequence of cuRobo calls followed by local time reparameterization via Toppra. This suggests a hybrid decomposition in which continuous-time optimal control is approximated by repeated geometric planning plus post hoc timing optimization, rather than by solving a single end-to-end nonlinear program.

4. Sampling strategy, graph construction, and coordination logic

Two sampling techniques are identified as novel components of the task-planning and motion-planning interface: Seeded IK Sampling and Overhead-Pose Augmentation (Gao et al., 2024).

Seeded IK Sampling prescribes IK seeds that steer solutions toward “elbow-up” postures, current-configuration continuity for MTs, and high retract postures for TTs. The reported effect is to cut per-subtask IK multiplicity from dozens to just a handful of feasible, well-conditioned configurations. The paper attributes two consequences to this design: reduction of the discrete branching factor during dual-arm coordination, and reduction of the search breadth later in continuous planning.

Overhead-Pose Augmentation enriches the geometric planning graph with uniformly distributed over-workspace poses. MODAP precomputes 32 overhead manipulator poses, solves IK for each, and forms their cross-product, yielding up to $n$6 candidate dual-arm waypoints. Only collision-free pairs are added as graph vertices. According to the paper, this increases roadmap coverage in high-clutter regions, enables more direct paths, and avoids home-retract detours that arise in naive parallel graph search.

The trajectory-generation procedure in cuRobo follows three stages. First, a graph is built whose nodes include the current configuration, target IK solutions, a home/retract posture, and the enriched overhead-pose set. Edges connect nodes that are within small Euclidean distance in joint space and are collision-checked on the GPU. Second, a concurrent GPU-accelerated A* or Dijkstra search returns a shortest collision-free seed path. Third, the seed path is refined through nonlinear optimization minimizing

$n$7

subject to velocity, acceleration, and jerk bounds, producing a dynamically feasible segment $n$8 (Gao et al., 2024).

Time-optimal path parameterization is then applied through Toppra, which solves

$n$9

with $\mathcal W$0 the path parameter along the piecewise-linear approximation to $\mathcal W$1. The stated output is a smooth function $\mathcal W$2 that exactly saturates actuator limits to minimize wall-clock time.

Dual-arm coordination is governed by a collision-aware interleaving mechanism. At each iteration, both arms first plan their next sub-task independently, producing $\mathcal W$3 and $\mathcal W$4. If $\mathcal W$5, the segments are merged and run in parallel until one arm finishes. If both arms are on Traveling Tasks and their paths collide, MODAP invokes SampleDualGoal to find a collision-free dual-arm goal $\mathcal W$6 such that one arm reaches its next sub-task configuration while the other is as far along its path as possible without collision. A joint cuRobo plan is then generated from $\mathcal W$7 to $\mathcal W$8. If only one arm has a prescribed path, MODAP invokes PlanPartialPath, sending the yielding arm along a precomputed collision-free path back toward home while the other follows its sub-task. The paper emphasizes that this mechanism never blocks both arms indefinitely: every collision either yields a shorter joint plan or forces one arm back to home, ensuring forward progress and tightly bounded idle times (Gao et al., 2024).

5. Experimental regime and empirical results

The evaluation uses both simulation and real hardware. The hardware platform consists of two Universal Robots UR-5e arms with 6 DOF + parallel 2-finger gripper, mounted on opposing sides of a $\mathcal W$9 tabletop. Overlap ratios $\mathcal T=(q^1(t),q^2(t))$0 are tested, with object counts $\mathcal T=(q^1(t),q^2(t))$1. Simulations run on an Intel i7-9700K + NVIDIA RTX 2080Ti. Real experiments use UR_RTDE control at 500 Hz, with objects tracked through ArUco markers and a calibrated side-mounted camera (Gao et al., 2024).

Three evaluation metrics are reported: Execution Time, defined as the makespan of the final time-parameterized dual-arm trajectory; Trajectory Length, defined as the sum of $\mathcal T=(q^1(t),q^2(t))$2 in joint-space $\mathcal T=(q^1(t),q^2(t))$3 norm; and Sim-to-Real Tracking Error,

$\mathcal T=(q^1(t),q^2(t))$4

recorded as RMSD per-joint and at the end-effector.

The baselines are BL, defined as MCHS task planning plus single-arm cuRobo plus naive yield-to-home conflict resolution plus smoothing, and BL-TP, defined as BL followed by Toppra on the entire plan.

The principal reported results are summarized below.

Setting	Result
Sim-to-real fidelity	Per-joint RMSD $\mathcal T=(q^1(t),q^2(t))$5 and end-effector RMSD $\mathcal T=(q^1(t),q^2(t))$6 mm, even at peak speeds $\mathcal T=(q^1(t),q^2(t))$7 rad/s
Representative instance	For $\mathcal T=(q^1(t),q^2(t))$8, MODAP completes in $\mathcal T=(q^1(t),q^2(t))$9 s vs. $T$0 s for BL and $T$1 s for BL-TP
Aggregate makespan gains	Over $T$2 random instances per setting, MODAP reduces average makespan by $T$3–$T$4 vs. BL at $T$5, and $T$6–$T$7 vs. BL at $T$8
BL-TP comparison	Average makespan reduction is $T$9–$r_1$0 at $r_1$1 and $r_1$2–$r_1$3 at $r_1$4
Trajectory-length trade-off	MODAP trajectories are slightly longer by $r_1$5–$r_1$6
Planning-time overhead	Richer sampling produces $r_1$7–$r_1$8 longer planning time, still all $r_1$9 s per instance

These findings clarify a point that might otherwise be misunderstood: MODAP does not minimize joint-space travel distance. The reported trajectory lengths are slightly longer than those of the baselines. The performance gain instead comes from better coordination and more favorable time scaling, allowing shorter makespan despite somewhat greater cumulative joint motion (Gao et al., 2024).

The reported sim-to-real gap is described as negligible, with approximately $r_2$0 per-joint RMSD and approximately $r_2$1 mm end-effector RMSD even at peak speeds of $r_2$2 rad/s. This supports the claim that the time-parameterized trajectories remain executable on real hardware under the tested sensing and control assumptions.

6. Assumptions, limitations, and extensions

MODAP is developed under several explicit assumptions. The arms are fixed-base and known calibration is available. Object geometry is static, pick and hand-off are treated with frictionless idealizations, and perception is effectively perfect through ArUco marker tracking. These assumptions delimit the operational regime of the reported results (Gao et al., 2024).

The stated limitations are equally explicit. MODAP provides no formal optimality guarantee, because the pipeline relies on heuristic MCHS planning together with sampling and graph search. Planning time grows with the number of objects $r_2$3 and with workspace overlap $r_2$4. The method also does not address uncertainty or online replanning under perceptual noise.

These limitations are significant in interpreting the term “makespan-optimized.” In the reported system, this denotes a practical objective implemented through coordinated heuristics, not a proof of globally optimal dual-arm TAMP. A plausible implication is that the method occupies an intermediate point between purely symbolic TAMP and full continuous optimal control: it is more tightly integrated than a pipeline baseline, but still fundamentally heuristic.

The paper identifies several extensions: learning-guided heuristics to prune IK samples or predict inter-arm conflicts; extension to mobile-base plus arm coordination or to systems with more than two arms; integration of non-prehensile primitives such as push and tilt; incorporation of uncertainty through chance-constrained or robust TAMP; and real-time replanning for execution perturbations (Gao et al., 2024). Collectively, these directions indicate that MODAP is best understood as a dual-arm rearrangement framework whose main contribution is the combination of intelligent discrete sampling, GPU-accelerated joint planning, specialized conflict resolution, and time-optimal path parameterization in a single makespan-oriented architecture.