Picture a swarm of drones, each carrying a different unknown payload and facing different drag. The swarm has no central coordinator, and radio links between drones appear and disappear as they move. Each drone learns a correction to its physics model from its own flight data and from data that nearby drones send it. It then uses how uncertain that correction is to decide how much extra clearance to keep from its neighbors.
Existing decentralized safety controllers fall into two camps. Some assume the physics is known exactly. Others learn the physics but assume the communication network never changes. This proposal targets the point where the two meet, which neither camp handles. When a link drops, the uncertainty a drone can rely on jumps, so its required safety margin jumps with it, and the standard safety proof breaks at exactly that moment.
The core idea fits in two sentences. First, a drone never forgets data a neighbor has already sent, so shared knowledge can only shrink its uncertainty. Second, a drone's estimate of a neighbor's uncertainty grows smoothly with the time since it last heard from that neighbor, never abruptly. Together these make the safety margin change continuously, or jump only in the safe direction. That restores the safety guarantee under arbitrary link switching and keeps it even when the swarm splits permanently. Connectivity then affects only how conservative the swarm is, not whether it is safe.
Background and the Gap
A control barrier function (CBF) is a scalar function $h(x)$ that is positive on safe states. A controller keeps the system safe by choosing inputs so that $h$ never decreases faster than a prescribed rate. At each step this is enforced by a small quadratic program that minimally edits a nominal command. The rate condition involves the time derivative of $h$, so any sudden jump in the terms that enter it invalidates the forward-invariance argument.
The two camps look like this.
Learned physics, one agent. Control Barrier Functions for Unknown Nonlinear Systems using Gaussian Processes learns unknown drift terms with a Gaussian process, a regression model that returns a prediction together with a calibrated error bar. It folds the error bar into the barrier condition and proves a safety probability of at least 0.9839 on a Moore-Greitzer jet engine model. Control Barriers in Bayesian Learning of System Dynamics does the same online with a matrix-variate Gaussian process and chance constraints solved as second-order cone programs. Both are single-agent. They supply our per-agent safety constraint, not our multi-agent mechanism.
Switching networks, known physics. GCBF+ and its predecessor Neural Graph Control Barrier Functions run fully decentralized barrier controllers over distance-based neighbor graphs. They smooth the arrival and departure of neighbors with attention weights that fade to zero at the sensing radius, and GCBF+ reports over 98% success at 256 agents and 128 obstacles. They assume the dynamics are known and deterministic, so an unmodeled payload or drag term silently miscalibrates the certificate. GCBF+ also notes that its neural certificates are not formally verified.
Learned physics, fixed networks. Decentralized Event-Triggered Online Learning for Safe Consensus and Distributed Event-Triggered Online Learning for Multi-Agent System Control learn unknown dynamics per agent with Gaussian processes. The second fuses neighbors' models by product- or mixture-of-experts and adds a sample only when an error threshold is crossed. Both prove bounded tracking error, but only on a fixed, connected, undirected graph.
Motivating the design. Distributed Gaussian Process Mapping for Robot Teams with Time-varying Communication proves that Gaussian-process parameters converge to the centralized estimate under B-connectivity, meaning the union of links over any window of length B connects the team. It models a static map, not closed-loop dynamics. It shows that "exchange data when you meet" is workable under intermittent contact. We reuse that pattern but decouple safety from the B-connectivity assumption.
Two gaps follow directly from this literature. Graph barrier controllers have no account of learned-dynamics uncertainty. The event-triggered decentralized Gaussian-process controllers have no account of neighbors that come and go.
The obvious combination would plug a fused neighbor posterior into a GCBF-style constraint, and it has a specific failure. When neighbor $j$ leaves range, agent $i$ loses $j$'s data or $j$'s broadcast error bar. The margin then steps upward, and a constraint that was satisfied an instant earlier becomes infeasible. Attention-style edge fading in GCBF+ smooths the geometric contribution of a neighbor. It does not address the step in the uncertainty term, because that step is caused by information loss, not by geometry.
Core Claim
Write agent $i$'s dynamics as control-affine, $\dot x_i = f_i(x_i) + d_i(x_i) + g_i(x_i)u_i$:
- $f_i$ is a nominal model and $g_i$ is a known input map.
- $d_i$ is an unknown residual, for example drag, ground effect, or payload mass, modeled by a sparse Gaussian process.
- The residual is assumed to have bounded norm in the kernel's function space. Under that assumption the posterior error bar $\beta\,\sigma_i(x_i)$ covers $d_i$ with high probability.
For a pairwise barrier $h_{ij}$, such as squared distance minus squared safety radius, we impose
$$\dot h_{ij}^{\text{nom}}(x,u_i) \;\ge\; -\alpha(h_{ij}) + \|\nabla_{x_i} h_{ij}\|\,\beta\,\sigma_i(x_i) + \|\nabla_{x_j} h_{ij}\|\,s_{ij}(t).$$
Here $\dot h_{ij}^{\text{nom}}$ is the derivative using $i$'s mean model and $j$'s sensed or predicted motion, and $\alpha$ is a class-K function. The quantity $s_{ij}(t)$ is agent $i$'s bound on neighbor $j$'s unmodeled acceleration, and the proposal rests on how it is built:
$$s_{ij}(t) = \min\big(\bar\sigma,\; \beta\,\sigma_j^{\text{last}} + L\,(t - t_{ij}^{\text{last}})\big).$$
In this formula, $\sigma_j^{\text{last}}$ is the error bar $j$ broadcast at its last contact time $t_{ij}^{\text{last}}$. $L$ is a known rate at which that bound may be allowed to age, justified by a Lipschitz bound on how fast $j$'s state, and hence its query point, can move. $\bar\sigma$ is the prior worst-case bound, which agents use for any never-contacted neighbor.
Two design rules follow. The first is data persistence: samples received from peers are never evicted merely because a link dropped. The second is continuity: the bound on a silent neighbor grows continuously rather than jumping.
Under these rules, every discontinuity in the margin is a downward step. Downward steps happen when new data arrives or a fresh broadcast replaces an aged bound, and they only enlarge the feasible input set. The paper will prove the resulting statement in two parts. With the high probability given by the Gaussian-process coverage bound, each $h_{ij}$ stays nonnegative for any switching sequence, including permanent partitions. The only additional requirement is that the quadratic program stays feasible, which we handle with the actuation-aware look-ahead used in GCBF+. The second part is that the amount of conservatism is bounded in terms of the B-connectivity window when that condition holds.
The guarantee covers hand-designed pairwise barriers. When the learned GCBF+ certificate is used for navigation performance, we inherit its lack of formal verification and say so.
No component in this design is a single point of failure. No agent holds the global model, and losing any agent or link degrades only how conservative its neighbors are.
Research Program
The work has three parts.
Theory. We derive the switching-robust invariance result above, extending the per-agent coverage argument of Control Barrier Functions for Unknown Nonlinear Systems using Gaussian Processes to the pairwise, staleness-aged margin. Two assumptions are known to be fragile and we flag both up front. One is the known input map $g_i$. The other is non-singular actuation, which Decentralized Event-Triggered Online Learning for Safe Consensus also requires.
Learning and communication. Each agent runs a budgeted sparse Gaussian process with pseudo-inputs, in the style of Distributed Gaussian Process Mapping, so cost stays fixed as data accumulates. Samples are admitted by an event trigger adapted from Distributed Event-Triggered Online Learning. On contact, agents exchange only newly triggered samples plus a scalar error bar. Because agents' residuals differ, received samples are placed in a separate, down-weighted "peer" output with its own noise level. They are not pooled blindly. Whether cross-agent sharing helps at all is treated as an empirical question.
Implementation. The controller is a per-agent quadratic program layered on the GCBF+ codebase's environments. We cross-check our Gaussian-process chance constraints against the single-agent Bayesian_CBF implementation.
Baselines
Uncertainty-blind reference. The naive reference is GCBF+ run exactly as published, using only the nominal model, in environments where we inject heterogeneous unmodeled residuals: per-agent payload mass, quadratic drag, and ground effect near obstacles. It is the right floor because it is the strongest decentralized swarm-safety method in the file. GCBF+ reports over 98% success at 256 agents with 128 obstacles and 45% higher success than InforMARL on drones, all under exact dynamics. We found no reported result on Lacuna for GCBF+ under unmodeled dynamics. Measuring its collapse under unmodeled dynamics is therefore itself a first contribution.
Robust fixed-margin controller. The strongest competitor is GCBF+ with a fixed worst-case margin $\bar\sigma$ added to every constraint. This is the classic offline-robust answer. For fairness, $\bar\sigma$ is tuned on the same training episodes to the smallest value achieving zero collisions on a validation seed set, with the same tuning budget we give our method's $\beta$ and $L$. Beating it means matching its collision rate while achieving clearly higher success and lower time-to-goal in dense scenes. Its conservatism should cause deadlocks there, the failure mode GCBF+ already reports in bottlenecks.
Ablations and bounds. Three variants isolate the ingredients:
- Local only: each agent learns only from itself, which isolates the value of sharing.
- Naive fusion: sharing on, but peer data and bounds are dropped immediately on disconnect, which isolates the persistence and continuity rules.
- Centralized oracle: a single server holds all data. This is an upper bound on performance and a demonstration of the vulnerability being avoided; we also kill its server mid-episode.
The event-triggered decentralized controllers of Distributed Event-Triggered Online Learning serve as the data-efficiency reference. That paper reports roughly 150 samples versus 4,000 for time-triggered updates, and we check that our data budget stays in that range.
All methods share the same environments, seeds, communication traces, per-agent compute budget, and control rate.
Why not just…?
Why not just add a fixed worst-case margin to GCBF+? This is the real threat. If the residuals across the swarm are small and similar, a single tuned margin may cost little, and online learning would add complexity for nothing. The evidence in the file is suggestive but not decisive. Control Barriers in Bayesian Learning of System Dynamics shows fixed bounds block passage through clutter that becomes feasible as uncertainty shrinks. Decentralized Event-Triggered Online Learning for Safe Consensus reports that static offline controllers show divergence trends. We settle the question by sweeping residual heterogeneity. The prediction is that the robust baseline's success rate falls sharply once the worst agent's residual dominates the median agent's. If it does not, we will report that learning is unnecessary in that regime.
Why not just let each agent learn only its own residual? This works if every agent's residual is independent and each agent sees enough of its own state space. Its weakness is novel regions, such as the first entry into ground effect. There, a neighbor's samples could lower the error bar before the agent pays for the lesson itself. The local-only ablation measures this directly. If it matches full sharing, the communication component reduces to broadcasting error bars, which is still needed for the neighbor term, and we will say so.
Why not just use model-free safe multi-agent reinforcement learning with penalties? Neural Graph Control Barrier Functions reports MAPPO falling to nearly 0% success beyond 500 agents. Safe-Control-Gym reports that PPO and SAC need an order of magnitude more data than GP-MPC and violate more constraints during training. We include MAPPO at small scale only, as a sanity reference.
Why not just use neural-network ensembles instead of Gaussian processes? Ensembles scale better in high dimension, but their spread carries no coverage guarantee, which the invariance proof needs. We run an ensemble variant of the margin and report its empirical coverage. If its coverage and safety match ours, the guarantee is the only thing distinguishing the two.
Proposed Experiments
Main swarm experiments. We run the GCBF+ SimpleCar, DubinsCar, and 3D quadrotor environments with injected per-agent residuals. Team sizes are 8, 16, 64, and 256, with obstacle counts up to 128.
Three communication regimes are tested. The first is distance-limited links. The second adds random link drops at 10–50%. The third imposes jamming partitions that last longer than any B window.
The metrics are:
- collision rate, and separately collisions occurring within one second of a link-switch event;
- goal success and deadlock rate;
- mean margin size;
- empirical coverage of $\beta\sigma$ against true residuals;
- quadratic-program infeasibility count;
- samples stored per agent;
- bytes exchanged.
Single-agent calibration. Before scaling up, we check per-agent calibration on the safe-control-gym 2D quadrotor with parametric inertia disturbances. We also reproduce the inverted-pendulum setup from Bayesian_CBF.
Decisive checks. The mechanism check is naive fusion versus our margin under link drops. The prediction is that naive fusion's collisions cluster at disconnect events while ours show none, and that the two coincide on a static graph. The robustness check is permanent partition, where our collision rate should stay at the static-graph level while success degrades gracefully toward the robust baseline. The usefulness check is the heterogeneity sweep against the fixed-margin baseline.
The proposal succeeds only if all three hold. If the third fails, the contribution narrows to a switching-safe margin construction with no performance advantage over robust tuning, and we would report it that way.
Hardware. A final eight-Crazyflie run with an attached unequal payload, mirroring the GCBF+ hardware setting, tests whether the continuity rule matters under real radio dropouts.
References
- Control Barrier Functions for Unknown Nonlinear Systems using Gaussian Processes
- Control Barriers in Bayesian Learning of System Dynamics
- GCBF+: A Neural Graph Control Barrier Function Framework for Distributed Safe Multiagent Control
- Neural Graph Control Barrier Functions Guided Distributed Collision-avoidance Multi-agent Control
- Decentralized Event-Triggered Online Learning for Safe Consensus of Multi-Agent Systems with Gaussian Process Regression
- Distributed Event-Triggered Online Learning for Multi-Agent System Control using Gaussian Process Regression
- Distributed Gaussian Process Mapping for Robot Teams with Time-varying Communication
- Safe-Control-Gym: A Unified Benchmark Suite for Safe Learning-Based Control and Reinforcement Learning in Robotics