Environment-Specific Skill Transfer for Decentralized Multi-Robot Navigation via Hybrid RRT and Behavior Cloning in Grid-Based Industrial Environments

1. Introduction

Mobile robots must reach their goals while avoiding collisions with obstacles [1,2]. In structured industrial settings—automated warehouses, in particular—fleets of such robots must additionally avoid collisions with one another [3]. Operating such fleets in a decentralized way—each robot deciding from local information, without a central coordinator and no direct inter-robot communication [4]—improves robustness and scalability, but makes coordination harder; in dense decentralized fleets, the dominant failure mode is deadlock and collision [5].

Two families of methods dominate grid navigation. Sampling-based planners such as RRT explore the configuration space and return feasible paths [6], but in dynamic, multi-robot settings, they incur frequent, costly replanning. Learning-based policies such as Behavior Cloning (BC) give fast, low-latency reactive control by imitating expert demonstrations, but degrade over long horizons and when the deployment environment diverges from the training data [7]. A hybrid framework that uses a pre-computed RRT route library together with a BC local policy [8]—reusing well-tested paths while reacting locally—can capture the strengths of both.

We study exactly such a framework and ask a question central to its practical use: when does the learned navigation transfer to a new environment, and what governs its quality? Our answer, obtained from a fully reproducible re-implementation that reuses the original trained network, RRT planner and route data verbatim, is that the decisive factor is the match between the route library and the deployment map. A library generated on one map and deployed unchanged on another leaves robots colliding with the new obstacles; an environment-adapted library transfers the skill and sharply reduces both collisions and task failures. We also compare against an online RRT baseline, clarifying the computational trade-off that motivates route reuse, and we evaluate—across repeated seeded trials—a lightweight add-on that needs no direct inter-robot messaging: collision-history sharing, proposed as future work in the framework’s originating study—an earlier unpublished graduate thesis by the first author, provided as supplementary material—which we re-implement faithfully here.

Our contributions are:

• A faithful, deterministic, seeded re-implementation of a hybrid RRT + Behavior Cloning decentralized navigation framework that reuses the original trained BC network, RRT planner, and route datasets, with the non-scalable multiprocessing prototype replaced by a reproducible single-process scheduler (code and raw results provided with the submission).
• A quantification of environment-specific skill transfer: an environment-adapted route library cuts collisions by 37–85% (Mann–Whitney U on per-episode collision counts, all $p<{10}^{-5}$) and task failures by 43–69% relative to a Map2-naive library across five fleet sizes (2, 4, 6, 8, 10 robots), recovering most of the navigation quality of an online RRT baseline at a fraction of its planning cost.
• A repeated-seed evaluation of collision-history sharing—indirect coordination through a shared map, with no direct messaging—within the full framework, finding only a limited benefit (full participation: a nominally significant 13% fewer collisions on Map1, $p=0.023$, which does not survive Holm correction; selective participation and a second layout: not significant). This corrects the originating thesis’s preliminary finding—a near-halving of collisions inferred from a single unseeded run—and shows that the effect is undetectable at low task throughput, where too few tasks accumulate to populate the shared map; we document this regime explicitly.
• A transparent, reproducible methodology in which every figure and number regenerates from the provided code and raw results, including the route-filtering and throughput conditions that determine whether each effect appears.

2. Related Work

Decentralized multi-robot navigation. Decentralized schemes avoid the single point of failure of centralized coordinators; approaches include cooperative reinforcement learning with a shared policy and inter-robot information exchange [3] and multi-agent RL more broadly [9], control-barrier functions [10,11], optimization-based trajectory planning [12], and swarm-intelligence approaches (reviewed for multi-UAV systems in [13]). Coping with deadlock and collision in dense fleets remains a persistent difficulty, including for decentralized aerial swarms [5]. Planning and learning. A* and sampling-based planners (RRT/RRT*) underpin robot path planning [6,14,15,16]; Behavior Cloning learns reactive policies from expert demonstrations [8,17,18,19,20,21], with well-known covariate-shift limits when the deployment distribution differs from the demonstrations [7]. Hybrid planner–policy methods combine a model-based planner with a learned model that guides it [22]; the framework we reuse couples an RRT expert, a BC policy, and route reuse, and—unlike hybrids that use BC only to smooth or refine planner paths—uses BC for decentralized reactive control and online RRT only for connecting segments. Skill transfer and adaptation. Transferring a learned policy to a new deployment environment—for example, from simulation to a real robot—is a core challenge for imitation-learning methods [23]; performance hinges on alignment between training and deployment distributions [7]. We give a concrete grid-navigation instance: adapting the expert route library to the deployment map restores performance lost to environment mismatch. Experience sharing. Multi-agent policies can be improved by modeling other agents’ behaviors and interactions [24,25], by training against diverse partner populations [26], and by leveraging human experience [27]; we study a minimal instance that uses no direct messaging—only a shared collision-frequency map—and evaluate it across repeated seeded trials.

3. Materials and Methods

All components are implemented in a deterministic, seeded simulator provided with the paper (manuscript/code/reproducible/); every result regenerates from the provided code, with reproduction instructions provided in the public repository. The simulator reuses the original implementation verbatim—the trained BC network (trained_model_NN.pth), the RRT planner, the offline route datasets and the per-step navigation logic—and replaces only the original multiprocessing / shared-memory harness, which did not scale, with a single-process round-robin scheduler so that every episode is reproducible from its seed.

3.1. Environment and Metrics

N robots navigate a $50\times 50$ occupancy grid in one of two layouts (Map1, Map2; Figure 1); obstacles are inflated by one cell to account for the robot footprint. The base navigation is fully decentralized: each robot acts on local observations only, with no shared state and no inter-robot communication. The optional collision-history sharing of Section 3.4 is the single exception—it introduces one shared data structure (a global collision-frequency map) through which a subset of robots coordinate indirectly, in a stigmergy-style manner, without exchanging messages; we evaluate it separately as an optional add-on rather than as part of the base framework. Over a fixed step budget, a task is a robot reaching its goal, after which a new random start/goal pair is drawn; tasks completed measures throughput. A collision is a predicted blocked-move event—the robot’s three-step look-ahead lands in a cell occupied by a static obstacle or by another robot—counted per event, matching the originating study’s definition (interactions with obstacles or other agents), not a physical contact. A task that cannot make progress within a step cap is counted as a failure; the failure rate is the number of failed tasks divided by the total number of task attempts (completed plus failed). Because a fixed step budget yields different numbers of completed tasks across conditions, we report collisions both absolutely and per completed task, the workload-normalized metric.

3.2. Hybrid RRT + Behavior Cloning Framework

An offline RRT expert generates a library of collision-free routes on a map. At run time each robot (i) selects, from the library, routes whose bounding box brings it toward its goal and that are locally obstacle-free (the Get_best_routes filter); (ii) drives toward the selected route under the trained BC network, which maps the robot’s position, a target waypoint on that route, and a $5\times 5$ local occupancy window to an incremental move—so the chosen route enters the policy through its target-waypoint input; and (iii) reconnects with a bounded online RRT segment toward the goal in two cases (Algorithm 1): as a fallback when no suitable library route is available (the nearest is too far to reach directly), and—when a three-step look-ahead along the chosen route predicts a blocked cell—probabilistically, logging the event and reconnecting with a probability that decreases as the task nears completion (more readily early in a task than near the goal). The BC network is a 29-input multilayer perceptron with hidden layers 256–256–64 (2 position $+2$ target-waypoint $+25$ occupancy inputs). We use the original trained weights and RRT/route code without modification. Figure 2 summarizes the offline and deployment phases, the skill-transfer test condition, and the optional collision-history-sharing add-on; Algorithm 1 states the per-robot run-time decision step, and Table 1 lists the implementation settings, including the online-RRT iteration cap. In Algorithm 1, robots interact only through the shared map H: every robot writes its own collisions to H, while only the sharing subset (a fraction $q_{\mathrm{share}}$) reads the aggregate to bias route choice—there is no direct robot-to-robot messaging. The routine $OnlineRRT(x,g)$ plans a fresh collision-free segment from x toward goal g, bounded by that cap.

Algorithm 1:Per-robot decision step, run independently by each robot i on every scheduler tick. A predicted blocked-move is a counted event (Section 3.1), not a physical crash, and does not by itself halt the robot.

Require:  map M, route library R, BC policy ${\pi }_{\mathrm{BC}}$, shared map H, sharing flag $z_i$, robot state $x_i$, goal $g_i$, counters $c_i$ (steps) and $h_i$ (collisions) 1: $C\leftarrow \mathtt{Get}\_\mathtt{best}\_\mathtt{routes}(R,x_i,g_i,M)$ 2: if$z_i$and$C\ne \varnothing$then 3:     $r^{★}\leftarrow arg{min}_{r\in C}{\sum }_{c\in r}H\left[c\right]$▹ sharing robots prefer low-H routes 4: else if$C\ne \varnothing$then 5:     $r^{★}\leftarrow$ route in C nearest $x_i$ 6: else 7:     $r^{★}\leftarrow$ current route if still valid, else $OnlineRRT(x_i,g_i)$▹ nearest route too far / none available 8: end if 9: $w\leftarrow$ next target waypoint on $r^{★}$ 10: $a\leftarrow {\pi }_{\mathrm{BC}}(x_i,w,W_{5\times 5})$▹ BC drives toward w 11: if three-step look-ahead along $r^{★}$ predicts a blocked cell (obstacle or robot) then 12:     $\mathit{collisions}\leftarrow \mathit{collisions}+1$; record cell in $h_i$▹ counted event, not a crash 13:     with prob. $1-{\rho }_i$: $r^{★}\leftarrow OnlineRRT(x_i,g_i)$; recompute $w,a$▹${\rho }_i$: fraction of $r^{★}$ done 14: end if 15: $x_i\leftarrow$ advance by a along $r^{★}$; $c_i\leftarrow c_i+1$ 16: if$x_i=g_i$then▹ task complete 17:     $H\leftarrow H+h_i$; register task; resample; reset $c_i,h_i$ 18: else if$c_i>$ step cap then 19:     register failure; resample; reset $c_i,h_i$ 20: end if

3.3. Route Libraries and Skill Transfer

The framework’s prior knowledge lives in its route library. We compare two libraries in the Map2 deployment environment: a Map2-naive library (the “original” dataset, generated by the RRT expert on Map1) and a Map2-adapted library (the “alternative” dataset, whose routes were shaped by Map2’s obstacle configuration). Following the original pipeline, each library is filtered for obstacle-free routes against the map on which it was generated (Map1 for the original library, Map2 for the adapted one) and then deployed on Map2; the Map2-naive library therefore retains routes that intersect Map2 obstacles, which is precisely the environment-mismatch the adapted library is meant to overcome. The two filtering stages are distinct: this offline filter is applied once against the generation map, whereas the run-time Get_best_routes filter (Algorithm 1) only rejects routes blocked in the robot’s immediate local occupancy window (other robots and nearby cells). A Map1-generated route that crosses a Map2 obstacle outside that local window therefore survives both filters and stays active, so its three-step look-ahead eventually predicts a blocked move—the collision the diagnostics below quantify. This setup isolates skill transfer: the BC network, planner, and deployment map are identical, and only the route library differs. Figure 3 makes the mismatch concrete: routes valid on Map1 (panel A) cross Map2’s obstacles when deployed unchanged (panel B), and panels C–D illustrate the deployment consequence on two examples: a robot following a naive Map1 route reaches a blocked contact where the route would enter a Map2 obstacle, so online RRT must plan a fresh collision-free continuation to the goal—the run-time replanning that the static mismatch forces. Routes in panels C–D are shown after collision-checked simplification for display: every plotted segment is validated against the Map2 configuration-space obstacle, so simplification removes raw-planner jitter without moving a route into obstacle geometry. Across the entire library, $8.1\%$ of the Map2-naive library’s route cells—spanning $58\%$ of its routes—fall inside Map2 obstacles. The Map2-adapted library has no such overlap by construction (its routes are generated by running RRT on Map2 directly); whether this static gap translates to a run-time benefit is the subject of Section 4 (Figure 4 and Figure 5).

Table 2 quantifies the two libraries. They contain a comparable number of routes (3543 vs 3592 raw; 3304 vs 3256 after source-map filtering, within about $2\%$), so the Map2-adapted library is not simply larger than the Map2-naive one; its routes are modestly longer (median 33 vs 37 cells) and cover somewhat more free space (1207 vs 1363 unique cells). These differences are small relative to the non-trivial one: the Map2-naive library leaves $8.1\%$ of its route cells, spanning $58\%$ of its routes, inside Map2 obstacles, which is the static gap that drives the run-time collision difference reported in Section 4.

3.4. Collision-History Sharing

As a lightweight add-on that needs no direct robot-to-robot message passing (proposed as future work in the originating study), a global per-cell map H accumulates the collisions logged during completed tasks: coordination, when enabled, is indirect—through this shared map rather than through messages exchanged between robots. The robots in a randomly chosen subset—a fraction $q_{\mathrm{share}}$, fixed per episode—bias their route selection toward rarely-collided cells, selecting, among valid candidate routes, the one that minimizes the summed collision history ${\sum }_{c\in r}H\left[c\right]$ along its cells, while the rest plan normally. $q_{\mathrm{share}}=0$ is no sharing, $0<q_{\mathrm{share}}<1$ selective, $q_{\mathrm{share}}=1$ full sharing. Every robot writes its own logged collisions into H upon completing a task, while only the sharing subset reads the aggregate; no robot exchanges messages with another. Collision records from tasks that fail (exceed the per-task step cap) are discarded with the task rather than added to H, so H reflects the collision history of completed tasks only. Because H accrues only as tasks complete, the mechanism can act only once enough collision history has been observed; we therefore run these episodes to a high task throughput (2000 scheduler steps, ≈245 completed tasks at five robots).

3.5. Experimental Design

With 15 seeds per condition we run six experiments (Table 3): (i) a skill-transfer experiment on Map2 comparing the Map2-naive and Map2-adapted libraries across fleet sizes $N\in \{2,4,6,8,10\}$; (ii) an online RRT baseline over the same fleet sizes; (iii) a collision-history-sharing ablation ($q_{\mathrm{share}}\in \{0,0.6,1.0\}$ at five robots) on both maps; (iv) an access-fraction sweep ($q_{\mathrm{share}}\in \{0,0.2,0.4,0.6,0.8,1.0\}$); (v) a sharing scalability sweep ($N\in \{2,4,6,8,10\}$, with and without selective sharing); and (vi) a throughput-dependence sweep (Map1, five robots, $q_{\mathrm{share}}\in \{0,0.6,1.0\}$ over episode lengths from 300 to 2000 steps). Each of the main experiments runs for 2000 scheduler steps—about 245 completed tasks at five robots—so that the shared collision database fills before collision-rate comparisons are made; the throughput sweep additionally varies the episode length to expose the short-horizon regime in which the database stays nearly empty. We report mean ± SD, Mann–Whitney U tests (one-sided, where directional), and Spearman trends. Scripts (sim_rrtbc.py, sim_rrt_online.py, scenario.py, run_experiments_rrtbc.py, run_experiments_rrt_online.py, analyze_rrtbc.py, make_heatmaps_rrtbc.py) and raw results are provided with the submission.

4. Results

The figures separate three effects. Figure 4 measures the result of route-library adaptation; Figure 5Figure 6 diagnose the failure mechanism by locating and classifying collisions; and Figure 7 quantifies the computational trade-off against online RRT. The final Figure 8, Figure 9 and Figure 10 evaluate the optional collision-history-sharing add-on.

4.1. Environment-Adapted Route Libraries Transfer the Navigation Skill

Deploying the Map2-adapted library instead of the Map2-naive library on Map2 sharply improves navigation (Figure 4). At four robots, the Map2-naive library incurs $703\pm 61$ collisions and a $0.23$ task-failure rate, while the Map2-adapted library incurs $206\pm 36$ collisions and a $0.09$ failure rate—a $71\%$ reduction in collisions (Mann–Whitney U on per-episode collision counts, $p<{10}^{-5}$) and a $62\%$ reduction in failures (the significance test is on collisions; failure rates are reported descriptively; full per-fleet-size numbers, bootstrap CIs and effect sizes in Table 4). The reduction is largest where obstacle mismatch dominates ($85\%$ at two robots) and remains substantial as agent–agent interference grows ($54\%$ at six, $37\%$ at ten robots); the adapted library’s collision rate (per completed task) and failure rate stay below the naive library’s at every fleet size $N\in \{2,4,6,8,10\}$ tested, all with $p<{10}^{-5}$. This is the environment-specific skill-transfer effect: the BC network and planner are unchanged, so the gain comes entirely from aligning the route library with the deployment geometry. The collision heatmaps (Figure 5) make the mechanism visible—the Map2-naive library produces collisions inside Map2’s obstacle regions (routes inherited from Map1 cut through walls that did not exist there), whereas the Map2-adapted library confines residual collisions to natural high-traffic corridors.

4.2. Throughput, Collision Composition, and Planning Cost Across Fleet Density

Throughput (tasks completed within the fixed budget) increases with fleet size on Map2: the completed-task counts in Table 4 rise monotonically with N for every method. The collision rate per completed task also increases gradually with density as path intersections become more frequent, reproducing the qualitative scalability behavior reported in the originating thesis; the same throughput trend appears in the Map1 scalability sweep (Figure 8, left; Spearman $\rho =+0.98$ between fleet size and tasks, $p<0.001$). Decomposing collisions by type (Figure 6) shows why: the Map2-naive library carries a large static-obstacle collision component—roughly $2.7$–$2.9$ collisions per completed task at every fleet size (its routes cross Map2 walls)—that is essentially absent from the Map2-adapted hybrid and from online RRT, both of which plan around the static obstacles and so incur no obstacle collisions. This map-mismatch component dominates the naive library’s collisions at small fleets and persists undiminished as N grows, even as robot–robot congestion—the residual common to all three methods—rises with density and overtakes it at the largest fleets. Figure 6 shows $N=4$ and $N=10$; the complete breakdown for all fleet sizes is given in Table 5. This separates the map-mismatch failure mode (curable by adapting the library and roughly constant in N) from the remaining density-driven congestion.

Compared to the online RRT baseline (Figure 4), online RRT achieves the lowest collision and failure rates—unsurprisingly, as it computes a fresh path toward each goal—but at a steep and growing computational cost (Figure 7, Table 6): its search had to be bounded (capped RRT iterations) merely to remain tractable at higher densities, and each episode was markedly slower than the route-reusing hybrid, which invokes the planner only to reconnect. The environment-adapted hybrid closes most of the gap to online RRT (e.g. $1.08$ vs. $0.82$ collisions per task at four robots, $3.99$ vs. $2.69$ at ten) while avoiding per-step replanning—the efficiency trade-off that motivates the hybrid design. A faithful comparison of throughput under a fixed time budget—in which online RRT’s planning cost would lower its completed-task count (the metric used by the originating study)—is left to future work.

4.3. Collision-History Sharing Gives Only a Limited Benefit

Evaluated at a high task throughput (2000 scheduler steps, ≈245 completed tasks at five robots), collision-history sharing yields only a limited benefit within the full framework (Table 7). In that table, the Change column and the significance tests refer to the mean per-episode collision count (the quantity tested), while Coll./task is the corresponding workload-normalized rate, which changes by a similar amount; p is the one-sided Mann–Whitney U test against no sharing, $p_{\mathrm{Holm}}$ applies a Holm–Bonferroni correction across the four ablation comparisons, and the Significant column is judged after correction. On Map1 at five robots, the mean per-episode collision count falls from $362\pm 66$ (no sharing) to $346\pm 62$ under selective access ($q_{\mathrm{share}}=0.6$) and $316\pm 54$ under full access: full sharing gives a modest, nominally significant $13\%$ reduction in collision count (Mann–Whitney U on these per-episode counts, one-sided $p=0.023$); the corresponding collisions-per-completed-task rate falls from $1.42$ to $1.29$ (about $9\%$, the slightly smaller figure reflecting the near-constant task count). The $4\%$ reduction under selective access is not significant ($p=0.32$). The sharing analysis comprises four comparisons (two maps × two participation levels), which we treat as a single family and report both nominally and with a Holm correction (Table 7). Only the Map1 full-participation comparison is even nominally significant, and its nominal $p=0.023$ does not survive the family-wise correction (Holm-adjusted $p=0.09$); therefore, we read the sharing benefit as limited and layout-dependent rather than robustly established. We find no evidence that full sharing increases collisions relative to selective access (one-sided $p=0.94$ in that direction), and no monotonic dose–response: the access-fraction sweep is essentially flat (Figure 9; Spearman $\rho =-0.09$, $p=0.42$). On Map2, the effect is still smaller and not significant (full and selective $\approx 2\%$; $p=0.37$ and $0.43$, respectively). The framework’s three-step look-ahead and environment-matched routes already keep collisions manageable, leaving little persistent congestion for the shared map to act on—so the near-halving reported from the originating study’s single preliminary run does not reproduce here. Crucially, this small benefit is undetectable at low task throughput (Figure 10): because the shared map H fills only as tasks complete (panel A), short episodes leave it nearly empty, and the collision-rate gap between full and no sharing is statistically indistinguishable from zero (panels B,C). In this regime, we cannot separate two compatible explanations—the mechanism has little accumulated history to act on, and few completed tasks give the test little power to detect such a small effect—so we report only that sharing has no measurable effect below roughly 1000 scheduler steps (the horizon at which the bootstrap interval first excludes zero in Figure 10), without claiming that the underlying effect is exactly zero.

5. Discussion

5.1. What Governs Navigation Quality

The dominant factor in this decentralized framework is the alignment between the route library and the deployment environment. Because the BC policy imitates expert routes, its behavior is only as good as the routes it can draw on: a library generated for a different map carries that map’s assumptions—including paths through cells that are obstacles in the new environment—and the robots inherit those mistakes. Adapting the library to the deployment map restores performance, transferring the learned navigation skill with the planner and policy unchanged. This is a concrete, measurable instance of the covariate-shift limitation of imitation learning [7], and of its remedy by distribution alignment.

This sensitivity to the gap between training and deployment conditions is not specific to our setup. Learning-based navigation is known to be sensitive to distribution drift between the conditions a policy is trained on and those it meets at deployment [28], and methods that learn purely from demonstration similarly falter once a robot must act in cluttered configurations outside the demonstrated range [29]. Our route-library result is the grid-navigation instance of the same phenomenon: the policy is only as good as the offline routes it imitates, so realigning those routes to the deployment map is what restores performance. A complementary route to robustness, pursued mainly in manipulation, is to distill a large corpus of sampling-planner solutions into a single reactive policy that generalizes across scene layouts [30]; our results indicate that, for a fixed policy, the cheaper lever of regenerating the route library on the target map is already decisive.

Behavior Cloning is attractive here precisely because it is the simplest form of imitation learning—a supervised mapping from observations to actions that needs neither a reward function nor a dynamics model [31,32]. That simplicity is also its weakness: with no mechanism to correct for states unseen in the demonstrations, environment-specific assumptions are baked into the policy, which is why demonstration- or planner-derived priors are frequently paired with additional components to improve generalization [33]. Our hybrid retains BC for fast reactive control and delegates only the harder, environment-specific reconnection to the planner, which localizes the covariate-shift problem to the route library.

5.2. The Role of Collision-History Sharing

Collision-history sharing is a low-cost way to steer robots away from cells that have repeatedly caused collisions, requiring no direct inter-robot messaging. Evaluated within the full hybrid framework and at a realistic task throughput, its benefit is limited: full participation yields a small, nominally significant reduction on Map1 (13%, not surviving Holm correction across the sharing comparisons), while selective participation and a second layout show no significant change, and there is no clear dose–response. The mechanism is most useful where the base navigation leaves persistent congestion; here the framework’s three-step look-ahead and environment-matched routes already keep collisions manageable, so little remains for the shared map to remove—and the near-halving reported from the originating study’s single preliminary run does not reproduce over repeated, seeded trials. The effect also depends on the shared map having accumulated enough history: at low throughput, the database stays nearly empty, and no effect is detectable, so reporting this throughput dependence is essential to evaluating the mechanism fairly.

Collision-history sharing is an indirect, stigmergy-like form of coordination: robots influence one another only through a shared spatial record of where collisions recur, never through direct messages. This contrasts with the bulk of decentralized multi-robot navigation, where coordination is achieved through explicit communication—for example, decentralized multi-agent RRT in which agents pass a planning token and exchange planned trajectories to guarantee mutual collision avoidance [34]—and with classical reactive schemes that must resolve static-obstacle and inter-robot collisions at once and are prone to local-minima deadlock [35]. The appeal of a message-free shared signal is its near-zero coordination cost; our results temper that appeal by showing that, once the base navigation is strong, the residual congestion that such a signal can remove is small.

5.3. Generality and Relation to Planning–Learning Hybrids

The framework is within a broad and active effort to combine classical planning with learning, spanning sampling-based planners, supervised policies, and reinforcement learning [36]. Sampling-based planners such as RRT remain a workhorse for mobile robot path planning, and their cost is dominated by collision checking [37] and by parameters such as step size and iteration budget [38]; pairing them with learned components is increasingly common in industrial mobile robotics, for example, combining an RRT global planner with learned perception inside an ROS navigation stack [39]. Other hybrids augment a reinforcement-learning agent’s action space with a motion planner [40], or pair a demonstration-learned task model with a sampling-based planner so that a robot reproduces demonstrated behavior while still avoiding obstacles absent from the demonstrations [41]. Against this backdrop our contribution is deliberately narrow: we reuse the original planner and policy verbatim and isolate the effect of route-library provenance, which is what lets the skill-transfer effect be attributed cleanly rather than confounded with architectural changes.

5.4. Limitations

The study is in grid-based simulation; real deployments add sensing noise, continuous dynamics, and safety constraints. Behavior-cloning policies in particular carry a well-documented sim-to-real gap, so a simulation-trained policy needs physical validation before its numbers can be expected to transfer [42]. Absolute counts depend on modeling choices (the collision metric counts predicted blocked-move events; the shared map accumulates without decay; the access subset is fixed per episode), so the robust claims are the large skill-transfer effects and their directional consistency across seeds—not the precise magnitudes, and not the marginal collision-history-sharing effect, which does not survive multiple-comparison correction.

5.5. Future Work

Several directions follow directly from these limitations. The environment-adapted route library here was produced offline; because offline plans are computed once and grow stale as the scene changes [43], generating such adaptation online and at scale is a natural next step. Further directions include comparing against optimal multi-robot solvers (e.g. conflict-based search) and continuous-space collision-avoidance methods (e.g. ORCA), adding a decaying shared collision-history map, and validating the framework on physical robots.

6. Conclusions

We presented a faithful, fully reproducible re-implementation of a hybrid RRT + Behavior Cloning framework for decentralized multi-robot navigation in grid-based industrial environments, reusing the original trained network, planner and route data. Our central finding is that navigation quality is governed by the match between the expert route library and the deployment environment: an environment-adapted library transfers the learned skill and cuts collisions by 37–85% and task failures by 43–69% relative to a Map2-naive library across five fleet sizes (2, 4, 6, 8, 10 robots), recovering most of the collision performance of an online RRT baseline at a fraction of its planning cost. A collision-history-sharing add-on that needs no direct messaging, evaluated across repeated seeded trials, gives only a limited benefit—a nominally significant 13% collision reduction under full participation on Map1 (not surviving multiple-comparison correction), but no significant change under selective participation or on a second layout—so the near-halving suggested by the originating study’s preliminary single run does not reproduce within the full framework, and the effect is undetectable at low task throughput. By providing the deterministic code and raw results with this submission—and by documenting the throughput and route-filtering conditions under which each effect appears—we aim to make these results directly reproducible and the framework a reliable basis for further work.