Paper deep dive
LASER: Level-Based Asynchronous Scheduling and Execution Regime for Spatiotemporally Constrained Multi-Robot Timber Manufacturing
Zhenxiang Huang, Lior Skoury, Tim Stark, Aaron Wagner, Hans Jakob Wagner, Thomas Wortmann, Achim Menges
Intelligence
Status: succeeded | Model: anthropic/claude-sonnet-4.6 | Prompt: intel-v1 | Confidence: 94%
Last extracted: 3/24/2026, 1:24:30 AM
Summary
This paper presents LASER (Level-based Asynchronous Scheduling and Execution Regime), a framework for multi-robot scheduling and execution in timber slab manufacturing. The core contribution integrates a barrier-based mechanism into a Constraint Programming (CP) scheduling formulation that partitions tasks into spatiotemporally disjoint 'levels', enabling parallel asynchronous robot execution with synchronization only at level barriers. Two specialized algorithms are proposed: an iterative temporal-relaxation approach for heterogeneous bottom-session tasks, and a bi-level decomposition (set partitioning + VRP) for homogeneous top-session screw-pressing. The framework is validated by fabricating a full-scale 2.4m x 6m timber slab with two KUKA robots, coordinating 108 subroutines and 352 screws under tight adhesive time windows.
Entities (31)
Relation Signals (24)
Zhenxiang Huang → affiliatedwith → Institute for Computational Design and Construction (ICD)
confidence 99% · Authors are with the Institute for Computational Design and Construction (ICD) and Cluster of Excellence IntCDC at University of Stuttgart, Germany
LASER → appliedto → Timber Slab Manufacturing
confidence 99% · demonstrated on a screw-press gluing application for timber slab manufacturing
LASER → incorporates → Level-based Barrier Mechanism
confidence 99% · Our central contribution is to integrate a barrier-based mechanism into a constraint programming (CP) scheduling formulation that partitions tasks into spatiotemporally disjoint sets, which we define as levels
CP-SAT Solver → partof → Google OR-Tools
confidence 99% · The CP-SAT solver [13], part of Google OR-Tools
LASER → uses → Constraint Programming (CP)
confidence 99% · integrate a barrier-based mechanism into a constraint programming (CP) scheduling formulation
LASER → appliedto → Screw-Press Gluing
confidence 98% · demonstrated on a screw-press gluing application for timber slab manufacturing
LASER → fundedby → Deutsche Forschungsgemeinschaft (DFG)
confidence 98% · This research has been supported by the Deutsche Forschungsgemeinschaft (DFG) under Germany's Excellence Strategy EXC 2120/1 – 390831618
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Automating large-scale manufacturing in domains like timber construction requires multi-robot systems to manage tightly coupled spatiotemporal constraints, such as collision avoidance and process-driven deadlines. This paper introduces LASER (Level-based Asynchronous Scheduling and Execution Regime), a complete framework for scheduling and executing complex assembly tasks, demonstrated on a screw-press gluing application for timber slab manufacturing. Our central contribution is to integrate a barrier-based mechanism into a constraint programming (CP) scheduling formulation that partitions tasks into spatiotemporally disjoint sets, which we define as levels. This structure enables robots to execute tasks in parallel and asynchronously within a level, synchronizing only at level barriers, which guarantees collision-free operation by construction and provides robustness to timing uncertainties. To solve this formulation for large problems, we propose two specialized algorithms: an iterative temporal-relaxation approach for heterogeneous task sequences and a bi-level decomposition for homogeneous tasks that balances workload. We validate the LASER framework by fabricating a full-scale 2.4m x 6m timber slab with a two-robot system mounted on parallel linear tracks, successfully coordinating 108 subroutines and 352 screws under tight adhesive time windows. Computational studies show our method scales steadily with size compared to a monolithic approach.
Tags
Links
- Source: https://arxiv.org/abs/2603.20577v1
- Canonical: https://arxiv.org/abs/2603.20577v1
Trouble viewing inline? Open PDF directly →
Full Text
41,646 characters extracted from source content.
Expand or collapse full text
LASER: Level-based Asynchronous Scheduling and Execution Regime for Spatiotemporally Constrained Multi-Robot Timber Manufacturing Zhenxiang Huang∗, Lior Skoury, Tim Stark, Aaron Wagner, Hans Jakob Wagner, Thomas Wortmann, and Achim Menges This research has been supported by the Deutsche Forschungsgemeinschaft (DFG) under Germany’s Excellence Strategy EXC 2120/1 – 390831618.Authors are with the Institute for Computational Design and Construction (ICD) and Cluster of Excellence IntCDC at University of Stuttgart, Germany. ∗zhenxiang.huang@icd.uni-stuttgart.de Abstract Automating large-scale manufacturing in domains like timber construction requires multi-robot systems to manage tightly coupled spatiotemporal constraints, such as collision avoidance and process-driven deadlines. This paper introduces LASER (Level-based Asynchronous Scheduling and Execution Regime), a complete framework for scheduling and executing complex assembly tasks, demonstrated on a screw-press gluing application for timber slab manufacturing. Our central contribution is to integrate a barrier-based mechanism into a constraint programming (CP) scheduling formulation that partitions tasks into spatiotemporally disjoint sets, which we define as “levels.” This structure enables robots to execute tasks in parallel and asynchronously within a level, synchronizing only at level barriers, which guarantees collision-free operation by construction and provides robustness to timing uncertainties. To solve this formulation for large problems, we propose two specialized algorithms: an iterative temporal-relaxation approach for heterogeneous task sequences and a bi-level decomposition for homogeneous tasks that balances workload. We validate the LASER framework by fabricating a full-scale 2.4 m × 6 m timber slab (Fig. 1) with a two-robot system mounted on parallel linear tracks, successfully coordinating 108 subroutines and 352 screws under tight adhesive time windows. Computational studies show our method scales steadily with size compared to a monolithic approach. I Introduction The increasing demand for automation in manufacturing and construction has positioned multi-robot systems (MRS) as a powerful solution for efficiency, scalability, and safety. In large assemblies, many steps can run in parallel if spatial interference and process windows are respected. Realizing this potential, however, requires addressing tightly coupled challenges in multi-robot task allocation and scheduling, motion planning in shared workspaces, and execution under uncertainty. These challenges are magnified in industrial settings, where complex spatiotemporal constraints, bespoke parts at scale, and strict quality criteria demand schedules that are both collision-aware and deadline-aware by construction. Figure 1: Timber slab prototype manufacturing using a two-robot system with our proposed framework. Timber fabrication serves as a low-carbon alternative to steel and concrete, and its sustainability potential can be amplified through scalable, automated robotic manufacturing. We focus on screw–press gluing, a connection technique that applies localized bonding pressure via screw tapping, eliminating the need for massive and costly press machines. As a traditional crafting method, this process is labor-intensive due to its dense screwing pattern (one screw per 220cm2220\,cm^2 in our system); naively automating with a single robot is often infeasible at scale because the number of screws can violate adhesive time windows. In a hollow timber slab system, two cross-laminated timber (CLT) plates sandwich discrete timber beams for material-efficient load transfer. To manufacture such a slab segment, efficient multi-robot collaboration must respect: (i) spatial collision-avoidance of robots and payloads, and (i) adhesive open and close windows that couple glue application, placement, and all subsequent screws. They are the primary drivers of schedule and execution design. This paper presents LASER (Level-based Asynchronous Scheduling and Execution Regime), a complete framework (Fig. 2) to systematically address task scheduling and execution for spatiotemporally constrained multi-robot manufacturing, demonstrated here on the screw-press gluing process for timber slab assemblies. The main innovation of our scheduling formulation is to integrate levels as time–space partitions of tasks whose robot workspace occupancies do not conflict. Robots execute asynchronously within a level and synchronize only at level barriers. This lightweight mechanism yields collision-free operation by schedule design, robust to execution delays and timing uncertainty. Figure 2: The overall workflow of our work. We process preliminary data as inputs to our scheduling formulation, which is solved by two specific algorithms for heterogeneous and homogeneous problems. We convert the scheduled results into level-associated task objects in a semi-centralized control framework and validate our approach in a physical slab assembly. We make the following specific contributions: 1) Constraint Programming (CP) scheduling formulation with level barriers that embeds spatial safety and adhesive time windows as constraints while minimizing makespan and level compactness. 2) Two efficient scheduling algorithms: an iterative temporal-relaxation algorithm with heuristic task clustering for the heterogeneous bottom assembly session; and a bi-level decomposition that translates the problem into set partitioning and vehicle routing problems (VRP) for the homogeneous top screw-pressing session. 3) Barrier-based, semi-centralized execution that queues level-scoped subroutines to each robot, enabling parallel execution and sparse synchronization. 4) Physical validation and scalability study via a full-scale 2.4 m2.4\,m × 6 m6\,m prototype featuring 34 internal beams, 15 levels, 108 subroutines, and 352 screws with a 2-robot setup, alongside a computational study over 8 design variants demonstrating scalability. I Related Work Our framework sits at the intersection of three major research threads within multi-robot systems—industrial manufacturing, scheduling with spatiotemporal constraints, and asynchronous execution. I-A Multi-Robot Systems for Industrial Manufacturing Early work established multi-robot assembly as a distinct industrial challenge with coordinated fixtures, tool sequencing, and collision-aware co-manipulation. The survey by Marvel et al. synthesizes strategies and metrics for industrial multi-robot assembly, covering fixtureless methods, synchronization schemes, and evaluation protocols [8]. In automotive spot-welding, Pellegrinelli et al. developed integrated approaches that jointly consider cell design and off-line motion planning [11, 12]. Beyond automotive, manufacturing tasks such as aircraft assembly [19] and brick layering [16] introduce heterogeneous collaboration with tool change and precedence requirements. Large multi-station industrial lines motivate hierarchical allocation and scheduling; Zhou et al. present a stepwise MS-MRTA method validated on a production case [20]. For broader assembly planning at the structure level, discrete optimization (ILP/IQP) has been used to co-design assembly sequences and resource usage for multi-robot teams [2]. I-B Multi-Robot Task Scheduling with Spatiotemporal Constraints Gerkey and Matarić differentiate allocation types by robot/task multiplicity and time extension [4]; Korsah et al. add interrelated utilities and constraints [7]; and Nunes et al. target precedence and time windows explicitly [10]. Exact/heuristic schedulers that couple space and time have been proposed, TERCIO [5] handles tight spatial interference and deadlines at scale. Under execution uncertainty, hierarchical methods decouple per-robot policies from conflict resolution while preserving time-window feasibility [1]. These works are grounded in temporal reasoning: Simple Temporal Networks (STNs) and their controllability/dispatchability properties [3, 9]. In practical settings, constraint programming (CP) offers compact encodings of precedence, resource sharing, and spatial safety using interval variables and global constraints. The CP-SAT solver [13], part of Google OR-Tools, supports scalable formulations for precedence, resource sharing, and spatial safety. I-C Asynchronous Multi-Robot Execution Frameworks Bridging plans to execution, recent frameworks advocate partial-order, asynchronous dispatch to address execution uncertainty without dense time-stamped synchronization. APEX-MR post-processes task/motion plans to build a temporal plan graph that enables robust asynchronous execution for cooperative assembly and demonstrates substantial speedups on long-horizon tasks [6]. The Bidirectional Temporal Plan Graph (BTPG) further introduces switchable dependencies to reduce wait time while maintaining safety guarantees during execution [18]. At the middleware level, asynchronous multi-arm/multi-robot execution with continuous collision checking has been implemented in MoveIt 2, providing a practical substrate for independent yet safe trajectory execution under a central scheduler [17]. While prior works like [6] enable asynchronous execution, our level-based barrier provides a novel, integrated mechanism that simplifies the execution framework by encoding collision avoidance directly into the schedule structure, thereby obviating the need for continuous collision checking or complex temporal plan graphs during execution. I Preliminaries The cooperative slab assembly for our multi-robot system provides a set of preliminaries for the scheduling model. They form the basis for the problem formulation in Sec. IV. They include the design of slab assembly plan, a library of manipulation skills and subprograms mapped to robots, and the environment setup with robot cell layout as a result of a co-design process to ensure the feasibility of fabrication. I-A Assembly Plan and Task Hierarchy The timber slab assembly plan provides a list of elements E=e1,e2,…,eNE=\e_1,e_2,…,e_N\ for the bottom session tasks. Each element is associated with a set of task primitives, including gluing, picking, placing, and screw-pressing. • Element Types: For the bottom session, elements can be either linear beams (manipulated by a screw effector with an integrated gripper) or planar crowns (handled by a vacuum gripper). Each element is associated with a list of glue lines and screws to be fastened. • Task Primitives: The tasks for the bottom session are heterogeneous, involving a mix of picking, placing, gluing, and screw-pressing. For the top session, tasks are homogeneous, consisting solely of high-density screw-pressing to secure the top CLT plate. The assembly plan specifies an unordered set of elements, subject to a small number of precedence constraints. For instance, a crown must be placed before its adjacent beams to facilitate proper slot-in placement. Additionally, for the top session, screws are divided into a priority set and a reinforcement set, where all screws in the priority set must be fastened before those in the reinforcement set. I-B Environment Setup and Cell Layout Our fabrication platform consists of two industrial robots, a KUKA KR 420 R3330 (Robot 1) and a KUKA KR 210 R3100 (Robot 2), each mounted on a 10.7-meter linear axis. The robots are positioned on opposite sides of a central movable worktable to facilitate cooperative tasks. This setup specifies the kinematics and geometries of all robots and static obstacles, as well as the placement of the workpiece in the shared workspace. The cell co-design ensures every task pose is kinematically reachable by at least one robot, a critical assumption for our formulation. I-C Manipulation Skills and Subprograms Each task primitive maps to a manipulation skill corresponding to a pre-defined, feedback-driven subprogram on the KUKA KRL controller. Our platforms feature a distinct division of labor based on payload capacity: Robot 1 (KUKA KR 420) is equipped with a gluing effector, a heavy-payload vacuum gripper, and a screw effector with an integrated gripper, enabling it to perform all tasks including gluing, placing large crowns, and screw-pressing. In the meantime, Robot 2 (KUKA KR 210) is equipped solely with a screw effector with an integrated gripper; it is limited to placing linear beams and screw-pressing but utilizes a more powerful motor to reduce cycle time and maximize utilization. We collect average execution times for these skills and encode them into the scheduling model to minimize the estimated makespan. IV Problem Formulation In this section, we formulate the scheduling of multi-robot screw-press gluing as a Constraint Programming (CP) problem. Building upon the discussion in Sec. I, we derive the following key inputs for our CP model, as summarized in Fig. 3: Figure 3: Scheduling input summary. • Simple Temporal Problem (STP): We model the temporal relationships between all tasks as a set of STPs, which define temporal constraints (lower and upper bounds) for task primitives. For each element e, the STP enforces that gluing must occur after placement but within the adhesive’s open time, and that screwing must occur after placement but within the close time window. For elements i and j with a precedence requirement, a constraint is added to ensure that the placement of i precedes the placement of j. • Actor-Task Capabilities: Each task is associated with a specific set of capabilities. This includes the estimated duration for each capable actor to complete the task, robot kinematic states at each task, and a binary representation of its spatial occupancy, crucial for collision avoidance. • Task Coordinate (x,y): Each task primitive has one or two (only with gluing task) 2D coordinates in the shared workspace. This information is used to evaluate spatial proximity during the homogeneous screw scheduling, as discussed in Section I. • Transition and Tool Switch Information: The model accounts for logistical overhead, including the time required for tool-switching and preparatory actions like screw loading and material picking. To simplify the spatial problem, these transition tasks are designed to occupy non-colliding areas. The total transition time (τkij _k^ij) between two consecutive tasks is pre-calculated based on the chosen actor and the sequence of actions. For instance, the transition from a vacuum gripper placement task to a gluing task may include the time for storing the gripper, picking up the glue effector, and pressurizing the adhesive. The problem is defined by the following inputs, variables, and constraints. Let T denote the set of task primitives and K the set of actors. We define a comprehensive set of temporal constraints T that encapsulates both process precedence and adhesive time windows. Central to our formulation is the concept of a level, formally defined as a set of tasks spatiotemporally disjoint from other levels and synchronized by a global barrier. The decision variables include: the boolean assignments AkiA_k^i for task i to actor k; the boolean sequence variables JkijJ_k^ij (1 if task j immediately follows i on actor k); and the integer level index ℓi∈ℤ≥0 ^i _≥ 0 for task i. The start/end times tSi,tEit_S^i,t_E^i are modeled as auxiliary variables whose values are propagated based on the main integer decisions. Parameters include the duration dkid_k^i and transition times ρkij _k^ij. The model minimizes the makespan CmaxC_ and the maximum level index LmaxL_ , weighted by a user-defined factor λ, as follows: minCmax+λLmax,s.t. \;C_ +λ\,L_ ,s.t. (1) ∑k∈KAki=1∀i∈T _k∈ KA_k^i=1 ∀ i∈ T (2) Aki=1⇒tEi≥tSi+dki∀i∈T,∀k∈K A_k^i=1\; \;t_E^i≥ t_S^i+d_k^i ∀ i∈ T,\ ∀ k∈ K (3) Jkij=1⇒tSj≥tEi+ρkij∀i,j∈T,∀k∈K J_k^ij=1\; \;t_S^j≥ t_E^i+ _k^ij ∀ i,j∈ T,\ ∀ k∈ K (4) Jkij=1⇒ℓj≥ℓi∀i,j∈T,∀k∈K J_k^ij=1\; \; ^j≥ ^i ∀ i,j∈ T,\ ∀ k∈ K (5) Luv≤tηv−tηu≤Uuv∀(u,v)∈ L^uv≤ t_ _v^v-t_ _u^u≤ U^uv ∀(u,v) (6) (Aai∧Abj∧Rabij=1)⇒ℓi≠ℓj∀i,j∈T,∀a,b∈K (A_a^i A_b^j R^ij_ab=1 )\; \; ^i≠ ^j ∀ i,j∈ T,\ ∀ a,b∈ K (7) (Jkij=1∧Redge(ij)=1)⇒ℓi≠ℓj∀i,j∈T,∀k∈K (J_k^ij=1 R^(ij)_edge=1 )\; \; ^i≠ ^j ∀ i,j∈ T,\ ∀ k∈ K (8) tEi≤Bℓi,Bk≤Bk+1 t_E^i≤ B_ ^i, B_k≤ B_k+1 (9) ℓi<ℓj⇒Bℓi≤tSj ^i< ^j\; \;B_ ^i≤ t_S^j (10) Cmax≥tEi,Lmax≥ℓi,∀i∈T. C_ ≥ t_E^i, L_ ≥ ^i, ∀ i∈ T. (11) Constraint (2) and (3) encode assignment and processing duration. (4)–(5) enforce routing gaps and level monotonicity along the sequence J. (6) governs all temporal constraints from T, including precedence (where L=0,U=∞L=0,U=∞) and adhesive windows via bounded differences. Binary node (RabijR^ij_ab) and edge (Redge(ij)R^(ij)_edge) conflicts are precomputed via voxelized occupancy with safety margins, they parametrize (7)–(8) to lift spatial conflicts into level separation.(9)–(10) model timestamp synchronization via barrier variables BℓB_ . Since these barrier constraints directly bound task start times, Eq. (6) validates temporal window constraints inclusive of synchronization idles. To robustly accommodate execution uncertainty, we apply a safety buffer to the temporal bounds in Eq. (6) by lowering the upper bound U, ensuring the schedule remains valid even under stochastic delays. (11) defines the objectives. V Scheduling Algorithms for Screw-Press Gluing Timber Slab Assembly The formulation presented in the previous section specifies the feasibility and optimality criteria for our problem. However, a monolithic CP model faces significant scalability challenges, particularly for a complete slab assembly that may involve over 800 task primitives. Our key insight is that the timber slab assembly process consists of two fundamentally different scheduling problems. The bottom session is a sparse, heterogeneous, constraint-driven problem. The number of decision nodes is moderate (under 80 in all test cases), but they are linked by complex temporal and logical constraints (e.g., glue windows, tool changes). Conversely, the top session is a dense, homogeneous, routing-driven problem, with hundreds of identical screw tasks where path efficiency and workload balance are dominant. The computational study on Fig. 9(a) confirms that a direct CP model of this problem becomes intractable beyond 80-100 tasks. We therefore dictate a hybrid strategy (Fig. 4): for the constraint-rich bottom session that falls within this tractable range, we employ a direct CP method with primitive clustering and iterative temporal relaxation. For the dense top session, a decomposition approach is necessary and operable under a fixed number of levels. Figure 4: Diagram illustration of our algorithms. Bottom Plate: Heterogeneous scheduling with clustering and iterative temporal relaxation. Top Plate: Homogeneous scheduling with decomposed Set Partitioning and Vehicle Routing Problem (VRP) solvers. V-A Bottom session: Primitive Clustering and Iterative Temporal Relaxation The assembly of the bottom session involves a large number of discrete timber elements that must be glued, placed, and pressed onto a large CLT plate. The ideal sequence of operations to minimize tool changes would involve performing all gluing tasks first, followed by all placement tasks for large elements (using a vacuum gripper), and finally all screwing tasks for smaller linear elements (using a screw effector). Even the tight open-time window of the adhesive (e.g., 15 minutes at 20∘20 C) makes a single round of such a sequence impossible, we can leverage the inherent efficiency of clustering tasks while systematically addressing the strict temporal windows as shown in Algorithm 1: Algorithm 1 Iterative Clustering and Scheduling for Bottom Session 1: Input: Task Primitives TallT_all, Actor Set K, Temporal Constraints T, Collision R 2: Output: Schedule SfinalS_final 3: (Tactive,Tdeferred)←InitializeBatches(Tall)(T_active,T_deferred) (T_all) 4: relaxed←ApplyRelaxation()T_relaxed (T) 5: V←dummyV←\dummy\ 6: while V≠∅V≠ do 7: Sskeleton←SolveCP(Tactive,relaxed,K,R)S_skeleton (T_active,T_relaxed,K,R) 8: V←FindViolations(Sskeleton,)V (S_skeleton,T) 9: if V≠∅V≠ then 10: Tactive←SplitBatches(Tactive,V)T_active (T_active,V) 11: end if 12: end while 13: Sfinal←InsertDeferredTasks(Sskeleton,Tdeferred,R)S_final (S_skeleton,T_deferred,R) 14: Return SfinalS_final We first coalesce consecutive glue primitives into clustered batched nodes, reducing the number of decision variables and minimizing travel overhead. During this aggregation, we relax the temporal bounds associated with the batched glue tasks to permit a feasible initial route. Three critical screw primitives (the center and end screws) are merged into each placement task to ensure immediate pressing and prevent slippage from the glue line. All remaining screws are temporarily deferred. The relaxed instance is solved; any elements whose glue–place chains violate the strict temporal windows are identified, and their glue primitives are detached to form smaller batches. This process repeats on the unresolved subproblem until every element satisfies its exact (unrelaxed) bounds. Finally, we reinsert the deferred screws under the full set of assignment, routing, and level constraints. These deferred tasks are placed into idle slots between levels with fixed actor assignments, maintaining spatial safety. V-B Top session: Set Partitioning and Vehicle Routing Problem The top session assembly involves applying glue to the sandwiched timber elements before a top CLT plate is placed via a crane, followed by a dense screw pattern to ensure a secure bond. The multi-robot collaboration must be highly efficient to complete all tasks before the adhesive’s strict close time window (approximately 120 minutes under standard conditions). To address this challenge, we leverage the homogeneous nature of the screwing tasks and reframe the problem as an assignment problem aimed at workload balance. Instead of minimizing makespan as the primary objective in (1), we adopt a load-balancing objective inspired by the Multiway Number Partitioning Problem. This approach seeks to minimize the workload difference between the actors within each level while minimizing the total number of levels to maximize parallelism. For a system with N actors, the general objective is defined as: g=maxi∈K∑j∈Tiwj−mini∈K∑j∈Tiwj g= _i∈ K _j∈ T_iw_j- _i∈ K _j∈ T_iw_j (12) where K is the set of actors, TiT_i is the set of tasks assigned to actor i, and wjw_j is the processing time of task j. This equilibrium is achievable for screwing tasks because each primitive’s duration is nearly invariant for a given actor, regardless of its sequence, as screw loading occurs in parallel with travel. For our setup in the top session, the KUKA KR210’s screwing cycle is 11s (6s screwing and 5s loading), and the KUKA KR420’s is 16s (11s screwing and 5s loading), indicating a distribution of 16:11 leads to temporal optimality. We allow a small time difference threshold, δ: g≤δ g≤δ (13) as a constraint for more search space for the solver. We solve this problem using a two-stage approach, as detailed in Algorithm 2: 1. Task Assignment (Multiway Number Partitioning Problem): We begin by attempting to assign all tasks with a minimal number of levels, Lmax=kminL_ =k_min, where kmin≥2k_min≥ 2 to enable multi-robot cooperation. A CP model is built that satisfies the processing, sequencing, level-monotonicity, barrier, and STP constraints described in Sec. IV. To enlarge the search space, we temporarily relax the edge-conflict constraints while retaining the static occupancy constraints. We also introduce a heuristic to prevent isolated assignments: each task assigned to a level must have at least one other task on that level within a distance threshold δdist _dist. This is enforced via additional binary variables linking proximity to assignment; we omit the detailed encoding for brevity. We relax constraint (2) to allow for partial assignment and maximize the number of assigned tasks. Starting with the priority screw set, we solve for kmin=2k_min=2. Any unassigned tasks are added to the reinforcement set and solved together with kmin=2k_min=2. We find in Sec. VII that this fixed 2-level solve yields at least 95% task assignment within a modest time budget. 2. Routing Refinement (Vehicle Routing Problem): With tasks assigned to specific actors and levels, we solve a multi-vehicle routing problem on each level to ensure collision-free travel. A local search algorithm is implemented on each level, where the start points of each actor’s path are fixed by the previous level’s solution. This makes each sub-problem a series of fast and scalable vehicle routing problem with fixed candidates. The objective is to minimize the total travel distance, while satisfying the edge-based spatial conflict constraint (8) that was relaxed during the assignment phase. The unassigned screws from the first stage are integrated post-routing by relaxing the workload equilibrium constraint (13) and dynamically inserted into existing scheduled levels or added to a minimal number of new levels (e.g., 1–2) to minimize the final makespan. Algorithm 2 Bi-Level Scheduling for Top Session Screwing 1: Input: Task sets [Tprio,Treinf][T_prio,T_reinf], Actors K, Collision data R, Load-balance threshold δ 2: Output: Completed Schedule SfinalS_final (Task Assignments, Orders, Levels) 3: Initialize Sassignments←∅S_assignments← , Tunassigned←∅T_unassigned← , Lmax←2L_ ← 2 4: for each TsetT_set in [Tprio,Treinf][T_prio,T_reinf] do 5: Tcurrent_solve←Tset∪TunassignedT_current\_solve← T_set∪ T_unassigned 6: Spartial←SetPartition(Tcurrent_solve,Lmax,δ)S_partial (T_current\_solve,L_ ,δ) 7: Tnewly_assigned←GetAssignedTasks(Spartial)T_newly\_assigned (S_partial) 8: Tunassigned←Tcurrent_solve∖Tnewly_assignedT_unassigned← T_current\_solve T_newly\_assigned 9: Sassignments←Sassignments∪SpartialS_assignments← S_assignments∪ S_partial 10: end for 11: Sinitial_routes←Initialize empty scheduleS_initial\_routes empty schedule 12: p0←-1p_0←-1 Start index at level 0 is not forced 13: for each level l from 0 to Lmax−1L_ -1 do 14: Tl←Tasks in Sassignments at level lT_l in S_assignments at level l 15: Tl+1←Tasks in Sassignments at level l+1T_l+1 in S_assignments at level l+1 16: Sl,pl+1←SolveVRP(Tl,Tl+1,pl)S_l,p_l+1 (T_l,T_l+1,p_l) 17: Add SlS_l to Sinitial_routesS_initial\_routes 18: end for 19: Sfinal←InsertUnassigned(Sinitial_routes,Tunassigned)S_final (S_initial\_routes,T_unassigned) 20: Return SfinalS_final VI Level-Based Task Execution We employ a semi-centralized control framework, Twico [14], to orchestrate the system. While general-purpose middlewares like MoveIt 2 [17] offer asynchronous capabilities, Twico is specifically tailored to dispatch scheduled primitives as parameterized KUKA subprogram calls with level-based barrier protocol for spatial safety, ensuring seamless alignment with our task scheduling model. Before execution, the scheduled primitives are post-processed into executable task objects. To optimize efficiency, consecutive tasks of the same type (e.g., multiple screwing points or continuous glue lines) are batched into single subprogram calls, and global task poses are transformed into each robot’s local coordinate frame. These objects, defined within a unified task schema [15] including task ID, level index, and subprogram parameters, are stored on the central server and dispatched to parallel execution threads. In the physical layer, each robot’s controller interprets the task parameters into KRL subroutines and executes the required motions and skills. The controller itself monitors primitive completion through internal signal-based commands and reports status back to the server. The server functions as a global barrier manager: it tracks the completion status of the current level and only releases tasks for level ℓ+1 +1 once all actors have confirmed the completion of level ℓ . This protocol acts as a robust control law that absorbs timing uncertainty and ensures collision-free operation without the need for dense timestamp synchronization. VII Framework Validation and Performance We validate our framework through three studies: first, by successfully fabricating a full-scale, complex architectural prototype; second, by highlighting the robustness embedded in our framework’s design; and third, by demonstrating the scalability and necessity of our tailored hybrid algorithm on a representative set of design variants. VII-A Physical Prototype Fabrication The 2.4 m×6 m slab (34 elements; 352 screws) executed collision-free under adhesive windows using 15 levels (11 bottom, 4 top) and 108 subroutines. Realized makespans were 28/20 min vs. model estimates 25/19 min (both within 5%). The physical execution, while successful, highlighted the importance of our level-based barrier mechanism. Minor variations in material handling time and screw-driving duration (up to 5% deviation from the model’s estimates) were naturally absorbed within each level’s asynchronous execution window, without requiring re-planning or risking collisions. This real-world validation confirms the framework’s inherent robustness against the uncertainties of physical fabrication. Figure 5: Overview of bottom session of our prototype. Top: Execution Gantt Chart from the first 990s up until level 8. Bottom left: Picture of the full assembly. Bottom right: Task assignment diagram to the robots. Fig. 5 summarizes the bottom assembly session involving heterogeneous task cooperation, such as gluing application, placement of large timber crowns and small timber beams, as well as screwing. Fig. 6 provides a detailed analysis on two scheduled levels from the bottom session. Fig. 7 demonstrates the scheduling and execution of the top screwing session, which contains 4 levels for 178 screws while maintaining workload balance within each level. Figure 6: Analysis of Level 2 (left) and Level 8 (right) of the bottom session. Specifically, Level 2 consists gluing, tool switching, and pick-and-place of a crown element for Robot 1, while Robot 2 is able to execute pick-and-place and screwing tasks for 3 smaller beams, leading to efficient task distribution. Figure 7: Scheduling result (top) and execution process with simulation overlay (bottom) of the top session. A total of 4 levels are scheduled with an estimated 98.8% robot utilization ratio. VII-B Robustness to Execution Variability We tested schedule robustness by injecting zero-mean i.i.d. noise into per-primitive durations and tool-switch times (Gaussian and bounded uniform), re-simulating the controller–dispatcher loop in a virtual environment provided by KUKA.OfficeLite. Across noise levels up to 5%, all runs respected level barriers and adhesive windows. Beyond simulated robustness, our framework incorporates two key mechanisms at the design level to handle real-world uncertainties: Proactive Safety Buffers The scheduler operates on conservative time windows. For instance, a hard 15-minute adhesive open-time is translated into a softer 13.5-minute scheduling constraint (a 10% safety buffer), ensuring minor delays do not compromise process integrity. Inherent Fault Tolerance The level-based barrier protocol provides a powerful fault-tolerance mechanism. A task failure or hardware malfunction on one robot simply pauses the system at a safe, collision-free state upon completion of the current level. This creates a natural checkpoint for human intervention without jeopardizing the other robot, a critical feature for long-horizon autonomous construction. Figure 8: Four of the eight representative slab geometries used for the computational study, illustrating the significant diversity in element count (15 to 74) and screw density (41 to 743). A detailed table of per-test metrics is available in the supplementary material. VII-C Scalability and Performance To analyze the framework’s performance across a range of complexities, we evaluated it on 8 distinct slab geometries sourced from a real-world building project (Fig. 8). These cases represent a significant diversity in scale, with 15 to 74 internal elements and 41 to 743 screws. Our central finding is that a monolithic CP formulation becomes sensitive to problem size, shown in Figure 9(a). The monolithic approach for the top session problem fails to find a solution within the 1800s time limit for instances with more than 300 tasks (Slabs E-H). This data-driven insight is the direct justification for our hybrid algorithm strategy for top and bottom sessions. For the Bottom Session After our primitive clustering, the number of decision nodes is identical to the element count (max 74 in Test H). This count falls within the tractable range for a direct CP solver. Therefore, our heterogeneous algorithm model assignment, sequence and levels as variables directly in the CP model with only relaxed temporal constraints, as it optimally minimizes the level count under the spatial disjunction of the sub-problem. Results from Figure 9(a) indicates that the problem is still solvable at its maximum size under the context of the studied cases. For the Top Session The number of tasks (screws) is an order of magnitude larger, far exceeding the CP solver’s tractable limit. This necessitates the decomposition into a set-partitioning problem for load-balancing and a VRP for routing. As shown in Figure 9(b), this tailored approach scales effectively, solving even the largest instances within 460 seconds. We also notice from Figure 9(c) that the initial partitioning model manages to assign at least 98% of the screws to the load-balanced levels, making the insertion problem in the final step of Algorithm 2 easier. Figure 9: Scaling, ablation and makespan overview: (a) solve time compare: bottom, top and top(monolithic); (b) top-session screws vs. solve time; (c) efficiency at set partition stage for top session solve. VIII Conclusion We have introduced LASER, a level-based scheduling and execution framework that enables time-critical process of multi-robot screw-press gluing for large-scale timber slab assembly. The resulting schedule allows for asynchronous execution within levels and single synchronization between them. By transforming stringent adhesive windows and spatial safety requirements into a robust, level-based execution structure, our work paves the way for automated robotic fabrication of complex, sustainable timber architecture. By embedding collision avoidance directly into the schedule, our system safely operates without the computational overhead of continuous collision checking. While such a mechanism efficiently coordinates sparse tasks, highly crowded workspaces may reduce the collaboration efficiency or cause levels to degenerate into serialized single-robot tasks and reduce parallelism. Future work could explore scalable temporal-based decomposition methods for heterogeneous collaboration with larger element counts and hybridize level-barriers with temporal networks to reduce idle times. References [1] S. Choudhury, J. K. Gupta, M. J. Kochenderfer, D. Sadigh, and J. Bohg (2020) Dynamic multi-robot task allocation under uncertainty and temporal constraints. In Robotics: Science and Systems (RSS), Cited by: §I-B. [2] P. Culbertson, S. Bandyopadhyay, and M. Schwager (2019) Multi-robot assembly sequencing via discrete optimization. Note: Technical Report, Stanford MSL Cited by: §I-A. [3] R. Dechter, I. Meiri, and J. Pearl (1991) Temporal constraint networks. Artificial Intelligence 49 (1–3), p. 61–95. External Links: Document Cited by: §I-B. [4] B. P. Gerkey and M. J. Matarić (2004) A formal analysis and taxonomy of task allocation in multi-robot systems. The International Journal of Robotics Research 23 (9), p. 939–954. External Links: Document Cited by: §I-B. [5] M. C. Gombolay, R. J. Wilcox, and J. A. Shah (2018) Fast scheduling of robot teams performing tasks with temporospatial constraints. IEEE Transactions on Robotics 34 (1), p. 220–239. External Links: Document Cited by: §I-B. [6] P. Huang, R. Liu, S. Aggarwal, C. Liu, and J. Li (2025) APEX-mr: multi-robot asynchronous planning and execution for cooperative assembly. In Robotics: Science and Systems (RSS), Cited by: §I-C. [7] G. A. Korsah, A. Stentz, and M. B. Dias (2013) A comprehensive taxonomy for multi-robot task allocation. The International Journal of Robotics Research 32 (12), p. 1495–1512. External Links: Document Cited by: §I-B. [8] J. A. Marvel, R. Bostelman, and J. Falco (2018) Multi-robot assembly strategies and metrics. ACM Computing Surveys 51 (1), p. 14:1–14:32. External Links: Document Cited by: §I-A. [9] P. Morris (2005) Temporal dynamic controllability revisited. In Proceedings of AAAI, p. 1193–1198. Cited by: §I-B. [10] E. Nunes, M. Manner, H. Mitiche, and M. Gini (2017-04) A taxonomy for task allocation problems with temporal and ordering constraints. Robot. Auton. Syst. 90 (C), p. 55–70. External Links: ISSN 0921-8890, Document Cited by: §I-B. [11] S. Pellegrinelli, N. Pedrocchi, L. Molinari Tosatti, A. Fischer, and T. Tolio (2014) Multi-robot spot-welding cells: an integrated approach to cell design and motion planning. CIRP Annals 63 (1), p. 17–20. External Links: ISSN 0007-8506, Document Cited by: §I-A. [12] S. Pellegrinelli, N. Pedrocchi, L. M. Tosatti, and T. Tolio (2017) Multi-robot spot-welding cells for car-body assembly: design and motion planning. Robotics and Computer-Integrated Manufacturing 44, p. 97–116. External Links: Document Cited by: §I-A. [13] CP-sat Google. External Links: Link Cited by: §I-B. [14] L. Skoury, S. Leder, A. Menges, and T. Wortmann (2024) Digital twin architecture for the aec industry : a case study in collective robotic construction. Proceedings of the ACM/IEEE 27th International Conference on Model Driven Engineering Languages and Systems. Cited by: §VI. [15] L. Skoury, S. Treml, N. Opgenorth, F. Amtsberg, H. J. Wagner, A. Menges, and T. Wortmann (2024) Towards data-informed co-design in digital fabrication. Automation in Construction 158, p. 105229. External Links: ISSN 0926-5805, Document Cited by: §VI. [16] M. Stamatopoulos, S. Velhal, A. Banerjee, and G. Nikolakopoulos (2025) Safety-aware optimal scheduling for autonomous masonry construction using collaborative heterogeneous aerial robots. In 2025 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), Vol. , p. 4889–4896. External Links: Document Cited by: §I-A. [17] P. Stoop, T. Ratnayake, and G. Toffetti (2024) A method for multi-robot asynchronous trajectory execution in moveit2. In 2024 IEEE International Conference on Robotics and Automation (ICRA), Vol. , p. 17694–17700. External Links: Document Cited by: §I-C, §VI. [18] Y. Su, R. Veerapaneni, and J. Li (2024) Bidirectional temporal plan graph: enabling switchable passing orders for more efficient multi-agent path finding plan execution. In Proceedings of the AAAI Conference on Artificial Intelligence, p. 17559–17566. External Links: Document Cited by: §I-C. [19] V. Tereshchuk, S. Devasia, and A. G. Banerjee (2021) A scheduling method for multi-robot assembly of aircraft structures with soft task precedence constraints. Robotics and Computer-Integrated Manufacturing 71, p. 102145. External Links: Document Cited by: §I-A. [20] B. Zhou, R. Zhou, Y. Gan, F. Fang, and Y. Mao (2022) Multi-robot multi-station cooperative spot welding task allocation based on stepwise optimization: an industrial case study. Robotics and Computer-Integrated Manufacturing 73, p. 102197. External Links: Document Cited by: §I-A.