acceptodds
Under review as a conference paper at ICLR 2027

Learning to Communicate Locally for Large-Scale Multi-Agent Pathfinding

Abstract

Multi-agent pathfinding (MAPF) is a widely used abstraction for multi-robot trajectory planning problems, where multiple homogeneous agents move simultaneously within a shared environment. Although solving MAPF optimally is NP-hard, scalable and efficient solvers are critical for real-world applications such as logistics and search-and-rescue. To this end, the research community has proposed various decentralized suboptimal MAPF solvers that leverage machine learning. Such methods frame MAPF (from a single agent perspective) as a Dec-POMDP where at each time step an agent has to decide an action based on the local observation and typically solve the problem via reinforcement learning or imitation learning. We follow the same approach but additionally introduce a learnable communication module tailored to increase the level of cooperation between the agents via efficient feature sharing. We present the Local Communication for Multi-agent Pathfinding (LC-MAPF), a generalizable pre-trained model that applies multi-round communication between neighboring agents to exchange information and improve their coordination. Our experiments show that the introduced method outperforms the existing learning-based MAPF solvers, including IL and RL-based approaches, across diverse metrics in a diverse range of (unseen) test scenarios. Remarkably, the introduced communication mechanism does not compromise LC-MAPF’s scalability, a common bottleneck for communication-based MAPF solvers.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Multi-Agent Pathfinding, Multi-Agent Coordination, Learned Communication, Decentralized Planning, Imitation Learning, Multi-Robot Systems, Scalable Planning

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_ARZCOpenReview ↗
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
  1. 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.

  2. 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
  1. 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.

  2. 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
  1. 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.

  2. 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?

  3. 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.

  4. 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

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).

Model (four rounds)Success, %Norm. SoCBlocked moves
LC-MAPF91.12 / 91.001.32995
No communication84.84 / 83.781.366138
Mean-pooled86.50 / 87.341.359124
First-round-only86.88 / 86.751.358123
CommNet with skip connections85.91 / 87.311.366124
Graph attention87.59 / 86.841.358123

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.

Trained RRSuccess, %Norm. SoCGPU team, msCPU local (N=1N=1), ms
183.53 / 84.091.36912.9 / 13.213.12 / 13.55
288.06 / 87.971.34014.4 / 14.714.59 / 15.27
491.12 / 91.001.32917.0 / 17.317.38 / 17.92
891.34 / 92.161.32421.6 / 21.822.73 / 23.31

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).

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:

AgentsConflicted stepsPairs / 1,000 agent-stepsZero-conflict runs
30/131 (0%)05/5
50/134 (0%)05/5
204/191 (2.09%)1.0473/5
5014/213 (6.57%)1.5020/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.

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).

AgentsNetwork conditionMedian, msp95, msp99, ms
3baseline136.6162.3169.5
3+20 ms delay190.3275.2288.2
31% packet loss138.0178.0200.4
3nominal 1 s outage140.1193.21800.0
5baseline180.1211.3229.5
20baseline301.5346.9385.1
50baseline1251.61427.61514.7
50+20 ms delay1297.41493.31647.0
501% packet loss1116.41334.91406.8
50nominal 1 s outage1221.01496.13615.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.

Reviewer_uWxeOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
2(+1)
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes LC-MAPF, a decentralized MAPF method that adds learned multi-round local communication to a Transformer-based imitation learning model. Each agent compresses its local observation into a fixed-size latent state zuz_u and, over RcommR_{\mathrm{comm}} communication rounds, exchanges a message vector murm_u^r with its neighbors; the message channel is kept separate from the observation, and zuz_u is re-injected at every round. The 3M-parameter model is trained end-to-end on LaCAM* expert demonstrations, without supervision on the messages. On the POGEMA benchmark, it achieves average success rates on par with or better than learning-based MAPF solvers, including MAPF-GPT, and its inference time scales linearly up to 5,000 agents.

Critical strengths
  1. Scalability. With 3M parameters, LC-MAPF matches or exceeds in average success rate both the similarly sized MAPF-GPT-DDG (2M) and the 85M-parameter MAPF-GPT (Sec. 5.1, Fig. 3), and its inference time grows linearly up to 5,000 agents (Table 5).
  2. Real-robot validation. The policy is deployed on three physical robots without modification, with the messages exchanged over actual ROS 2 communication (App. C), although a host process synchronizes the robots' positions.
Critical weaknesses
  1. A closely similar method already exists, and the benefit of re-injection is not shown. LC-MAPF follows the structure of CommNet with skip connections (Sukhbaatar et al., NeurIPS 2016, Eq. 4), which is not cited: the local observation is encoded once, a fixed number of local communication rounds update an internal state from the neighbors' messages, and the observation encoding is re-injected into every round. This re-injection is exactly what Table 1 lists as unique to LC-MAPF, whereas exchanging messages, i.e., projections of the policy's internal state, is common to all compared methods. Neither CommNet nor this paper ablates the re-injection, so the claim that it prevents the observation from being overwritten (Sec. 2.3) remains untested. The comparison with MAPF-GPT, which uses the same observation, including the neighbors' positions, goals, and greedy actions (Andreychuk et al., 2025b), only roughly shows the benefit of adding messages. As a result, the contribution is essentially an empirical application of CommNet-style communication to MAPF.
  2. The multi-round communication is understood only empirically. The rounds iterate on the policy's internal state shared with the neighbors, so whether the iteration converges to a consistent joint action is the key question, yet no convergence, stability, or fixed-point analysis is given. Table 2 changes the number of rounds only at inference for a model trained with Rcomm=4R_{\mathrm{comm}} = 4, and more rounds do not help. More generally, the experiments in Sec. 5.2–5.4, including the one called an ablation (Sec. 5.2), only change the inference conditions of a single model trained with four rounds; no component is removed and retrained, so the claim in Sec. 6 that ablations confirm the benefit of multi-round communication is not supported.
Questions for authors
  1. Comparison with CommNet. How does LC-MAPF compare with CommNet (Sukhbaatar et al., 2016) with skip connections, trained on the same observations and data? Which components of LC-MAPF account for the difference, including the small model size?
  2. Missing ablations. Results of LC-MAPF with the same architecture and data (a) without feeding zuz_u into every round and (b) with communication zeroed, as in the independent controller of CommNet. Unlike the experiments in Sec. 5.2–5.4, including the one called an ablation (Sec. 5.2), which only change the inference conditions, these require retraining without each component.
  3. Optimality of the number of rounds. Results when the model is trained, not only evaluated, with different numbers of rounds. Does the optimum at four rounds remain? Does ∥mr−mr−1∥\|m^r - m^{r-1}\| decrease as rr increases, i.e., does the iteration approach a fixed point, so that the number of rounds could be chosen by a convergence criterion rather than fixed?
5 comments

We thank the reviewer for the careful assessment and for recognizing the compact model's performance, computational scalability and robot demonstration. The comments helped us clarify the relationship to CommNet, add retrained component and depth comparisons, and examine message dynamics across rounds. In the revised manuscript, we use blue 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 now cite CommNet with skip connections in Section 2.3 and acknowledge its observation re-injection and sharing of update weights across rounds. CommNet averages neighbor states; LC-MAPF attends to individual message tokens and a bank of observation tokens. Section 4 clarifies that each round reuses the original observation encoding while jointly updating the working token representations. Actions are selected from the final-round distribution.

We trained the skip-connected CommNet and graph-attention adaptations with the same MAPF observations, encoder and dataset as LC-MAPF, matching optimization settings, 200,000 updates and four rounds (Section 5.2, Table 2, Appendix A). Success is shown as seed 1337 / seed 1338 on all 3,200 instances. Normalized SoC averages both seeds on the same 2,396 common successes used in the main ablation tables.

ModelParametersMessage widthSuccess, %Norm. SoC
LC-MAPF3.24M9691.12 / 91.001.329
CommNet3.31M16085.91 / 87.311.366
Graph attention3.23M22487.59 / 86.841.358

LC-MAPF has higher success in every map family in both seeds and lower overall SoC than both adaptations. Its shared decoder keeps the parameter count independent of the number of rounds, and its messages are shorter than those of both alternatives. These comparisons change several components together; the graph-attention adaptation is not an exact reproduction of MAGAT+.

The retrained component controls in Table 2 address individual design choices. Mean pooling reduces mean success to 86.9%, and removing direct observation access after the first round reduces it to 86.8%.

We also evaluate LC-MAPF's communication architecture on CommNet's lever-coordination and traffic-junction tasks. These LC-MAPF cores use task-specific observation and action interfaces and are trained from scratch; they are labelled LC in Appendix G. Tables report means and sample SDs over five training seeds, using final checkpoints.

In lever coordination, five agents must choose different levers. Models are trained and evaluated at four or eight rounds, with the same seed-specific training groups, AdamW settings and update budget.

Communication modelFailure at 4 rounds, %Failure at 8 rounds, %
CommNet, shared weights2.06 ± 0.101.45 ± 0.08
CommNet, separate weights1.66 ± 0.101.34 ± 0.10
LC-MAPF core, shared decoder0.99 ± 0.040.97 ± 0.02

The LC-MAPF core has lower mean failure at both depths, although parameter counts are not matched: its core is larger than shared-weight CommNet. Appendix G also reports the native-recipe CommNet reproduction and a separate three-round control of the LC-MAPF core without neighbor messages.

In traffic junctions, an episode fails if it contains a collision. We compare a common AdamW recipe and CommNet's native RMSProp recipe, reporting completed trips alongside failures to account for how much traffic moves.

ModelOptimizerFailed episodes, %Trips/episode
CommNetNative RMSProp1.671 ± 0.66717.635 ± 0.046
CommNetAdamW7.994 ± 2.63217.192 ± 0.273
LC-MAPF coreAdamW1.204 ± 0.81317.728 ± 0.056

The LC-MAPF core has lower mean failure under the common AdamW recipe and higher mean throughput. Its failure-rate difference from native-RMSProp CommNet is not statistically established. Appendix G provides protocol details and statistical comparisons, and also notes unfavorable exploratory bAbI task 2 and Combat comparisons. The matched MAPF comparisons support the LC-MAPF design; its advantage on the auxiliary tasks depends on the task and training recipe.

W2 and Q3

We independently trained models with one, two, four and eight rounds and evaluated each at its trained depth (Section 5.2, Table 3).

Trained RRSuccess, %Norm. SoCGPU team, msCPU local (N=1N=1), ms
183.53 / 84.091.36912.9 / 13.213.12 / 13.55
288.06 / 87.971.34014.4 / 14.714.59 / 15.27
491.12 / 91.001.32917.0 / 17.317.38 / 17.92
891.34 / 92.161.32421.6 / 21.822.73 / 23.31

Success: seed 1337 / seed 1338 on all 3,200 instances. SoC averages both seeds on the 2,396 common successes. Times are median / p95 for a 128-agent GPU team and one CPU agent, excluding network transport. The encoder runs once per decision; only the decoder repeats across rounds. Appendix A.1 specifies the timing protocol.

Four rounds improve success and reduce SoC relative to one or two rounds in both seeds. Eight rounds achieve the highest mean success, with a longer decision time; their 0.7-point gain over four rounds is significant in only one seed (Appendix A).

On fixed observations, median message changes decrease and action distributions typically stabilize across rounds. Some agents still show substantial changes, so these diagnostics do not establish convergence for all agents or validate adaptive stopping. Appendix A.2 reports the per-seed diagnostics and threshold analysis.

Q2

Both requested controls are retrained with the same backbone, data and four local rounds. Metrics use the protocol and cohort above. Success is shown as seed 1337 / seed 1338; SoC and blocked moves average both seeds.

Model (four rounds)Success, %Norm. SoCBlocked moves
LC-MAPF91.12 / 91.001.32995
First-round-only86.88 / 86.751.358123
No communication84.84 / 83.781.366138

First-round-only makes observation information reach later rounds through the message state. No communication removes neighbor-message links during training and evaluation while retaining self-messages, repeated observation input and observable neighbor features. Full LC-MAPF improves success, SoC and blocked moves in both seeds; Table 2 and Appendix A give details.

Reviewer_uWxeOpenReview ↗

Response to Authors

Thank you for your detailed response and the additional experiments, which address my questions. As acknowledged in Section 2.3 of the revised version, the re-injection of observations had already been proposed in CommNet. Therefore, the novelty of the proposed method is not as high as claimed. As the new Table 2 shows, the difference lies not in the re-injection of observations itself, but in the method of aggregating neighboring messages. Table 1 and the first contribution in Section 1 still present observation re-injection as a distinguishing feature of LC-MAPF and should be revised accordingly. In addition, as you yourself acknowledge, the issue of convergence across rounds remains unclear. Since I place weight on theoretical or algorithmic contributions, which remain limited here, I will maintain my evaluation.

Reviewer_mcjtOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents LC-MAPF, a decentralized multi-agent pathfinding model that uses multiple rounds of local communication. The architecture separates observation representations from communication messages and incorporates each agent’s encoded local observation at every communication round. The model is trained via imitation learning using demonstrations generated by LaCAM* and evaluated across different map types and agent counts. The paper also includes a demonstration involving three physical robots.

Critical strengths

The design has a clear computational motivation: limiting the number of neighbors and using fixed-dimensional messages keep per-agent neural computation and communication bounded in each round. The transfer results are also informative. Despite being trained with at most 32 agents, the roughly 3M-parameter model remains competitive with the evaluated learning-based baselines on unseen map types and with larger agent populations.

Critical weaknesses

The ablation studies do not adequately establish how much of the reported performance improvement is attributable to the proposed communication design. Table 2 varies the number of communication rounds at inference time for a model trained with four rounds. The message-failure test (Table 3, with additional results in Table 6) perturbs messages, while Table 4 restricts the communication neighborhood. These tests show that the trained model depends on communication and its configuration, but they do not isolate the combined benefit of separating messages from observation representations and reinjecting observations at every round. In particular, setting R = 1 changes computational depth, and agents do not yet receive observation-conditioned messages from their neighbors at this stage. Poor performance in this setting therefore cannot serve as a substitute for a comparison of alternative architectures trained under comparable conditions and evaluated with the same number of communication rounds.

The evaluation metrics also require clarification. Table 2 reports a success rate of 1.00 alongside 487 ± 24 collisions for 160 agents at R = 4. However, it is unclear whether the collision counts refer to attempted conflicts blocked by the environment or actual conflicts in executed trajectories, and how they relate to the success criterion. Although the paper defines SoC and cites the evaluation protocol, Figures 4 and 6 do not explicitly state which instances are included in the statistics or how failures are handled. If each method’s SoC is computed only over the instances it successfully solves, differences in cost could partly reflect differences in instance difficulty.

Questions for authors

What evidence isolates the additional benefit of combining separate observation and message representations with observation reinjection at every round, compared with alternative multi-round communication architectures trained under comparable conditions?

What is counted as a collision in Table 2, and how does this relate to the success criterion? Which runs are included in the SoC statistics in Figures 4 and 6, and how are failed runs handled?

1 comment

We thank the reviewer for the detailed feedback and for recognizing the computational motivation of local communication and the model's generalization to unseen maps and larger teams. The comments helped us strengthen the architectural comparisons and clarify the evaluation metrics. In the revised manuscript, we use green 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

Our original experiment shortened a trained model at test time. For the new comparison, we trained and tested each model with four communication rounds (Section 5.2, Table 2). All models use the full training dataset, 200,000 optimizer updates, global batch size 512 team-state samples and two training seeds, with matched optimization settings; evaluation covers the same 3,200 instances.

Model (four rounds)Success, %Norm. SoCBlocked moves
LC-MAPF91.12 / 91.001.32995
No communication84.84 / 83.781.366138
Mean-pooled86.50 / 87.341.359124
First-round-only86.88 / 86.751.358123
CommNet with skip connections85.91 / 87.311.366124
Graph attention87.59 / 86.841.358123

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.

The three controls use the same backbone. No communication masks neighbor-message links while retaining self-messages and observable neighbor features; mean pooling merges neighbor messages; first-round-only removes direct observation access after round one. LC-MAPF solved more instances in every map family for both seeds. It also had lower overall SoC and fewer blocked moves. Appendix B reports the original test-time truncation results.

The CommNet and graph-attention adaptations also share the encoder and use four rounds with similar parameter counts. They change pooling, message width and update modules together, so these comparisons evaluate complete architectures rather than isolate one component. Their definitions and paired tests are in Appendix A.

The three component controls support contributions from learned message exchange, separate neighbor-message tokens and repeated observation access with the backbone and four-round depth held fixed. LC-MAPF also achieves higher success and lower SoC than the CommNet and graph-attention adaptations in both seeds under the matched training protocol.

W2 and Q2

The collisions in the original Table 2 count proposed moves that POGEMA blocked. It replaced those moves with waits before updating the agents' positions. In the 160-agent Warehouse test, the environment blocked 3.74% of proposed moves. All agents still reached their goals together within the step limit in all 128 episodes.

Figures 4 and 6 include all evaluated instances, including episodes in which some agents fail to reach their goals. For each instance, SoC is the sum of individual agent costs. Agents that reach their goals contribute their path costs, while agents that have not reached their goals by the end of the evaluation horizon are assigned a cost equal to that horizon. Failed episodes therefore remain in the reported statistics, with unfinished agents contributing the horizon cost. We have clarified this treatment in Section 5, before Section 5.1.

The new architecture and depth ablations use a common set of 2,396 instances solved by all eighteen compared checkpoints across both training seeds. Their normalized SoC is the sum of individual agent costs divided by the sum of individual shortest-path lengths. This gives all models the same tasks for the cost comparison, as specified in Appendix A.

Comments on the paper

1 comment

We sincerely thank the reviewers for their thoughtful feedback and for recognizing LC-MAPF’s compactness, generalization and practical relevance. Their comments helped us strengthen the experimental evidence and clarify the contribution and evaluation.

We have provided detailed replies to the individual comments and summarize the main revisions below:

  • We added architecture ablations with retraining, using the same number of communication rounds during training and evaluation. These controls support the benefits of learned message exchange, separate neighbor-message tokens and observation re-injection. Section 5.2, Table 2 and Appendix A provide the comparisons, training protocol and detailed results. (Reviewers mcjt, uWxe and ARZC.)
  • We explicitly credited observation re-injection in CommNet with skip connections and revised the introduction, related work and Table 1 to clarify LC-MAPF’s architectural distinction. We added matched MAPF comparisons against the CommNet and graph-attention adaptations, with LC-MAPF achieving higher success rates and lower SoC under the tested protocol. We also added comparisons on CommNet’s lever-coordination and traffic-junction tasks using task-specific models trained from scratch. See Sections 1, 2.3 and 5.2, Tables 1–2 and Appendices A and G. (Reviewer uWxe.)
  • We independently trained models with one, two, four and eight communication rounds and evaluated each using the same number of communication rounds as during training. These comparisons show the benefits of additional communication rounds and report the corresponding computation times. We also examined message dynamics across communication rounds and clarified that the observed stabilization does not establish convergence for all agents or validate adaptive stopping. See Section 5.2, Table 3 and Appendices A.1–A.2. (Reviewers uWxe and ARZC.)
  • We clarified that the original collision counts refer to moves blocked by POGEMA because of inter-agent conflicts. We explained how unsuccessful episodes contribute to SoC and specified the common set of instances solved by all compared checkpoints for SoC comparisons between retrained models. See Section 5 and Appendices A–B. Additional conflict statistics for the proposed joint actions are reported in our response to ARZC Q3. (Reviewers mcjt and ARZC.)
  • We provided additional multiprocess experiments using actual ROS 2 message exchanges, reporting decision latency, including position synchronization, task completion, conflicts in the proposed joint actions and behavior under network impairments. These measurements and their limitations are described in our responses to ARZC Q3–Q4. The batched inference scaling results and the physical robot demonstration in Appendix E are discussed separately. (Reviewer ARZC.)

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.