- Rating
- 1
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 1
- Soundness
- 2
Read review
Paper summary
This paper introduces LC-MAPF, a decentralized multi-agent pathfinding policy trained through imitation learning with multiple rounds of local communication. Its central design separates a fixed observation representation from the evolving message state and reintroduces the observation at every communication round. Compressed representations and fixed-dimensional messages keep the communication computation bounded. The approximately three-million-parameter model is trained with four rounds, using expert supervision on the final action without explicit message labels. Evaluation covers Random, Mazes, Warehouse, and Cities Tiles in POGEMA, with learning-based baselines including MAPF-GPT, SCRIMP, DCC, MAGAT+, and HMAGAT, and additional PIBT and RT-LaCAM comparisons in the appendix. Results demonstrate competitive performance across map types, unseen agent counts, and some distribution shifts, although the method does not dominate every metric. Additional validation examines communication rounds, neighborhood size, random message corruption, batched GPU inference with up to 5,000 agents, and deployment on three physical robots communicating through ROS2.
Critical strengths
-
LC-MAPF achieves strong performance with only about 3 million parameters; across various settings, it matches or outperforms competitive baseline models, including the 85-million-parameter MAPF-GPT model. Up to 32 agents were used during training, while evaluation covered larger sample sizes and diverse map topologies, providing strong evidence of generalization capability. Even though the method’s innovation primarily lies in the effective integration of established components, it remains a significant practical contribution. Its advantages are evident in model size and evaluation performance; however, the reported training duration of approximately 900 GPU-hours does not demonstrate low training costs.
-
The evaluation scope extends beyond the final success rate to include communication rounds, neighborhood size, and message corruption; the appendix also supplements the evaluation with reactive search baselines. In robot deployment, each robot runs its own policy and performs actual ROS2 message exchanges; the host only synchronizes position snapshots without performing neural network inference or selecting actions. This breadth enhances confidence in the implementation and elevates the paper’s value beyond a mere architectural proposal.
Critical weaknesses
-
This paper presents the separation of message states and observation states, as well as the re-injection of observations, as its core contributions; however, neither of these has been directly compared with corresponding alternatives. Existing research on the number of rounds, neighborhood size, and data tampering indicates that trained policies exploit communication; however, these studies have not demonstrated the specific advantages of each of these two design choices.
All experiments employed four rounds of training and supervised only the final action, while the message received in the first round originated from a shared initial vector. Therefore, the complete failure observed when this checkpoint was truncated to a single round was actually due to confusion resulting from a significant mismatch between training and inference. The Differential Transformer and HybridNorm components further complicate attribution. This shortcoming directly limits the empirical support for the contributions of this unique methodology.
-
The linear-time results in Table 5 measure batch forward computations on a single GPU. These results do not demonstrate the scalability of actual message passing, synchronization, neighbor construction, or the complete decision pipeline. Failures observed with 2,000–5,000 agents at a 30% obstacle density also illustrate why computational scalability and reliable problem-solving capabilities should be evaluated separately. Furthermore, Table 2 conflates a near-perfect success rate with a non-zero collision count. This paper should explicitly state whether these counts represent collision attempts blocked by the environment and precisely define the scope of “collision-free shielding.” Although the three-robot demonstration supports deployment feasibility, its synchronized position snapshots and controlled execution conditions cannot demonstrate latency or reliability in large-scale distributed environments. These limitations substantially constrain claims regarding practical scalability.
Questions for authors
-
This paper identifies “separation of observations and messages” and “repeated injection of observations” as its key distinguishing features; however, the current experiments do not directly analyze these two mechanisms in isolation. Given roughly equivalent expert data, training budgets, backbone networks, and the number of parameters, please compare traditional multi-round communication, the removal of observation re-injection, shared observation-message states, and a separately trained, non-communicative model. Does the proposed design yield consistent and significant performance improvements? Furthermore, which specific update mechanisms in previous methods lead to the gradual overwriting of observational information, and what evidence suggests that this limits their performance? These results are crucial for evaluating the academic contribution of this method.
-
Table 2 modifies the inference depth of the model trained over four rounds, with action supervision applied only in the final round and the message received in the first round originating from a shared initial vector. Therefore, failure in single-round inference does not prove that a separately trained single-round model would be ineffective. Please independently train single-round, two-round, and four-round models under comparable resource budgets and report the success rate, SOC, and decision latency. Does the four-round model still demonstrate an advantage? If this primarily reflects consistency with the training configuration, how should the interpretation of communication depth be revised?
-
Table 2 reports high success rates alongside non-zero collision counts. Please clearly specify the POGEMA version, the conflict resolution mode, and the execution rules for vertex conflicts and backward edge traversal. Do these counts represent conflicted motion attempts, motions blocked by the environment, or collisions within executed trajectories? What mechanisms does “no collision shielding” specifically exclude? Please additionally report the conflict rate of raw joint motions and the task completion rate without such conflicts, and describe any additional waiting, blocking, or avoidance mechanisms in the robot’s execution stack. This determines the extent to which this evaluation can directly validate the policy’s ability to generate conflict-free motions.
-
Actual ROS2 message exchanges provide valuable evidence, but the qualitative three-robot demonstration does not quantify the complete decision-making pipeline. Please report the median and tail delays of decision-making, task completion rates, and collision rates through repeated robot experiments or a multi-process implementation using actual message transmission, and clearly specify whether host-based position snapshot synchronization is included. The current “message failure” experiment uses Gaussian vectors as a substitute. In the event of actual packet loss, delay, or message expiration, how does the four-wheel synchronization protocol perform, what timeout and fallback rules apply, and how does performance change? These results directly impact the evaluation of the claim of “actual decentralized deployment.”
3 comments
Part 2
Q3
Our benchmark runs POGEMA 1.3.2a4 in soft collision mode. Its execution rules handle both vertex and swap conflicts. When two or more agents attempt to enter the same cell, one agent moves and the others wait in place. If two agents attempt to exchange positions, both wait. Conflict resolution occurs within the environment before positions are updated.
The phrase “no collision shielding” refers to submitting the policy's actions directly to POGEMA, without an additional planner such as CS-PIBT modifying them first. POGEMA's built-in rules enforce feasibility by blocking impossible moves. Collision-shielding methods such as CS-PIBT actively construct a coordinated, conflict-free joint action. In our benchmark, the policy is responsible for learning to coordinate its proposals.
For the original Table 2 (now Appendix B), we count the individual moves that POGEMA blocks due to inter-agent conflicts. With 160 agents and four rounds on Warehouse, this gives a conflict rate of 3.74% of proposed agent moves. All episodes completed under the environment's execution rules.
In the additional multi-process experiments described in Q4, we recorded the proposed joint actions before POGEMA resolved conflicts. A vertex conflict means that two agents propose the same destination cell; an edge conflict means that they propose traversing the same edge in opposite directions. Each unordered agent pair is counted once per conflict type and step. The baseline results are:
| Agents | Conflicted steps | Pairs / 1,000 agent-steps | Zero-conflict runs |
|---|---|---|---|
| 3 | 0/131 (0%) | 0 | 5/5 |
| 5 | 0/134 (0%) | 0 | 5/5 |
| 20 | 4/191 (2.09%) | 1.047 | 3/5 |
| 50 | 14/213 (6.57%) | 1.502 | 0/5 |
All five runs per size completed with POGEMA resolution. At 50 agents, 14/213 joint steps (6.57%) contained 16 proposed conflict pairs, not physical collisions. Zero-conflict runs contain no proposed vertex/swap conflict; they are not tests with resolution disabled. These additional results characterize the multi-process setup, not the original benchmark table.
The three-robot demonstration combines local LC-MAPF action selection with Nav2 motion execution and synchronized rotation and translation phases (Appendix E). The host synchronizes position snapshots; it does not select actions. This is a qualitative demonstration of the integrated execution stack and does not isolate the policy's ability to generate conflict-free physical motions.
Part 3
Q4
We ran 50 multiprocess episodes with actual ROS 2/Zenoh communication. Each agent performs local inference and action selection in a separate Docker container/network namespace and local DDS domain. POGEMA supplies authoritative positions and executes joint actions; a coordinator distributes states and collects actions without neural inference. Four decoder passes involve three inter-round message exchanges using trained-policy vectors, without Gaussian replacement. We used a 50×50 maze, five start–goal seeds/condition, a 128-step horizon and one shared 10-core/20-thread x86 host, with one PyTorch thread per agent.
Latency starts just before host state/step publication and ends when all actions arrive. It includes host-based position synchronization, observation/neighbor preparation, inference, inter-round communication and receive barriers, and action collection; POGEMA transitions are excluded. Percentiles pool joint steps within each condition (five episodes/row).
| Agents | Network condition | Median, ms | p95, ms | p99, ms |
|---|---|---|---|---|
| 3 | baseline | 136.6 | 162.3 | 169.5 |
| 3 | +20 ms delay | 190.3 | 275.2 | 288.2 |
| 3 | 1% packet loss | 138.0 | 178.0 | 200.4 |
| 3 | nominal 1 s outage | 140.1 | 193.2 | 1800.0 |
| 5 | baseline | 180.1 | 211.3 | 229.5 |
| 20 | baseline | 301.5 | 346.9 | 385.1 |
| 50 | baseline | 1251.6 | 1427.6 | 1514.7 |
| 50 | +20 ms delay | 1297.4 | 1493.3 | 1647.0 |
| 50 | 1% packet loss | 1116.4 | 1334.9 | 1406.8 |
| 50 | nominal 1 s outage | 1221.0 | 1496.1 | 3615.8 |
All 50 episodes completed with POGEMA conflict resolution; Q3 reports raw proposed-conflict rates and zero-conflict episodes. These are simulated agents using actual middleware, not additional physical robot trials.
Netem impaired outgoing agent-to-router TCP traffic: +20 ms delay, 1% packet loss, or complete loss after three steps for a nominal one-second window. Actual outage windows were 1.115–1.162 s (3 agents) and 1.530–1.705 s (50), including application/removal across containers. Impairments were cleared before episode initialization. TCP retransmission can convert packet loss into delay; the faster 50-agent loss result does not establish a benefit.
Agents wait up to 2 s for team positions and 0.5 s at each of three inter-round message barriers. Missing neighbor slots retain the learned empty-message embedding; missing teammate positions revert to configured initial positions. Messages are matched by step/round IDs; separate expiration was not tested. The host resends triggers at 1 Hz, with a 60 s action deadline. Missing actions receive recorded waits and an incomplete decision ends the benchmark episode; no such timeout occurred.
At 50 agents, the share of missing neighbor-message slots was 0.13% across baseline episodes and 0.32% across episodes in the outage condition; the latter recorded 742 missing message slots and 1,006 missing position slots. The table shows increased tail latency, while all runs completed. The shared host, coordinator and team-wide transport subscriptions limit the conclusion to the tested pipeline; these results do not establish linear distributed scaling or physical reliability at 50 agents.
Part 1
We thank the reviewer for the detailed assessment and for recognizing the model's compactness, generalization and practical contribution. The suggestions helped us strengthen component attribution, distinguish computational scaling from deployment performance, and clarify conflict metrics. We also added measurements using actual ROS 2 communication. In the revised manuscript, we use purple for changes specific to this review and dark red for changes addressing questions raised by multiple reviewers. Below, we respond to each concern and question.
W1 and Q1
We did not measure whether previous methods lose observation information as messages change. We removed that claim from Section 2.3. We tested how much LC-MAPF gains when its decoder can consult the local observation again. Section 4 now distinguishes the fixed observation encoding from the decoder representations updated within each round and clarifies final-round action selection.
We retrained each control on the same data, with the same Differential Transformer/HybridNorm backbone and four rounds. Restricting the observation to the first round reduced mean success from 91.1% to 86.8%. Removing neighbor messages reduced it to 84.3%, even though the agents could still observe nearby agents. Both controls increased normalized SoC and blocked moves in both seeds (Table 2). The paired differences in success were significant in both seeds (Appendix A).
Success is shown as seed 1337 / seed 1338 on all 3,200 cases. SoC and blocked moves are means over the two seeds on the common 2,396 cases solved by all eighteen checkpoints; SoC is divided by the sum of individual shortest-path lengths.
Skip-connected CommNet also revisits its original observation. It combines that observation with an evolving agent state and the mean of its neighbors' states. It reached 86.6% mean success under the same training budget, with a similar parameter count. This comparison changes both the observation representation and how messages are combined. Isolating a shared observation–message state would require varying that choice alone. The graph attention alternative likewise shares the encoder and changes the communication core, reaching 87.2% mean success with 3.23M parameters; it is included in the same table and cost cohort.
W2
Revised Table 6 measures batched GPU inference; it does not establish distributed pipeline scaling. At 30% obstacles, 2,000–5,000-agent cases reach the 2,048-step cutoff without completion, so computational scaling and solving performance must be distinguished. The introduction scopes the timing claim accordingly. Q4 reports actual ROS 2 pipeline measurements, separately from the qualitative three-robot demonstration.
Q2
We independently trained models with one, two, four and eight rounds using matched data, optimization settings and 200,000 updates, then evaluated each at its trained depth (Section 5.2, Table 3). This comparison addresses trained depth separately from the inference-only truncation in Appendix B.
Success: seed 1337 / seed 1338 on all 3,200 instances. SoC averages both seeds on the 2,396 common successes. Times are median / p95 on Warehouse: a 128-agent GPU team including observation preparation, and one CPU agent's policy computation, excluding network transport. The encoder runs once per decision; only the decoder repeats across rounds. Appendix A.1 gives the execution mode, hardware and timing protocol.
Four rounds improve success and reduce SoC relative to one or two rounds in both seeds, showing an advantage even when the shallower models are trained at their own depths. Eight rounds achieve the highest mean success and lowest SoC, with greater decision latency; their success gain over four rounds is significant in only one seed (Appendix A).