OSDAG: Online Scheduling for Efficient Multi-Robot Collaboration

Abstract: Coordinating heterogeneous multi-robot systems (MRS) for complex, long-horizon tasks requires both flexible high-level reasoning and efficient low-level scheduling. Existing LLM-based approaches address the reasoning side but introduce two critical bottlenecks: (1) repeated LLM inference during execution, which inflates latency with agent count, and (2) offline, pre-committed scheduling, which forces robots to idle while waiting for sequentially ordered predecessors even when independent work is available. This paper presents OSDAG, a novel framework that integrates LLM-based task reasoning with Directed Acyclic Graph (DAG) representation and constraint-aware online scheduling. The LLM is invoked once to decompose a natural-language instruction into a dependency-annotated task graph, and a lightweight online scheduler then allocates ready tasks to idle agents in real time. The DAG representation encodes both precedence and resource constraints, ensuring correctness while exposing all available parallelism. Experiments across five benchmark scenarios demonstrate that OSDAG achieves 5-15x faster reasoning time compared to dialogue-based methods, reduces makespan by up to 38% over sequential baselines, and maintains competitive success rates. Both simulation and real-world experiments on dual-arm manipulation tasks validate the effectiveness and practicality of the proposed approach for efficient multi-robot coordination. The website and resources are available at http://thanhnguyencanh.github.io/LLM_DAG4MultiRobot

• The paper introduces OSDAG, which converts natural-language instructions into a dependency-aware DAG with one LLM call and dispatches ready tasks through a lightweight online scheduler.
• Across five PyBullet scenarios and a real-world human-robot deployment, OSDAG achieves 80–100% success, 9.1–14.0 seconds of reasoning time, and 15.2–26.1-second makespans.
• The paper shows that dependency annotations are essential for correctness while online dispatch reduces makespan by up to 38%, although greedy scheduling and the lack of replanning limit robustness and optimality.

OSDAG addresses two structural bottlenecks in LLM-based multi-robot coordination: the latency of repeated LLM inference during execution, and the idleness induced by offline, pre-committed schedules. The framework invokes the LLM exactly once to decompose a natural-language instruction into a dependency-annotated subtask set, formalizes this set as a Directed Acyclic Graph (DAG), and then uses a lightweight, constraint-aware online scheduler to dispatch ready tasks to idle agents in real time. Across five PyBullet benchmark scenarios and a real-world human-robot collaboration deployment, OSDAG reports 5–15× faster reasoning time than dialogue-based coordination and up to a 38% makespan reduction relative to offline scheduling baselines (2606.15255).

Motivation and positioning

Existing LLM-based MRS frameworks fall into two families, each with a distinct deficiency. Decentralized dialogue methods such as RoCo assign each robot an LLM agent that negotiates through conversation; because conversation history grows linearly with agent count, latency scales poorly—RoCo requires 206.3 s of reasoning time on a three-agent task versus 14.0 s for OSDAG. Centralized flat-sequence generators such as ChatGPT-Prompts are fast (8–10 s) but produce no inter-task dependency structure, yielding success-weighted step efficiency (SSE) of only 0.36–0.51 and makespans of 33–48 s. Structured hybrids—TwoStep (LLM + PDDL), LiP-LLM (dependency graph + linear programming), DART-LLM, LaMMA-P, REBEL, ELHPlan, and CoMuRoS—improve reasoning quality but remain offline pipelines: the complete schedule is fixed before any robot moves, so agents idle while waiting for pre-allocated predecessors even when independent subtasks are executable. OSDAG's contribution is to decouple the expensive reasoning step (one-shot, offline) from the scheduling step (continuous, online, LLM-free).

Problem formulation and pipeline

The system models heterogeneous agents $\mathcal{N}$ operating over objects $\mathcal{O}$, with per-agent reachability encoded as a binary matrix $$\mathbf{R}_{ij} = \mathbb{I}[\|\mathbf{p}(N_i) - \mathbf{p}(o_j)\|_2 \leq r_i]$$ and per-agent executable action sets. Each subtask is a tuple $T_i = (\mu_i, a_i, o_i, d_i, \mathcal{D}_i)$ capturing assigned agent, action, object, destination, and prerequisite set. Scheduling minimizes makespan $C_{\max}$ subject to precedence ($s_j \geq c_i$ for each dependency edge), reachability, and capability constraints.

The pipeline has three stages. First, LLM-driven task decomposition: a single prompt $$\mathcal{P} = \Phi(\mathcal{I}, \{\mathcal{S}(N_i)\}, \{\mathcal{A}(N_i)\}, \boldsymbol{\sigma})$$—including current object states—requests a strictly schema-constrained task list. Each generated task is validated against reachability, capability, and dependency-reference checks; infeasible outputs trigger regeneration with refined constraints. Second, task graph formalization: validated tasks become DAG vertices with edges from prerequisites; a topological sort rejects cyclic (logically inconsistent) graphs. The DAG explicitly encodes both intra-agent precedence (pick→place) and inter-agent dependencies such as handoffs and shared-resource constraints. Third, constraint-aware online scheduling: an event-driven loop maintains completed and running task sets and, for each free agent, computes the executable set $\mathcal{E}_i(t)$ of tasks whose predecessors are complete, whose assigned agent is the free agent, and whose resource predicates (holding state and reachability) hold. Among ready tasks, the earliest-indexed one is dispatched. Because dispatch occurs the moment prerequisites are satisfied—rather than at pre-assigned times—independent DAG branches execute concurrently.

An illustrative timeline comparison shows the mechanism's value concretely: on a shared task graph, offline scheduling yields $C_{\max} = 30$ s with large idle blocks, while online scheduling completes in 14 s (53% faster) with only brief waits at a handoff.

Experimental results

Evaluation uses Gemini Flash as the LLM backbone, PyBullet simulation across five tabletop manipulation scenarios (varying agent count, implicit dependencies, sequential ordering, and handoff collaboration), and four metrics: success rate (SR), reasoning time (RT), makespan (MS), and SSE. Baselines are RoCo, TwoStep, and ChatGPT-Prompts, averaged over 10 trials.

Method	SR range (%)	RT (s)	MS range (s)
RoCo	0–100	64.1–206.3	19.1–41.6
TwoStep	0–90	14.3–15.2	19.1–41.6
ChatGPT-Prompts	90–100	8.2–10.3	22.7–48.3
OSDAG	80–100	9.1–14.0	15.2–26.1

Three findings stand out. Reasoning time: OSDAG's one-shot structured decomposition achieves a 5–15× speedup over RoCo, with the gap widening with agent count (Task 2, three agents: 14.0 s vs. 206.3 s). It nearly matches the flat-sequence ChatGPT-Prompts in RT while retaining full dependency awareness. Success on implicit dependencies: on Task 3 (drawer must be opened before placing items), OSDAG reaches 80% SR, whereas RoCo and TwoStep both fail completely (0%), because OSDAG embeds object states $\boldsymbol{\sigma}$ into the prompt and can thus surface hidden preconditions. This is a strong claim about the necessity of state grounding for implicit-dependency reasoning. Makespan: online scheduling reduces makespan by 33% on Task 4 (15.2 s vs. 22.7 s) and 38% on Task 5 (26.0 s vs. 41.6 s) relative to the offline variant.

The ablation study isolates each component. Removing dependency annotations causes total failure (SR = 0 across all tasks) from resource conflicts and precedence violations—indicating the DAG is not merely an efficiency aid but a correctness requirement. Removing online scheduling leaves success rates intact but inflates makespan by +49% (Task 4) and +60% (Task 5), confirming that dynamic dispatch, not just dependency modeling, drives the efficiency gains. Removing state/action embeddings raises RT (16.5 s vs. 9.1 s on Task 1) and lowers SR (70% vs. 90% on Task 2) through hallucinated actions and invalid assignments.

Real-world deployment

The framework is validated on a human-robot collaboration scenario with a UF850 manipulator, Intel RealSense D435, YOLOv11-seg perception, and depth-aligned 3D object poses. Notably, the human agent is treated as a schedulable resource receiving text-based instructions in real time, so the online scheduler coordinates heterogeneous agents with different execution interfaces. The collaborative cube-sorting task executes successfully, supporting the claim that the DAG abstraction generalizes beyond homogeneous simulated robots.

Limitations and open questions

The paper is explicit about three constraints. First, dependency edges are LLM-generated, so reasoning errors may compound as environmental complexity and agent count grow—the 80% SR on Task 3 (the only task below the baselines' ceiling where they succeed) is consistent with this. Second, the earliest-index task selection policy is a greedy heuristic and is not guaranteed to yield globally optimal schedules; no optimality bound is provided. Third, the system has no replanning mechanism, so execution failures can cascade without recovery—a significant gap given that the online scheduler monitors execution state and could in principle trigger replanning. An additional unstated assumption is that task durations are deterministic enough for the makespan comparisons to hold; stochastic execution times could erode the offline-vs-online gap.

Conclusion

OSDAG demonstrates that separating LLM reasoning (one-shot, structure-generating) from scheduling (continuous, model-free) yields both the latency profile of flat-sequence generation and the correctness and parallelism of dependency-aware planning. The ablations make the case cleanly: the DAG is necessary for correctness, and online dispatch is necessary for the makespan gains. The open problems—scalability of LLM-generated dependencies, schedule optimality, and failure recovery—are well-defined and directly addressable within the framework's structure.