Industry Research

Appearance

Multi-Agent Neural and Gaussian SLAM ​

Related docs: Distributed Multi-Robot PGO · COVINS / COVINS-G · Kimera-Multi · CO-SLAM / ESLAM · Gaussian SLAM / MonoGS · SplaTAM · Splat-SLAM · GigaSLAM · MASt3R-SLAM · DROID-SLAM · NeRF-SLAM · D2-SLAM · Loop Closure and Place Recognition · Learned LiDAR Place Recognition · Aggregated Map Semantic Segmentation · Feed-Forward 3D Reconstruction and Splatting · Lie Groups — SE(3), SO(3), Jacobians

Last updated: 2026-05-24

What It Is ​

Multi-agent neural Gaussian SLAM is a family of SLAM systems in which N robots each run a local neural-implicit or 3D Gaussian Splatting (3DGS) front-end, then combine their per-robot submaps into a single globally consistent dense representation. There is no single canonical paper — the literature is distributed across concurrent research threads that appeared between NeurIPS 2023 and May 2026, each claiming "first" status along a different dimension. The survey (Nguyen et al., arXiv 2510.23988, October 2025) is the best taxonomy baseline for the pre-2026 collaborative-Gaussian literature, while CoMA-SLAM and MAGS-SLAM are newer 2026 branches that should be treated as frontier follow-ons.

This page covers the family as one research lane: CP-SLAM (first complete collaborative neural pipeline, NeurIPS 2023), MAGiC-SLAM (centralized 3DGS, CVPR 2025), MAC-Ego3D (consensus-based 3DGS, CVPR 2025), GRAND-SLAM (outdoor multi-agent 3DGS evaluation, RA-L 2025), MNE-SLAM (distributed peer-to-peer neural implicit, CVPR 2025), Coko-SLAM (bandwidth-reduction focus, arXiv April 2026), CoMA-SLAM (distributed 2D Gaussian surfels, AAAI 2026), and MAGS-SLAM (RGB-only multi-agent 3DGS, arXiv May 2026). Each addresses a distinct sub-problem. No single system yet solves metric scale, LiDAR-primary sensing, outdoor fleet scale, dynamic-scene filtering, bandwidth, and production integration together.

Research stage. Most systems operate on RGB-D indoor sequences; GRAND-SLAM adds outdoor Kimera-Multi evaluation, and MAGS-SLAM explores RGB-only operation. LiDAR-primary multi-agent neural/Gaussian SLAM does not exist as a published system as of May 2026. For multi-vehicle outdoor survey the production-grade choices remain classical multi-robot SLAM: Swarm-SLAM (RA-L 2024) or Kimera-Multi (T-RO 2022), both with LiDAR-capable front-ends.

Historical Context ​

Single-agent 3DGS-SLAM (SplaTAM, GS-SLAM, MonoGS — all CVPR 2024) demonstrated that an explicit Gaussian map can serve as the online reconstruction target in a tracking-and-mapping loop. Those first-wave systems were limited to room-scale, loop-closure-free, single-camera operation. The multi-agent extension asks a harder question: can N independently operating robots merge their Gaussian submaps into one coherent global scene?

The attempt at an answer arrived quickly. CP-SLAM (NeurIPS 2023) predated the first-wave single-agent systems and established the baseline pipeline with a neural-point (not 3DGS) representation. By CVPR 2025, MAGiC-SLAM and MAC-Ego3D covered multi-agent 3DGS, while MNE-SLAM covered distributed neural-implicit collaborative SLAM. GRAND-SLAM (RA-L 2025) then added outdoor evaluation on Kimera-Multi. Coko-SLAM (April 2026) followed with an explicit bandwidth-budget treatment, CoMA-SLAM (AAAI 2026) added distributed 2D Gaussian surfels and distributed keyframe optimization, and MAGS-SLAM (May 2026) explored RGB-only multi-agent 3DGS.

For the 3DGS rendering model underlying all of these see Feed-Forward 3D Reconstruction and Splatting and the single-agent systems GS-SLAM and MonoGS and GigaSLAM. For the Lie-algebra mathematics used in pose-graph optimization see Lie Groups — SE(3), SO(3), Jacobians.

Core Technical Idea ​

Multiple robots simultaneously build local neural or Gaussian maps. The goal is a single globally consistent dense map suitable for novel-view synthesis, inspection, and digital-twin construction. Four central challenges govern every design decision in this family.

Challenge 1 — Communication bandwidth. A 3DGS submap for a single room contains millions of Gaussians, each described by a 3D mean, a 6-parameter covariance, an opacity scalar, and spherical-harmonic color coefficients. Raw submap size: 50–100 MB per room. At multiple submaps per robot per session, naive transmission saturates any WiFi link and is impractical even on wired networks for large fleets. Neural-implicit (NeRF / hash-grid) representations are even heavier: the per-scene MLP or feature-grid block is not transmissible in real time.

Challenge 2 — Cross-robot map alignment. Until two robots find a relative SE(3) transform T_{ij} connecting their local coordinate frames, their submaps cannot be fused. This "rendezvous detection" or "inter-robot loop closure" problem requires detecting when two robots have observed the same region. In Gaussian SLAM the map is a rendering-optimized object, not a feature-sparse graph, so detection must operate on rendered images or extracted point clouds rather than directly on Gaussian parameters.

Challenge 3 — Map fusion under representation overlap. When two robots have independently reconstructed the same corridor, their Gaussians representing it have different densities, different initializations, and different SH coefficients. Naive concatenation creates double-density artifacts and inflates memory. Reconciliation requires a visibility or depth-consistency test to identify and prune co-located redundant Gaussians.

Challenge 4 — Global pose-graph consistency. After inter-robot loop closures are detected, all submap poses must be corrected jointly via distributed or centralized pose-graph optimization (PGO). Rigidly transforming a Gaussian submap after PGO — updating means and covariances — corrects geometry but does not correct the SH color coefficients that were optimized in the old frame. Novel-view synthesis quality degrades after large corrections and may require a fine-tuning pass.

Family Survey ​

CP-SLAM — NeurIPS 2023 (Neural Point, not 3DGS) ​

Citation: Jiarui Hu, Mao Mao, Hujun Bao, Guofeng Zhang, Zhaopeng Cui. "CP-SLAM: Collaborative Neural Point-based SLAM System." NeurIPS 2023. Links: arXiv 2311.08013 · https://zju3dv.github.io/cp-slam/

Representation: Neural points — each 3D point carries a learnable feature vector anchored to a keyframe. Differentiable ray marching over the point field renders depth and color. This is not 3DGS and not a NeRF hash-grid; it is a distinct point-anchored neural feature representation.

Architecture: Each robot runs an odometry front-end on RGB-D input, producing a local submap (neural point cloud + keyframe poses). Inter-robot loop detection uses NetVLAD global descriptors; matched keyframes trigger submap fusion. The strategy is distributed-to-centralized: agents compute independently, then a central server fuses submaps by averaging shared MLPs (a federated learning step) and fine-tuning across all keyframes. Global refinement is a keyframe-centric bundle-adjustment-style PGO.

Measured performance:

  • Disk per submap: ~54 MB; peak GPU per agent: ~9.7 GiB
  • Mapping time per frame: ~16.95 s — far below real-time
  • ReplicaMultiagent (2 agents) ATE RMSE: ~0.65 cm; PSNR: ~22.71 dB; SSIM: ~0.69

Significance: First complete multi-agent neural implicit SLAM with all four modules (odometry, loop detection, submap fusion, global refinement). Establishes the baseline against which all subsequent work is measured.

Limitations: Far below real-time, high GPU memory, centralized server required, no LiDAR support.

MAGiC-SLAM — CVPR 2025 (3DGS, centralized) ​

Citation: Vladimir Yugay, Theo Gevers, Martin R. Oswald. "MAGiC-SLAM: Multi-Agent Gaussian Globally Consistent SLAM." CVPR 2025. Links: arXiv 2411.16785 · https://github.com/VladimirYugay/MAGiC-SLAM

Representation: 3D Gaussian Splatting with rigidly deformable Gaussian submaps. The first complete 3DGS multi-agent SLAM system.

Architecture:

  • Per-agent front-end: local tracking + mapping on RGB-D stream; a new submap is triggered every 50 frames (Replica) or 20 frames (Aria).
  • Communication trigger: on submap creation, the agent extracts DINOv2 features from the submap's first keyframe and transmits them to a central server along with the submap Gaussians. Critically, only Gaussians invisible in the current camera frustum (opacity near zero) are dispatched, reducing bandwidth.
  • Central server: receives features → retrieves top-k nearest-neighbor submaps via DINOv2 cosine similarity → coarse-to-fine registration using FPFH features + ICP on rendered / depth point clouds → PGO with G2O (Gauss-Newton), minimizing a weighted sum of squared SE(3) residuals.
  • Map fusion: corrected poses are applied as rigid transforms to Gaussian parameters (means and covariances), followed by a 3 000-iteration fine-tuning pass to remove double-density artifacts.

Measured performance:

  • Disk per submap: ~54 MB; GPU per agent: ~1.12 GiB (vs CP-SLAM 9.7 GiB — 8.7× lower)
  • Mapping time: ~0.71 s/frame (vs CP-SLAM 16.95 s/frame — 24× faster)
  • ReplicaMultiagent (2 agents): ATE RMSE 0.27 cm (vs CP-SLAM 0.65 cm); PSNR 34.26 dB (vs 22.71 dB); SSIM 0.97 (vs 0.69); Depth L1 1.30 cm (vs 22.98 cm)
  • AriaMultiagent (3 agents, real-world): ATE RMSE 0.90 cm; PSNR 22.61 dB

Failure modes acknowledged: Sub-1 FPS tracking (not real-time); no dynamic-object handling; loop detection fails in textureless or repetitive environments; centralized server is single point of failure; scalability tested to 3 agents only; loop closure requires a reasonable initial relative pose estimate — Coko-SLAM (2026) explicitly addresses this gap.

MAC-Ego3D — CVPR 2025 (3DGS, distributed consensus) ​

Citation: Xiaohao Xu, Feng Xue, Shibo Zhao, Yike Pan, Sebastian Scherer, Xiaonan Huang. "MAC-Ego3D: Multi-Agent Gaussian Consensus for Real-Time Collaborative Ego-Motion and Photorealistic 3D Reconstruction." CVPR 2025. Links: arXiv 2412.09723 · https://github.com/Xiaohao-Xu/MAC-Ego3D

Key distinction: Consensus-based rather than PGO-based. Agents exchange compact vectorized image embeddings at communication interval T_comm; similarity score s(v_i, v_j) = dot product; if s > tau = 0.8, loop closure is detected. Gaussian correspondence matching then solves for a rigid transform T that minimizes weighted Euclidean distance between Gaussian means (covariance-weighted), replacing the FPFH+ICP registration pipeline used by MAGiC-SLAM and GRAND-SLAM.

Intra-agent consistency: Local coherence enforced by Mahalanobis-distance pose alignment — each observed point Gaussian must be consistent with the nearest map Gaussian within a Mahalanobis distance derived from the map covariances.

Measured performance:

  • ReplicaMultiagent (2 agents): ATE RMSE 0.14 cm (vs CP-SLAM 1.23 cm); PSNR 40.04 dB (+10.71 dB vs CP-SLAM)
  • Speed: 15× faster than prior SOTA at the time of publication

Limitations: Tested on 2 agents, single room only; multi-room association not addressed; outdoor mapping not explored; memory overhead for Gaussian storage requires compression for deployment.

GRAND-SLAM — RA-L 2025 (3DGS, first outdoor multi-agent) ​

Citation: Annika Thomas, Aneesa Sonawalla, Alex Rose, Jonathan P. How. "GRAND-SLAM: Local Optimization for Globally Consistent Large-Scale Multi-Agent Gaussian SLAM." IEEE Robotics and Automation Letters, 2025. Links: arXiv 2506.18885

Significance: First multi-agent 3DGS SLAM achieving outdoor, large-scale global consistency. Benchmarked on the Kimera-Multi outdoor dataset — the same dataset used to evaluate classical multi-robot SLAM — giving a direct comparison against the state of the art in that family.

Architecture:

  • Submap initialization: a new submap is triggered when the pose exceeds a translation threshold d_max or rotation threshold theta_max relative to the submap origin. This bounds the active optimization area and enables scalability.
  • Tracking: two-stage per submap — coarse frame-to-frame hybrid color-depth odometry, followed by frame-to-model refinement via rendering-based optimization in local frame (avoids gradient imbalance at large distances from world origin). Gaussian parameters are frozen during tracking.
  • Loop closure (intra + inter robot): NetVLAD keyframe descriptors → top-k retrieval by cosine similarity with spatial baseline check → dense RGB-D registration (hybrid depth-color loss) → point-to-plane ICP → quality filter on fitness and inlier RMSE.
  • PGO: GTSAM Levenberg-Marquardt minimizing the SE(3) log-map norm of relative pose residuals weighted by edge information matrices (see Operator Mechanics section). After PGO, submaps are rigidly transformed to the global frame.

Measured performance:

  • ReplicaMultiagent: ATE RMSE 0.25 cm (comparable to MAGiC-SLAM 0.26 cm); PSNR 41.35 dB (vs MAGiC-SLAM 34.26 dB — +28%)
  • Kimera-Multi outdoor: ATE RMSE 4.99 m (vs MAGiC-SLAM 60.79 m — 91% lower; vs ORB-SLAM3 10.58 m — better); PSNR 27.44 dB (vs 15.88 dB); SSIM 0.97 (vs 0.50)

Limitations: Communication overhead is uncharacterized — the authors identify compression as future work. No LiDAR; relies on visual texture for loop closure. The 91% outdoor ATE improvement is the single largest performance gap reported in this literature, but the system is still RGB-D only.

MNE-SLAM — CVPR 2025 (Neural implicit, distributed peer-to-peer) ​

Citation: Tianchen Deng et al. "MNE-SLAM: Multi-Agent Neural SLAM for Mobile Robots." CVPR 2025, pp. 1485–1494. Links: CVF open access · https://github.com/dtc111111/MNESLAM

Representation: Neural implicit with two-scale parametric-coordinate encoding — avoids the cubic memory growth of voxel grids by encoding scene features at coarse and fine scales separately. Not 3DGS.

Architecture: Fully distributed, peer-to-peer communication only with no central server. Intra-to-inter loop closure: intra-robot loop closure first achieves local consistency per agent; inter-robot loops detected via matched keyframe features then trigger cross-agent submap alignment. Multi-submap fusion proceeds via online distillation in which knowledge is transferred between neural fields, avoiding naive parameter averaging.

Dataset contribution: Introduces the first real-world indoor neural SLAM (INS) dataset with ground-truth 3D mesh and continuous-time camera trajectory covering both single- and multi-agent scenarios at room-to-large-scale.

Significance: The only published paper in this family claiming fully peer-to-peer (no server) architecture. Important for deployments where a central server is impractical.

Follow-on — MCN-SLAM (arXiv June 2025): The same lead author published MCN-SLAM (arXiv 2506.18678) with a triplane-grid hybrid representation and a new Dense SLAM Dataset (DES). These are distinct papers; MCN-SLAM is a 2025 follow-on and remains preprint-only in this corpus until source artifacts mature.

Coko-SLAM — arXiv April 2026 (3DGS, bandwidth-first) ​

Citation: Monica M.Q. Li, Pierre-Yves Lajoie, Jialing Liu, Giovanni Beltrame. "Compact Keyframe-Optimized Multi-Agent Gaussian Splatting SLAM." arXiv 2604.00804, April 2026. Links: arXiv 2604.00804 · https://github.com/lemonci/coko-slam

Key contribution: The first system to treat bandwidth reduction as the primary design objective, formalizing Gaussian compaction as a constrained optimization problem. The GaussianSPA step uses a Lagrangian dual formulation: alternating optimization and sparsification via proximal operators, active from iteration 700–950 of 1 000 mapping iterations. Keyframe selection uses DINOv2-Small features with a minimum feature-distance threshold that replaces environment-specific heuristics.

Loop closure without initial pose estimate: Unlike MAGiC-SLAM, Coko-SLAM does not require an initial relative pose between robots. Two modes: rendered-depth (renders depth from Gaussians → point cloud → FPFH + RANSAC + ICP) and camera-depth (uses stored depth for additional Gaussian pruning of co-visible points).

Measured bandwidth (per-submap transmission):

DatasetCoko-SLAM (rendered-depth)MAGiC-SLAM
Replica Office-0~100 MB~2 050 MB
Aria Room0~85 MB~540 MB

Reduction: 85–95% versus MAGiC-SLAM.

Rendering quality (Replica): PSNR 26.66–39.29 dB; SSIM 0.906–0.991 (vs MAGiC-SLAM SSIM ~0.295 in configurations without initial poses, where MAGiC-SLAM degrades substantially).

Limitations: Rendered-depth registration degrades at low camera resolution (e.g., 512×512 Aria images); centralized server still required; depth rendering is a compute bottleneck.

CoMA-SLAM — AAAI 2026 (2D Gaussian Surfels, Distributed) ​

Citation: Lin Chen, Yongxin Su, Jvboxi Wang, Pengcheng Han, Zhenyu Xia, Shuhui Bu, Kun Li, Boni Hu, Shengqi Meng, Guangming Wang. "CoMA-SLAM: Collaborative Multi-Agent Gaussian SLAM with Geometric Consistency." AAAI 2026. Links: AAAI proceedings · https://ojs.aaai.org/index.php/AAAI/article/view/37283 · GitHub: https://github.com/npu-chenlin/CoMA-SLAM

Key distinction: CoMA-SLAM is the strongest source-mature 2026 refresh for this page because it moves the family away from a central server and toward distributed Gaussian map coordination. Its map representation uses 2D Gaussian surfels rather than volumetric 3D Gaussians, which improves geometry consistency for surface reconstruction and reduces the depth-ambiguity failure mode common in monocular or weak-depth Gaussian maps.

Architecture:

  • Per-agent front-end: each robot builds a local 2DGS map and trajectory estimate on the supported ReplicaMultiagent or AriaMultiagent-style inputs.
  • Loop closure: intra-agent and inter-agent loop closures provide the constraints needed to align local submaps across agents.
  • Optimization: distributed keyframe optimization and a submap-centric update propagate corrections without uploading all data to a central fusion server.
  • Repository maturity: the public repository includes setup instructions, requirements, dataset layout, configuration files for ReplicaMultiagent and AriaMultiagent, quick-start commands, and post-processing scripts. It has no tagged release as of this refresh, so treat it as research code rather than production software.

Reported evidence: The AAAI proceedings record reports better pose accuracy, rendering fidelity, and geometric consistency than prior multi-agent Gaussian methods, and states a 99.8% communication-bandwidth reduction compared with centralized approaches by avoiding transmission to a centralized server.

Limitations: CoMA-SLAM is still a camera/RGB-D Gaussian SLAM method, not a LiDAR-primary mapping stack. The public repository has one visible commit and no releases, so deployment claims should wait for independent reproduction, longer outdoor sequences, and sensor-hardware integration. It does not replace Kimera-Multi, Swarm-SLAM, FAST-LIO2, or KISS-SLAM for metric LiDAR map construction.

MAGS-SLAM — arXiv May 2026 (RGB-Only Multi-Agent 3DGS) ​

Citation: Zhihao Cao, Qi Shao, Shuhao Zhai, Jing Zhang, Anh Nguyen, Baoru Huang. "MAGS-SLAM: Monocular Multi-Agent Gaussian Splatting SLAM for Geometrically and Photometrically Consistent Reconstruction." arXiv 2605.10760, May 2026.

Key distinction: MAGS-SLAM targets the RGB-only case: multiple lightweight monocular agents collaboratively reconstruct a 3DGS scene without relying on RGB-D depth. That makes it relevant for low-power robot teams and camera-only inspection rigs, but it also reintroduces scale ambiguity, monocular depth uncertainty, and stronger dependence on photometric texture.

Corpus routing: Keep MAGS-SLAM inside this family page unless an official implementation, stable benchmark package, or repeated external adoption makes a separate atomic page worthwhile. It is useful for tracking the frontier, not for safety-critical metric map publication.

Operator Mechanics ​

Inter-Robot Rendezvous Detection ​

Agents detect spatial overlap via learned global descriptors. For DINOv2 or NetVLAD embeddings f_i and f_j:

s(i,j) = cosine(f_i, f_j) = (f_i · f_j) / (||f_i|| * ||f_j||)

A loop candidate is accepted if s > tau_sim and the spatial baseline ||t_i - t_j|| > delta_min. The spatial baseline check prevents false positives between nearby robots in the same region that already share a relative transform estimate.

SE(3) Alignment from Cross-Robot Keyframe Matches ​

Given point sets {p_k} from submap i and {q_k} from submap j (from ICP / FPFH+RANSAC correspondence):

T*_{ij} = argmin_{T in SE(3)}  sum_k  w_k * ||T p_k - q_k||^2

Closed-form via SVD on the weighted cross-covariance matrix W = sum_k w_k (p_k - p_bar)(q_k - q_bar)^T. Factor W = U S V^T, then R = V U^T and t = q_bar - R p_bar. This is the standard Procrustes / Umeyama alignment applied to 3D point sets. For the SE(3) Lie-algebra framing used in GTSAM-based PGO see Lie Groups — SE(3), SO(3), Jacobians.

Pose-Graph Optimization ​

PGO minimizes over all submap poses {T_i} in SE(3):

L_graph = sum_{(i,j) in E}  ||log(T_hat_{ij}^{-1} · T_i^{-1} · T_j)||^2_{Omega_{ij}}

where T_hat_{ij} is the measured relative transform from ICP/registration, Omega_{ij} is the information matrix (inverse covariance of measurement noise), and log(·) is the SE(3) logarithmic map yielding a 6-vector in R^6. GRAND-SLAM uses GTSAM Levenberg-Marquardt; MAGiC-SLAM uses G2O Gauss-Newton. See Distributed Multi-Robot PGO for the full treatment of distributed vs centralized PGO solvers used in classical multi-robot SLAM.

Gaussian Rigid Transform After PGO ​

Given pose correction T_i^c in SE(3) for submap i (rotation R_i^c, translation t_i^c):

mu_k     <-  R_i^c * mu_k + t_i^c
Sigma_k  <-  R_i^c * Sigma_k * (R_i^c)^T

Spherical harmonic color coefficients encode view-dependent appearance in the old coordinate frame and must be rotated separately (applying the Wigner D-matrix for SH rotation) or re-optimized in a fine-tuning pass. This is the primary reason post-PGO rendering quality degrades after large corrections — the rendering loss must be minimized again to realign appearance with the corrected geometry.

Bandwidth-Efficient Gaussian Summary ​

MAGiC-SLAM: transmit only Gaussians with opacity o < epsilon_invisible (not rendered in current frustum) — a frustum-culling-based selection that reduces transmission to geometrically novel submaps.

Coko-SLAM: Lagrangian Gaussian compaction — minimize rendering loss subject to a Gaussian count budget K:

min_{Theta}  L_render(Theta) + lambda * max(|Theta| - K, 0)

solved by proximal alternating optimization. Active from iteration 700–950 of 1 000 mapping iterations. Reduces submap size 85–95% versus naive transmission. The dual variable lambda adjusts automatically to enforce the sparsity budget.

Inputs and Outputs ​

Per-robot inputs:

  • RGB-D stream (color + registered depth) — all published systems except MAGS-SLAM (2026, RGB only)
  • Known camera intrinsics
  • GPU with CUDA (most systems: RTX 4090 or equivalent; minimum ~10 GiB VRAM per agent)

Communication channel:

  • Keyframe descriptor embeddings (DINOv2 / NetVLAD feature vectors) — low bandwidth
  • Compressed Gaussian submaps — 85–2 050 MB per submap depending on system and compaction setting
  • Loop closure transform estimates and confidence scores
  • Corrected pose broadcasts from server back to agents (centralized systems)

Outputs per robot:

  • Per-robot SE(3) trajectory in a shared global frame (ATE RMSE metric)

Shared joint map outputs:

  • Globally consistent 3DGS or neural-implicit map supporting novel-view synthesis
  • Per-submap corrected poses after PGO
  • Rendered RGB, depth, and silhouette images at any registered viewpoint

Architecture ​

Per-Robot Front-End (RGB-D or RGB)
    |
    +-- Tracking: rendering-based or ICP-based pose estimation
    +-- Mapping: Gaussian / neural-implicit submap construction
    +-- Keyframe selection: distance / overlap threshold
    +-- Descriptor extraction: DINOv2 / NetVLAD embeddings
         |
         v
Inter-Robot Communication Layer
    |
    +-- Descriptor exchange --> overlap detection (cosine similarity)
    +-- Submap transmission (frustum-culled or Lagrangian-compacted Gaussians)
    +-- Loop closure registration: FPFH+RANSAC --> ICP --> SE(3) T_{ij}
         |
         v
Central Server (CP-SLAM / MAGiC-SLAM / GRAND-SLAM / Coko-SLAM)
OR Distributed Coordinator (MAC-Ego3D / MNE-SLAM / CoMA-SLAM)
    |
    +-- Pose-graph construction + optimization (GTSAM / G2O)
    +-- Corrected pose broadcast back to agents
    +-- Map fusion: rigid transform of Gaussians + fine-tuning / distillation

Centralized systems (CP-SLAM, MAGiC-SLAM, GRAND-SLAM, Coko-SLAM): a server handles PGO and fusion. More tractable for heavy neural optimization but constitutes a single point of failure.

Distributed systems (MAC-Ego3D, MNE-SLAM, CoMA-SLAM): peer-to-peer or distributed coordination; consensus, distillation, or distributed keyframe optimization; no central fusion server. More robust to server failure and more scalable in principle, but global consistency is harder to guarantee and current results remain research-scale.

Training and Optimization ​

Multi-agent neural Gaussian SLAM has four distinct optimization stages that must run in coordination across robots.

Stage 1 — Per-robot local mapping. Each agent minimizes the combined photometric and depth rendering loss over its RGB-D stream:

L_local = L1_photometric + lambda_depth * L1_depth + lambda_reg * L_regularizer

The regularizer is isotropic (penalizing anisotropic Gaussians) in monocular systems and absent or weaker in RGB-D systems. This is the standard single-agent 3DGS-SLAM objective (see GS-SLAM and MonoGS for full derivation).

Stage 2 — Rendezvous detection + cross-robot alignment. Cosine similarity on DINOv2 or NetVLAD keyframe descriptors triggers loop closure candidates. Each candidate is verified via point-cloud registration (FPFH+RANSAC or rendered-depth ICP), yielding a relative transform T_{ij} and an information matrix Omega_{ij} encoding registration confidence.

Stage 3 — Global PGO. All accepted inter-robot and intra-robot loop constraints are fused in a single PGO over the full submap pose graph. GTSAM or G2O minimize the SE(3) log-map residuals weighted by information matrices. Distributed PGO (DPGO, as used in Kimera-Multi) is an alternative for the MNE-SLAM / MAC-Ego3D class of systems. See Distributed Multi-Robot PGO.

Stage 4 — Map deformation and fine-tuning. PGO-corrected poses are applied as rigid transforms to Gaussian means and covariances. Because SH color coefficients were optimized in the pre-correction frame, a 3 000-iteration fine-tuning pass (MAGiC-SLAM) or online distillation step (MNE-SLAM) re-minimizes the rendering loss in the corrected frame to restore appearance quality.

Benchmark Results ​

Datasets Used ​

DatasetTypeAgentsSensorNotes
ReplicaMultiagentSynthetic indoor2RGB-DDerived from Replica; Office-0, Apartments; primary indoor benchmark
ReplicaMultiagent PlusSynthetic indoor2+RGB onlyIntroduced by MAGS-SLAM (2026) for monocular evaluation
AriaMultiagentReal indoor3RGB-D (Project Aria)Larger scale; used in MAGiC-SLAM
7-ScenesReal indoor1–2RGB-DSmall-scale real-world check
Kimera-Multi outdoorReal outdoor2Stereo + IMU~800 m trajectories; large-scale; originally classical multi-robot SLAM benchmark
INS datasetReal indoormultiRGB-DIntroduced by MNE-SLAM (CVPR 2025); single + multi-agent
DES (Dense SLAM)Real indoor + outdoormultiRGB-DIntroduced by MCN-SLAM (2025)
S3EReal multi-robotmultiLiDAR + camera + IMUAir-ground heterogeneous; none of the surveyed neural/Gaussian systems use it

The survey (arXiv 2510.23988) explicitly concludes: "None of the existing datasets fully capture requirements for benchmarking collaborative Gaussian SLAM" — gaps include outdoor scale, heterogeneous sensors, and long-duration sequences.

Metrics ​

  • Per-robot ATE RMSE (cm or m): absolute trajectory error versus ground truth; primary localization metric.
  • Joint-map consistency: multi-agent ATE after PGO correction; tests whether cross-robot loop closures produce correct global alignment.
  • Rendering quality: PSNR (dB), SSIM, LPIPS on training views and novel views.
  • Depth L1 (cm): geometric accuracy of reconstructed depth map.
  • Communication bandwidth: total MB transmitted per agent or per submap; reduction ratio versus baseline.
  • Runtime: seconds per frame for tracking, mapping, merging, and PGO.

Head-to-Head Comparison (ReplicaMultiagent, 2 agents) ​

SystemATE RMSE (cm)PSNR (dB)SSIMDisk/submap (MB)GPU/agent (GiB)Map time (s/frame)
CP-SLAM (NeurIPS 2023)0.6522.710.69~54~9.7~16.95
MAGiC-SLAM (CVPR 2025)0.2734.260.97~54~1.12~0.71
MAC-Ego3D (CVPR 2025)0.1440.04———~0.07 (tracking)
GRAND-SLAM (RA-L 2025)0.2541.35————
Coko-SLAM (2026, rendered-depth)—26.66–39.290.906–0.991~100——

Outdoor Comparison (Kimera-Multi outdoor dataset) ​

SystemATE RMSE (m)PSNR (dB)SSIM
MAGiC-SLAM60.7915.880.50
ORB-SLAM310.58——
GRAND-SLAM4.9927.440.97

GRAND-SLAM's 91% lower ATE versus MAGiC-SLAM on the outdoor dataset is the largest performance gap in the literature. However, GRAND-SLAM's bandwidth overhead on the outdoor dataset is not reported.

Classical Multi-Robot SLAM Context ​

Understanding where multi-agent neural Gaussian SLAM sits requires comparison with the mature classical multi-robot SLAM family.

SystemModalityArchitectureKey feature
CCM-SLAM (Schmuck & Chli, JFR 2019)MonocularCentralizedFirst multi-UAV collaborative monocular SLAM; ORB-SLAM2 agents offload to server
COVINS / COVINS-G (ETH, 2021/2023)Visual-InertialCentralized server, generic front-endAny VIO front-end; multi-camera relative pose for loop closure
Kimera-Multi (Tian et al., T-RO 2022)Stereo-inertialFully distributedDense metric-semantic 3D mesh; DPGO back-end; robust to outlier loops; T-RO Best Paper 2022
Swarm-SLAM (Lajoie & Beltrame, RA-L 2024)LiDAR / stereo / RGB-DFully decentralizedSparse, ROS 2, multi-sensor, inter-robot loop closure prioritization; 5 datasets + real 3-robot
DPGO (Tian et al., T-RO 2021)Back-end onlyDistributedCertifiably correct distributed PGO; used as back-end in Kimera-Multi

See Kimera-Multi, COVINS / COVINS-G, and Distributed Multi-Robot PGO for full treatments.

How neural/Gaussian variants differ from classical:

  1. Map density: Classical multi-robot SLAM stores sparse keyframe pose graphs and feature maps (megabytes total). Neural/Gaussian SLAM stores dense appearance submaps (tens to hundreds of MB per submap). This is the core bandwidth tension.

  2. Loop closure inputs: Classical methods use binary descriptors (BoW, DBoW3) on raw keyframes. Neural/Gaussian methods use learned global descriptors (DINOv2, NetVLAD) on rendered or stored images plus ICP on rendered point clouds.

  3. Map representation after fusion: Classical → sparse 3D mesh or point cloud, usable for geometric navigation. Neural/Gaussian → photorealistic splat or NeRF supporting novel-view synthesis — useful for inspection but not needed for geometry-only navigation.

  4. Maturity: Classical multi-robot SLAM (Swarm-SLAM, Kimera-Multi) has ROS 2 integrations, real-robot deployments, and outdoor evaluation at hundreds of meters. Neural/Gaussian multi-agent SLAM is largely synthetic-dataset research (2024–2026); outdoor results exist mainly from GRAND-SLAM on the Kimera-Multi outdoor benchmark rather than from LiDAR-primary fleet surveys.

  5. Sensor: Classical systems — especially Swarm-SLAM — natively support LiDAR front-ends. No neural/Gaussian multi-agent SLAM system as of May 2026 has a LiDAR-primary front-end.

Variants and Lineage ​

The family tree from classical multi-robot SLAM to the current generation:

Classical sparse multi-robot SLAM (ORB-SLAM2 multi-agent, CCM-SLAM, ~2016-2019)
    |
    +-- Classical dense multi-robot SLAM: Kimera-Multi, COVINS (2021-2022)
    |   LiDAR/VIO front-ends; distributed PGO back-end; sparse-to-semi-dense maps
    |
    +-- Neural-implicit collaborative: CP-SLAM (NeurIPS 2023)
    |   Point-anchored neural features; first complete collaborative neural pipeline
    |
    +-- 3DGS single-agent: SplaTAM, GS-SLAM, MonoGS (CVPR 2024)
    |   Explicit Gaussian primitives; room-scale; no loop closure
    |
    +-- 3DGS single-agent with loop closure: Splat-SLAM, LoopSplat (2024-2025)
    |   Adds pose-graph correction to single-agent Gaussian systems
    |
    +-- 3DGS / 2DGS multi-agent: MAGiC-SLAM, MAC-Ego3D,
        GRAND-SLAM, Coko-SLAM, CoMA-SLAM, MAGS-SLAM
        (CVPR 2025 / RA-L 2025 / AAAI 2026 / arXiv 2026)
        Explicit Gaussian or surfel submaps; inter-robot loop closure;
        centralized or distributed PGO / consensus / keyframe optimization

The most direct single-agent precursors are GS-SLAM and MonoGS (iter 26) and GigaSLAM (iter 29). GigaSLAM's hierarchical LoD submap architecture is conceptually relevant for handling large-scale outdoor multi-agent scenes, though no multi-agent extension of GigaSLAM exists yet. For loop closure methods that underpin inter-robot rendezvous detection see Loop Closure and Place Recognition (iter 28) and Learned LiDAR Place Recognition (iter 18).

Strengths ​

Collaborative scene coverage. Multiple robots cover a large area faster than a single robot, and jointly reconstruct areas that no individual robot's trajectory fully observes.

Photorealistic shared map. The shared 3DGS map supports novel-view synthesis — useful for inspection (visual comparison across survey runs), synthetic data generation, and digital twin visualization in a way that sparse point clouds do not.

Rich appearance representation with concrete bandwidth handles. The Gaussian explicit representation is differentiable and prunable. Frustum culling (MAGiC-SLAM) and Lagrangian compaction (Coko-SLAM) reduce submap sizes by 85–95%, giving concrete engineering levers unavailable in NeRF-based approaches.

PGO back-end is shared with classical SLAM. The pose-graph optimization used by GRAND-SLAM (GTSAM), MAGiC-SLAM (G2O), and Kimera-Multi (DPGO) is mathematically identical — the same SE(3) log-map residuals and information matrix weighting. Teams familiar with classical multi-robot SLAM can reuse the entire PGO module and need only swap the front-end representation.

Growing benchmark coverage. With GRAND-SLAM's Kimera-Multi outdoor evaluation, the family now has a direct comparison point against classical multi-robot SLAM on a shared outdoor dataset.

Failure Modes ​

Failure modeMechanismSeverity
Communication-bandwidth bottleneckEven with 85–95% compaction, multi-vehicle survey of a large space generates gigabytes; no system measures continuous streamingCritical for outdoor fleet
Rendezvous-detection sensitivityIf two robots never share overlapping views (textureless tarmac, non-overlapping sectors), no loop closure detectable; submaps remain in disjoint framesCritical for outdoor survey
No LiDAR supportSurveyed systems assume RGB-D, RGB, or stereo/visual input; no LiDAR-primary front-end existsCritical for industrial deployment
RGB-D depth range limitationActive depth sensors (RealSense, Kinect) saturate at 5–10 m; useless for outdoor survey rangesCritical for airside
Post-PGO rendering degradationRigid transform corrects geometry but SH color coefficients optimized in old frame degrade novel-view quality; requires fine-tuningModerate for inspection
Sub-real-time mappingMAGiC-SLAM: 0.71 s/frame; CP-SLAM: 16.95 s/frame; only MAC-Ego3D approaches real-time for tracking (~0.07 s/frame)High for online deployment
Scalability ceilingAll results involve 2–3 agents on indoor sequences of minutes; no published evaluation of 10+ agents or kilometer-scale outdoorHigh for fleet use
Centralized server dependencyMAGiC-SLAM, GRAND-SLAM, Coko-SLAM require a server; server failure = no global consistencyModerate for resilient systems
Dynamic object corruptionNo surveyed system includes dynamic-object masking; moving objects contaminate map and tracking lossVery high for airside GSE
Scale ambiguity (monocular)RGB-only systems (MAGS-SLAM) require additional geometric priors for cross-agent metric alignmentHigh for metric accuracy

Domain Fit ​

DomainFitNotes
Indoor terminal / hangar (offline appearance)ConditionalMost viable application; RGB-D range matches; use LiDAR for poses
Indoor hangar (multi-robot inspection)ResearchUseful after LiDAR survey; appearance re-mapping with coordinated robots
Airside apron (primary multi-vehicle SLAM)Not suitableNo LiDAR, sub-real-time, RGB-D range too short, dynamic GSE
Outdoor large-scale surveyResearch onlyGRAND-SLAM shows feasibility at ~100 m; not production-grade
Warehouse multi-robot mappingResearchClassical multi-robot SLAM is more mature and LiDAR-compatible
Port / logistics-yard surveyNot suitableScale and LiDAR requirements match classical systems better
Road AV digital twinResearchGigaSLAM is the relevant single-agent reference at km scale
Agriculture / construction outdoorNot suitableWeather, vegetation, scale all exceed system capabilities
Delivery robot (indoor, shared map)ResearchMost plausible deployment context; scale fits; GPU budget is a concern

Aggregated-Map Suitability: The Honest Assessment ​

Multi-agent neural Gaussian SLAM is research-stage RGB-D work. For an airside multi-vehicle LiDAR survey, it is not a production-grade choice for four structural reasons:

  1. LiDAR geometry is the survey deliverable, not RGB appearance. Neural Gaussian maps optimize for photometric rendering quality; LiDAR-primary pipelines (LIO-SAM, FAST-LIO2, LiLi-OM) produce direct georeferenced point clouds without neural optimization overhead and at a fraction of the GPU cost.

  2. Classical multi-robot SLAM is production-ready for multi-vehicle survey. Swarm-SLAM (RA-L 2024, open-source ROS 2) supports LiDAR + stereo + RGB-D, is fully decentralized, and has been tested on five datasets including real 3-robot experiments. Kimera-Multi handles outdoor 800 m trajectories with metric-semantic 3D mesh output. These are the correct technology choices for multi-vehicle airside survey.

  3. Scale mismatch. Airside apron surveys span hundreds to thousands of meters. All neural/Gaussian multi-agent SLAM papers operate on submeter to tens-of-meters indoor scenes, with GRAND-SLAM as the single exception at ~100 m outdoor scale.

  4. No LiDAR front-end in any published system. Multi-agent neural Gaussian SLAM as of May 2026 is visual/RGB-D/RGB-first rather than LiDAR-primary. The closest published outdoor result (GRAND-SLAM on Kimera-Multi outdoor) uses a dataset originally captured with stereo + IMU — a sensor modality that is itself inadequate for production airside survey.

Recommended production path for multi-vehicle airside survey:

Step 1: Classical multi-robot SLAM (Swarm-SLAM or Kimera-Multi + LiDAR front-end)
        + RTK/GNSS for global anchoring
        -> Globally consistent LiDAR point cloud (primary, metric-accurate)
        -> Distributed or centralized PGO back-end

Step 2 (optional — appearance layer):
        Per-vehicle cameras run 3DGS mapping using LiDAR-derived poses as ground truth
        -> Multi-agent 3DGS coordination can be applied here, with LiDAR decoupled
        -> Result: photorealistic Gaussian appearance layer registered to LiDAR geometry
        -> Use cases: digital twin visualization, inspection image comparison,
           synthetic training data, change detection

Combined output:
        Airport digital twin = LiDAR geometry (primary, safety-rated)
                             + 3DGS appearance layer (visualization, inspection)
        The two pipelines are decoupled: LiDAR for geometry/navigation,
        3DGS for appearance/visualization.

This decoupled architecture is consistent with how Gaussian-LIC and LVI-GS operate (LiDAR for geometry, cameras for appearance Gaussians) and can absorb any future multi-agent 3DGS advancement without requiring changes to the safety-critical LiDAR pipeline.

Implementation Notes ​

  • Do not expect real-time operation. MAGiC-SLAM maps at ~0.71 s/frame, CP-SLAM at ~16.95 s/frame. Only MAC-Ego3D reports near-real-time tracking (0.07 s/frame). Treat these as offline or slow-online mapping systems. Design data collection missions accordingly.
  • GPU budget per agent is substantial. CP-SLAM requires ~9.7 GiB per agent; MAGiC-SLAM ~1.12 GiB. For a 3-agent setup on a shared server, budget at least 6–10 GiB for the coordination overhead plus per-agent maps. An RTX 4090 (24 GiB) handles 2–3 agents simultaneously in the MAGiC-SLAM configuration.
  • Centralized vs distributed remains unsettled. Centralized systems are easier to reproduce and compare, but CoMA-SLAM makes the distributed branch source-mature enough to evaluate. For production fleet mapping, keep classical distributed C-SLAM as the safety-critical layer and treat distributed neural/Gaussian SLAM as an offline appearance or validation experiment.
  • DINOv2 descriptor quality depends on visual texture. Loop closure detection fails in textureless environments (uniform walls, apron concrete, painted runways). For indoor airport environments add GeM or NetVLAD fallback; for outdoor add scan-context-style geometric descriptors from LiDAR (see Learned LiDAR Place Recognition).
  • Implement loop closure verification before map merging. False inter-robot loop closures couple independent maps and are especially damaging — harder to detect and correct than single-agent false loops. Use point-to-plane ICP fitness + inlier RMSE thresholds (as in GRAND-SLAM) as a quality gate, and log all accepted/rejected loop candidates for audit.
  • Budget for fine-tuning after every PGO correction. Rigid Gaussian transforms fix geometry but degrade appearance. MAGiC-SLAM's 3 000-iteration fine-tuning pass is the minimum to restore rendering quality. For inspection use cases where appearance matters, this cost must be factored into the mission timeline.
  • Custom CUDA rasterizer dependency pinning is critical. All 3DGS systems inherit the tile-based CUDA rasterizer from Kerbl et al. (SIGGRAPH 2023). Version combinations outside the tested CUDA/PyTorch/driver set fail to compile or produce silent numerical errors. Pin versions tightly and document the tested configuration.
  • Agent identity and clock synchronization are first-class requirements. Keyframe timestamps, agent IDs, and coordinate frame conventions must be consistent across all robots before attempting any submap fusion. Use a centralized timestamp authority or NTP-synchronized clocks with bounded drift.
  • No ROS 2 integration in any surveyed system. All published implementations are research Python/PyTorch code without robot middleware integration. Significant engineering effort is required to bridge from paper code to a ROS 2-compatible deployment.
  • Evaluate per-agent ATE, bandwidth, loop false-positive rate, and recovery after communication loss as separate metrics. Single aggregate ATE numbers hide the failure modes that matter most in deployment (communication failures, agent reconnection, partial loop closure detection).

Sources ​

Core papers:

Survey:

Classical multi-robot SLAM:

Public research notes collected from public sources.

Copyright © 2026 kvynlim