acceptodds
Under review as a conference paper at ICLR 2027

Attention Is the Message: Communicating through Planner Attention for Multi-Robot Embodied Planning

Abstract

Robots that share a semantic map still spend computation encoding the same regions in their onboard planners. Can they also share the planner states computed from those regions, even as the map changes and each robot pursues a different query? We introduce region-addressed attention messages, which let robots with frozen planners reuse one another’s computation without knowing the receiver’s query or training for communication. Each room has an owner that encodes it using only a shared prefix and that room’s evidence. The resulting attention state is tagged with the room identity, evidence version, and owner. Receivers accept a message only when these tags match the current map, then use it directly through the planner’s native attention. This construction ensures that every accepted message equals the state the receiver would compute itself. With two robots, attention messages reduce planner GPU time by 45% compared with cached re-perception. Across teams of two to four robots, they match the computational cost of a centralized shared cache while keeping planning onboard. Experiments on HM3D and MP3D show that sharing room information improves navigation success, with re-perception recovering most of the same gains. Our contribution is to achieve these benefits at lower computational cost. We further validate the system through real-world navigation experiments with two physical robots, demonstrating shared planner computation with onboard planning.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Multi-Robot Navigation, Cooperative Multi-Agent Planning, Vision-Language Models for Robotics

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_ujW6OpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes region-addressed attention messages to reduce redundant VLM computation in multi-robot embodied planning. Each region is independently encoded by a designated robot, and its KV cache is associated with a region identity, version, and owner. Other robots can reuse valid cached states through their frozen planners without re-encoding the same regions. Experiments on HM3D, MP3D, and physical robots demonstrate navigation feasibility and a 45% reduction in planner GPU time compared with cached re-perception.

Critical strengths
  1. Well-motivated problem. The paper addresses redundant planner computation in multi-robot navigation, extending beyond conventional map-level information sharing.

  2. Computational efficiency gains. The proposed approach reduces execution latency and GPU processing time compared with cached re-perception, while maintaining comparable navigation performance.

Critical weaknesses
  1. Limited methodological novelty. Independent context construction, positional adaptation, and KV-cache transfer have been explored previously. The paper could better distinguish its technical contributions from existing cache-reuse methods.

  2. Figure clarity. Figure 1 could be improved in terms of visual appeal and readability. The excessive text and mathematical expressions make it appear cluttered.

Questions for authors

Q1. Novelty. Could the authors clarify the main technical differences between the proposed framework and existing KV-cache reuse methods? Which components constitute the primary methodological contributions?

Q2. Limited comparison with existing KV-cache reuse methods. Although the paper evaluates several communication and caching baselines, it lacks direct comparisons with existing KV-cache reuse techniques. Such comparisons would help clarify the proposed method's advantages.

Q3. Insufficient evaluation of independent regional encoding. Independent encoding removes cross-region attention and leads to noticeable disagreement with joint encoding. Could the authors include joint encoding results in Table 1 and further analyze the trade-off between navigation performance degradation and computational efficiency gains introduced by independent encoding?

Q4. Source of navigation performance gains. The proposed method sacrifices cross-region interactions to improve computational efficiency, yet achieves the best navigation performance in Table 1. Could these performance gains be attributed to differences in the planners used? The authors are encouraged to further analyze the sources of the observed performance improvements.

3 comments
AuthorsOpenReview ↗

Response to Reviewer ujW6

Thank you for the review. Shared points are in the general response (G1–G4). Where a question repeats a weakness, we answer once and refer back.

W1: Methodological novelty. We inherit several components: encoding each room independently from a shared prefix, storing pre-RoPE keys, rephasing at read time, and KV transport (Prompt Cache, Block-Attention, APE, EPIC, KVCOMM). The revised Sec. 1 states what we add. (1) A query-independent, world-keyed construction that an owner commits before any reader or query exists, and that frozen planners on other robots read natively. (2) A complete-key admission rule (region, version including the selected patches, single owner) that decides when shared state is current. (3) A measured account of the one approximation, independent construction (please see Q3). Table 4(b) shows that (2) is more than a detail: dropping any key field either admits stale state (99.4% of post-change decisions without the version) or makes records differ across robots, while the full key admits none. EfficientNav, now cited, is a goal-conditioned map cache for a single robot; its per-robot analogue is our cached re-perception baseline (App. E.1, Table 9).

W2: Figure 1. We redrew Figure 1 on a real HM3D map, in four labelled panels with short labels and no equations. Panel (a) shows the shared map with rooms tinted by owner. Panel (b) shows the owner running the frozen planner on the shared prefix and one room, with no goal, and tagging that room's keys and values with room, version and owner. Panel (c) shows the receiver admitting only records whose tag matches its map, encoding a changed room locally, and computing only its task tokens over all rooms. Panel (d) shows where the saving comes from: cached re-perception encodes every changed room on every robot, while attention messages encode it once. The version with full notation is Fig. 7 in the appendix.

Q1. Please see W1.

Q2: Comparison with KV-cache reuse techniques. We added CacheBlend-style recomputation and a KVCOMM-style anchor correction on the same admission layer (G2; App. E.7, Table 15). Recomputation raises agreement with joint encoding from 0.761 to 0.812 but costs 2.11 GPU-s per step against our 1.68; the anchor correction does not raise agreement. SR stays within noise for both (0.722 with recomputation against 0.708 without), so our default reaches the same navigation quality at lower cost, and recomputation can be enabled when higher agreement matters. We thank the reviewer for suggesting this comparison: it shows that correction methods complement the admission layer rather than replace it. Per-robot and centralized region caches are already in the paper as cached re-perception (3.07 GPU-s, Table 2) and a centralized cache (1.64 GPU-s, Table 3). Latent sharing matches the centralized cost while planning stays onboard: under a 20% link outage, a centralized team times out on 19.6% of decisions, while latent sharing keeps deciding (App. E.11).

Q3: Joint encoding in Table 1, and the trade-off. We agree this comparison belongs in the main table, and Table 1 now has a joint-encoding row: 0.810 SR on HM3D and 0.625 on MP3D, against 0.818 and 0.621 for latent sharing, and the paired intervals include zero on both splits (App. E.9, Table 16). Joint encoding costs 3.66 GPU-s per step against 1.68, because nothing can be reused across decisions or robots. Independent construction keeps 79–81% of joint encoding's own run-to-run agreement, and the gap concentrates in multi-room, near-tie decisions (App. E.6, Table 14). The trade-off is therefore no measurable loss in success rate for roughly half the planner GPU time.

Q4: Source of the navigation gains. This is a fair concern, and Table 1 lets us check it directly. The gains do not come from a stronger planner; ours is the smaller one. MCoCoNav runs GLM-4V 9B, while each of our robots runs GLM-Edge-V-5B. With the full map and no sharing, our planner records 0.722 SR on HM3D and 0.552 on MP3D, against 0.716 and 0.568 for MCoCoNav rerun under our protocol (Table 1). The margin comes from pruning the front end (0.752 without sharing) and from communicating teammate rooms, which adds 0.066 SR on HM3D and 0.058 on MP3D, both significant (App. E.9). The last four rows of Table 1 share this planner and front end and differ only in how teammate rooms are delivered; the caption now says so. Dropping cross-region interaction costs no measurable SR (please see Q3). Re-perception obtains the same rooms by re-encoding them on every robot and reaches a similar SR, while attention messages need 45% less planner GPU time.

Thank you for the clarification, which addressed my concern. I will raise my score.

AuthorsOpenReview ↗

Response to Reviewer ujW6

Thank you very much for taking the time to read our response and for your kind reconsideration. We sincerely appreciate your thoughtful review and your support of our work.

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

This paper proposes an attention-based communication mechanism for multi-robot embodied planning, where robots share intermediate attention states (key-value representations) rather than raw observations or map evidence. By attaching region, version, and ownership metadata to messages, the method supports consistent reuse of shared information. The authors provide formal guarantees for exact computation under a canonical fork–join setting and evaluate the approach in simulated and real-world environments, demonstrating reduced planner GPU time and improved navigation performance compared with local planning and re-perception baselines.

Critical strengths
  1. Clear Motivation and Systems Contribution. The paper addresses redundant regional encoding in multi-robot planning by sharing intermediate planner states rather than only world evidence.

  2. Practical Message Lifecycle Design. Region identity, evidence version, and owner identity enable explicit message validation and rejection of stale states.

  3. Formalized Exactness and Approximation. The paper establishes exactness under a canonical fork–join computation while explicitly identifying cross-region dependencies lost through independent regional encoding.

  4. Controlled Baselines and Attribution. Comparisons with local planning, cached re-perception, and latent sharing help isolate computational savings from the benefits of teammate information sharing.

  5. Comprehensive Efficiency and Performance Metrics. The evaluation reports GPU time, latency, communication payload, navigation success, and SPL, providing a multidimensional assessment.

  6. Scaling and Physical Feasibility. Experiments with up to four robots and physical platforms demonstrate the potential for distributed deployment, although the real-world evidence remains limited.

Critical weaknesses
  1. Unclear Incremental Novelty. The contribution beyond existing KV-cache reuse and distributed attention methods is insufficiently established, with no experimental comparison against KVCOMM-style correction or CacheBlend-style recomputation.

  2. Insufficient Approximation Analysis. Independent regional encoding removes cross-region dependencies, but the conditions under which this approximation affects planning remain unclear. The limited evaluation also cannot establish performance equivalence.

  3. Limited Model Generalizability. Experiments rely on a single frozen planner and a specific configuration, leaving the method's effectiveness across architectures and different token or region budgets uncertain.

  4. Limited Incremental Navigation Gains. Most navigation improvements arise from sharing teammate information; the additional benefit of attention-message sharing over re-perception is comparatively modest.

  5. Incomplete Scalability and Robustness Evaluation. Communication traffic increases substantially with team size, while packet loss, communication dropout, and bandwidth below 100 Mbps remain untested. Experiments cover at most four robots.

  6. Limited Real-World and End-to-End Evidence. Physical evaluation includes only ten trials without a matched baseline. The reported 45% reduction applies to planner GPU time, not total system cost, and excludes costs incurred before the stated timing boundary.

Questions for authors
  1. Novelty relative to prior cache-reuse methods: What is the principal technical advance over existing methods for independent context construction, positional rephasing, and KV-cache sharing? Can the authors provide a controlled comparison with a relevant cache-correction or selective-recomputation baseline, such as KVCOMM-style correction or CacheBlend-style recomputation, under comparable accuracy, compute, and communication budgets?

  2. Approximation behavior: The proposed method retains approximately 79–81% of the joint-encoding run-to-run agreement ceiling. Can the authors characterize which task or scene properties lead to the remaining disagreements? In particular, how does disagreement vary with the number and ordering of active regions and the degree of cross-region dependence?

  3. Statistical evidence for navigation performance: Given the relatively small controlled evaluation and the reported uncertainty, can the authors provide paired per-episode analyses or confidence intervals for the differences between joint encoding, independent construction, re-perception, and latent sharing? Can the authors clarify which performance differences are statistically supported and which are only descriptive?

  4. Sensitivity to planner and configuration: How sensitive are the computational savings and decision agreement to the planner architecture, quantization method, regional token budget, and frequency of region-version changes? Are the principal conclusions expected to hold for other compatible frozen planners, or is the method currently validated only for the tested GLM-Edge-V-5B configuration?

  5. Communication robustness and scaling: How does the method behave under packet loss, delayed updates, communication dropout, and bandwidth below the evaluated range? Can the authors quantify the impact of these conditions on stale-message rejection, local fallback, navigation performance, and computational savings?

  6. Attribution of end-to-end gains: The paper reports that re-perception recovers most of the navigation improvement obtained through information sharing. Can the authors quantify the additional navigation benefit of latent sharing over re-perception separately from its computational benefit, preferably using paired episode-level comparisons?

  7. End-to-end system cost: Does the reported 45% GPU-time reduction remain substantial when serialization, transmission, memory management, and map synchronization are included? Can the authors provide a more complete system-level cost breakdown, particularly for constrained communication links and larger robot teams?

  8. Real-world validation: Can the authors provide a matched physical-robot comparison against local re-perception or another shared-information baseline? Such an experiment would help distinguish the feasibility of transmitting planner attention states from the practical benefit of doing so in real-world navigation.

3 comments
AuthorsOpenReview ↗

Response to Reviewer RQDi

Thank you for the detailed review. Shared points are in the general response (G1–G4). Where a question repeats a weakness, we answer once and refer back.

W1: Incremental novelty. The advance is a query-independent, world-keyed construction shared across robots, plus complete-key admission that decides when shared state is current (G1; every key field is needed, Table 4(b)). We added CacheBlend- and KVCOMM-style correction on our admission layer under the same protocol (G2; App. E.7, Table 15). Recomputing 15% of the rows raises joint agreement from 0.761 to 0.812 at 2.11 GPU-s per step, still below the 3.07 of cached re-perception, with SR within noise (0.722 against 0.708); the anchor correction gives 0.752 at 1.71 GPU-s. Recomputation can thus be enabled when higher agreement matters. Both act at the receiver, so communication is unchanged. We thank the reviewer for suggesting this comparison: it shows that correction methods complement the admission layer rather than replace it.

W2: Approximation analysis. We added a stratified analysis (App. E.6, Table 14). Agreement with joint encoding falls with the number of active rooms (0.953 with one, near the int4 ceiling of 0.948, down to 0.707 with four or more), is lower when the decisive frontier lies in a later branch and when cross-room attention mass is high, and drops to 0.515 on near-tie decisions. Disagreements thus concentrate in multi-room, near-tie decisions, where recomputation helps. For equivalence, please see Q3.

W3: Planner and configuration. We added a second planner family and a second precision (App. E.12, Table 20). With Qwen2.5-VL-3B (M-RoPE, rephased over position triples) and with GLM-Edge-V-5B in bf16, single-region messages match fresh encoding up to kernel differences, and the saving is 38% and 43%. Exact reuse needs a causal decoder whose only position-dependent key transformation is a rotary phase (App. A.3). The per-room token cap does not bind (App. C), and among partitions with 3.39 to 8.95 regions per decision, rooms give the lowest latency and highest SR (Table 5). Rendered annotations change a room's version 0.80 times per active room per decision; moving them into the task text still leaves a 42% saving (Table 8).

W4: Gains over re-perception. Most navigation gain comes from receiving teammate rooms, which re-perception also does by re-encoding them on every robot. Separated, latent sharing adds +0.016 SR on HM3D and +0.022 on MP3D over re-perception (not significant, Q3), and saves 45% of planner GPU time and 12% of total step time (G3).

W5: Scalability and robustness. We added replays with packet loss, owner dropout and 25 and 10 Mbps links, a closed-loop run with a degraded planner link, and teams of up to eight robots (App. E.10–E.11, Tables 17–19). Unavailable messages fall back to local encoding, and no stale record is admitted in any condition or lifecycle event; a delayed update keeps decisions on the old map until it arrives (Sec. 4.4). At 5% loss, server time is 1.91 s against 3.07 s for cached re-perception, and at 10 Mbps it returns to that level. In closed loop at 5% loss, latent sharing keeps 0.694 SR at 2.9 s per decision. Traffic grows superlinearly with team size because each robot receives from N − 1 owners; at N = 8, latent sharing needs 4.64 GPU-s per step, against 4.57 for a centralized cache and 29.45 for cached re-perception (Table 18).

W6: End-to-end and real-world evidence. With serialization, link wait, map synchronization and the front end (Table 12, App. E.4), a step costs 8.75 s against 9.94 s for cached re-perception, 12% less (G3). Records unused for eight decisions are evicted, and peak server memory is 2×5.2 GB, as in the full-map deployment (Table 7). We also added a matched real-robot comparison (App. E.13, Table 21): on the same two scenes and target, local re-perception succeeds in 4 of 10 trials and attention messages in 5 of 10, with 9.3 s and 7.4 s of onboard planner time per decision.

Q1. Please see W1.

Q2. Please see W2.

Q3: Paired statistics. We added episode-level paired bootstrap 95% CIs and McNemar tests on the full splits (App. E.9, Table 16; intervals quoted in Sec. 4.2). Sharing teammate rooms is statistically supported on both splits. Latent sharing versus re-perception (borderline on MP3D, p = 0.065), joint versus latent, and independent versus joint construction are not significant. We agree that these data do not establish equivalence, so we report them as descriptive and revised Sec. 4.3 accordingly.

Q4. Please see W3.

Q5. Please see W5.

Q6. Please see W4.

Q7. Please see W6 for the full cost, and W5 for constrained links and larger teams.

Q8. Please see W6.

Thank you for the detailed rebuttal, which addresses most of my concerns and substantially improves the experimental evidence. However, I remain somewhat unconvinced about the incremental technical novelty of the proposed admission layer. While the additional comparisons show that correction methods complement rather than replace the admission mechanism, they do not fully establish the distinct technical contribution of the admission layer over existing KV-cache reuse and correction approaches. Furthermore, the additional navigation gains over cached re-perception remain statistically insignificant, suggesting that the primary benefit is computational efficiency rather than improved navigation performance. I therefore maintain my original score.

AuthorsOpenReview ↗

Response to Reviewer RQDi

Thank you for the follow-up. We would like to briefly clarify the two remaining points.

Contribution of the admission layer. KV-cache reuse and correction methods target static contexts: they adjust how reused state is placed or attended, but do not decide whether a cached record still matches a changing world or which agent's copy to trust. The admission layer makes this decision. It is defined in Sec. 3.2, with its guarantee in Property 2 (proof in App. A.5). Table 4(b) shows that removing any key field admits stale or inconsistent state (for example, 99.4% stale admissions without the version), and the correction methods in App. E.7 run on top of this layer rather than in its place.

Navigation gains. To test this statistically, we added paired episode-level bootstrap CIs and McNemar tests on the full splits (1,000 HM3D and 2,195 MP3D episodes; App. E.9, Table 16), and the controlled comparisons on val-72 report 3-seed means (App. E.2, Table 10). Sharing teammate rooms gives a significant gain on both splits. Latent sharing aims to deliver this gain at lower cost, with 45% less planner GPU time than cached re-perception (Table 2), so a similar success rate is in line with the claim of the paper (Sec. 4.3).

We sincerely appreciate your careful review and constructive feedback throughout the discussion.

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

This paper proposes sharing room-level KV states across robots to avoid repeatedly encoding the same semantic-map evidence while keeping planning local. Experiments on HM3D and MP3D evaluate navigation performance, including object-goal navigation and Multi-IIN, while matched communication-interface comparisons report roughly 45% less planner-server time than cached re-perception with similar navigation performance. Further experiments compare independent and joint state construction, test cache behavior under map and ownership changes, and examine room-based partitioning and deployment costs. A study extends the efficiency evaluation to four robots, and ten real-robot trials demonstrate deployment feasibility.

Critical strengths
  1. Latent sharing cuts summed planner-server time by about 45% relative to version-cached re-perception, with similar navigation performance. Savings remain after removing transient visual annotations, showing that the benefit is stable.

  2. The authors build a working multi-robot planning system that integrates room-level KV construction, version and ownership management, and cross-robot reuse while keeping planning local. Deployment on a quadruped and a wheeled robot across ten trials provides concrete evidence that the approach works in real world.

Critical weaknesses
  1. The methodological novelty and contribution of the system integration needs clearer justification. Modular KV reuse, independent navigation-map group caching, and cross-agent cache reuse have precedents in Prompt Cache, EfficientNav, and KVCOMM. The implemented system and efficiency gains are valuable and I would appreciate more discussion of the substantive system-level problems addressed, the nontrivial integration challenges encountered, or the insights gained from the design and experiments. Clarifying these points is important for assessing the significance of the contribution beyond the demonstrated implementation.

  2. The efficiency gain needs a clearer execution and cost breakdown. The experiments support 45% reduction in summed server time, but the scheduling and timing boundaries remain difficult to reconstruct. A concise timeline and a breakdown of encoding, prefill, and sharing costs for both methods would help establish where the savings arise and how they translate into faster decisions, which are central to assessing the system’s practical value.

Questions for authors
  1. Details about reuse: Do robots use the same patch set for a given room, and how is the previous-goal input handled across robots? If selection is robot-specific, how often do complete room versions match in the evaluated runs? This would help determine how strongly the reported savings depend on synchronized inputs.

  2. Benefit of room-based partitioning. In Table 5, rooms reduce overall latency relative to count-matched tiles despite slightly higher encoding time (354 versus 339 ms). Which stages account for the reduction?

3 comments
AuthorsOpenReview ↗

Response to Reviewer ESeG

Thank you for the precise questions. Several of them led us to rewrite parts of the paper. Points shared with other reviewers are in the general response (G1–G4).

W1: System problems, integration challenges and insights. The system problem is that every robot re-encodes the same changed rooms while the map keeps changing. G1 states what we add to Prompt Cache and KVCOMM, and G2 compares against correction methods. The integration problems we ran into, and what they taught us, are now a main-text paragraph, "Lessons for sharing planner state" (Sec. 4.4). It rests on four findings; the first also places the work against EfficientNav.

First, version churn decides whether caching on each robot pays off. Rendered robot arrows and frontier letters change a room's version at almost every decision (0.80 changes per active room). An EfficientNav-style cache on each robot, which is our cached re-perception baseline, lowers planner time only from 3.62 to 3.07 s per step, while sharing saves 45%. The saving therefore comes from encoding each changed room once per step across robots, not from reuse over time. Moving the annotations into the task text still leaves a 42% saving (Table 8).

Second, a content hash is not a safe key under int4 kernels. The kernels are not bitwise deterministic, so without a single owner 94.7% of records differ in bytes, and robots with identical inputs choose different frontiers in 7.9% of decisions (Table 4(b)). The owner rule removes this and also tells a receiver whom to ask.

Third, the selected patches belong in the version. If the key hashes only the rendering, 9.6% of post-change decisions admit stale state, because the selection can change while the image does not (Table 4(b)).

Fourth, robots should send state rather than queries. Remote recall moves 1.09 GB per step against 4.5 MB for latent sharing, as the payload break-even predicts (Table 6).

W2: Cost breakdown and timeline. The new Table 12 (App. E.4) splits one step, summed over both robots, into image encoding, regional prefill, reading and decoding, sharing (serialization and link wait), map synchronization and the front end. The first three stages add up to the server time of Table 2: 3.07 s for cached re-perception and 1.68 s for latent sharing. Almost all of the difference is regional encoding (image encoding plus prefill, 2.77 s against 1.44 s), because each changed room is encoded once by its owner instead of by every robot. With two robots, half is the most this can save. Sharing adds 0.21 s, and map synchronization and the front end cost the same under both methods. A full step takes 8.75 s instead of 9.94 s, 12% less, and the whole difference comes from the planner channel. Execution latency is 2.7 s against 3.3 s per decision (Table 2).

Fig. 6 draws one representative step as a timeline. Robot 2 encodes the one changed room it owns, sends it, and waits for the two rooms owned by Robot 1. Both robots then read the same admitted rows, and the step ends 0.58 s earlier than with cached re-perception.

Q1: Patch sets, the previous goal, and how often versions match. All robots use the same patch set for a room. The WallPPR selector runs once per step on the synchronized map and is seeded with every robot's position, every frontier and every robot's previous goal, so the result does not depend on which robot runs it (Sec. 4.1). In the evaluated runs, both robots held identical patch sets for every shared room in 98.8% of decisions; the remaining cases differ only through message timing within a step. 95.9% of teammate-room reads were served by an admitted message, and the other 4.1% fell back to local encoding (App. E.3, Table 11). Matching versions thus follow from the synchronized map rather than from chance. When a version does not match, the reader encodes the room itself, so a mismatch costs time but never admits stale state.

Q2: Why rooms beat count-matched tiles in Table 5. Re-perceptions (2.72 against 2.79) and encoding time (354 against 339 ms) are nearly equal, so the gap comes from other stages. The new Table 13 (App. E.5) splits the mean decision latency of Table 5 into stages (seed 0). A decision reads 3.39 rooms instead of 4.25 tiles. It therefore waits on fewer and smaller messages (serialization and link wait: 108 against 176 ms), re-encodes fewer late units (28 against 53 ms) and waits less at the step barrier (225 against 417 ms). The largest difference is per-unit rendering (1053 against 1357 ms). Each unit is rendered and preprocessed as its own image, so this cost grows with the number of units per decision. Prefill and segmentation are also slightly lower (366 against 400 ms and 301 against 345 ms). We rewrote this explanation in Sec. 4.4.

Thank you for the detailed response. The additional analyses address most of my concerns. However, I could not find the revised PDF on OpenReview. Could you clarify whether the updated manuscript has been uploaded?

AuthorsOpenReview ↗

Revised PDF re-uploaded

Thank you very much for your kind feedback and for checking. We apologize for the inconvenience: we have re-uploaded the revised PDF, and it should now be available from the PDF link at the top of this page. Please let us know if you still have trouble accessing it.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response to all reviewers

We thank the reviewers for specific and constructive reviews. In the revised PDF, new or changed text is marked in blue, and the new analyses are collected in Appendix E. We answer the shared points here (G1–G4) and each reviewer's remaining points in their own thread.

G1. Contribution beyond KV-cache reuse (ESeG, RQDi, ujW6). We build on independent context construction, positional rephasing and KV transport (Prompt Cache, Block-Attention, APE, KVCOMM). The revised Sec. 1 states what we add. First, a query-independent, world-keyed construction: an owner commits a room's planner state before any reader or query exists, and the frozen planners of other robots read it natively. Second, a complete-key admission rule for a changing map (region, version including the selected patches, single owner); Table 4(b) shows that removing any field either admits stale state or makes records differ across robots. Third, a measured account of the one approximation, independent construction, including what receiver-side correction recovers (G2, G4). EfficientNav (NeurIPS 2025), now cited, caches map groups for a single on-device reader with goal-conditioned retrieval and has no versioning, ownership or cross-agent admission; its per-robot analogue is our cached re-perception baseline (App. E.1, Table 9).

G2. CacheBlend- and KVCOMM-style correction (RQDi, ujW6). We added both on top of our admission layer (App. E.7, Table 15; HM3D val-72, 3 seeds). Recomputing 15% of the admitted rows at the receiver, as in CacheBlend, raises joint agreement from 0.761 to 0.812 at 2.11 GPU-s per step, still below the 3.07 GPU-s of cached re-perception. A KVCOMM-style anchor correction does not raise agreement. SR stays within noise for both (0.722 with recomputation against 0.708 without), so we keep no correction as the default. Because both corrections run on the admission layer, a team that needs higher agreement can enable recomputation and still use less planner time than cached re-perception.

G3. End-to-end cost (ESeG, RQDi). We added a per-step cost breakdown and a timeline of one step (App. E.4, Table 12 and Fig. 6). Planner GPU time falls by 45%, almost all of it in regional encoding, because each changed room is encoded once at its owner instead of on every robot; sharing adds 0.21 s of serialization and link wait. A full step takes 8.75 s instead of 9.94 s, 12% less, and the whole difference comes from the planner channel. Robustness to packet loss, dropout, slow links and larger teams is in App. E.10–E.11.

G4. Navigation (RQDi, ujW6). We added paired bootstrap CIs and McNemar tests on the full splits (App. E.9, Table 16) and a joint-encoding row in Table 1. Communicating teammate rooms improves SR significantly on both HM3D and MP3D. Latent sharing does not differ significantly in SR from re-perception, which obtains the same rooms by re-encoding them on every robot, or from joint encoding, while it needs 45% less planner GPU time than re-perception. We report these differences as descriptive and do not claim equivalence; Sec. 4.3 was reworded accordingly.

Other revisions. Figure 1 is redrawn in four panels without equations, and the detailed version is Fig. 7 in the appendix (ujW6). Sec. 4.1 now states how the patch selector is seeded (ESeG). Appendix E also adds a second planner family, a matched real-robot comparison, and a stratified analysis of where independent construction disagrees with joint encoding (RQDi).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.