Reliability-Weighted Safety Filters for Heterogeneous Teams

When a team of different robots must avoid colliding, someone has to decide who swerves. A known answer splits the job by physical ability: the agile drone dodges more and the slow ground rover dodges less. That answer assumes each robot's motion model is correct. After a policy moves from simulator to hardware, it is not. Some robots drift from their models a lot (a slipping wheel, a delayed actuator), others barely. Some agents are not even reliable about their own commands, for instance a controller computed on a noisy quantum processor. This note proposes that the avoidance burden should be split by each agent's certified reliable capability: its acceleration margin minus an online, statistically calibrated bound on how wrong its model currently is. The resulting safety filter sits under a constrained multi-agent learner. The goal is no collisions during training and deployment, not just at convergence.

The opportunity is that two literatures each hold half the answer. Asymmetric barrier methods know how to share responsibility across unequal robots but assume exact dynamics. Provably safe sim-to-real methods know how to bound and explore the region where simulation and reality differ, but only for single agents in small discrete settings. Joining them gives a concrete, testable mechanism for the failure the file flags repeatedly. Small per-robot model errors compound across interactions, and coordinated maneuvers then fall apart.

Core Claim

Safety Barrier Certificates for Collisions-Free Multirobot Systems solves a small quadratic program (QP) per robot each step. The program minimally edits the robot's intended command so that a control barrier function (CBF) stays nonnegative. A CBF is a scalar "distance-to-unsafe" score $h_{ij}$ for each pair of robots $i,j$. The paper splits the required pairwise correction in proportion to acceleration limits ("Strategy C"). It also proves the safe set stays invariant while robots estimate their neighbors' parameters online. That estimation is within a known model class. It does not cover unmodeled residual dynamics, and the paper itself reports deadlocks and QP infeasibility in crowded scenes.

We replace capability $c_i$ (agent $i$'s maximum available acceleration) with reliable capability $c_i - \delta_i$. Here $\delta_i$ is a high-probability bound on agent $i$'s one-step model error, computed by split conformal calibration on recent real transitions. Conformal calibration is a distribution-free way to turn held-out prediction residuals into a quantile with a coverage guarantee. Each agent enforces its share of the pairwise barrier condition, tightened by its own error bound:

$$ \nabla_{x_i} h_{ij}\cdot \hat f_i(x_i,u_i) \;\ge\; -\rho_{ij}\,\gamma\, h_{ij} + \delta_i\,\|\nabla_{x_i} h_{ij}\|,\qquad \rho_{ij}=\frac{(c_i-\delta_i)_+}{(c_i-\delta_i)_+ + (c_j-\delta_j)_+}. $$

In this condition, $\hat f_i$ is agent $i$'s simulator-derived dynamics model, $u_i$ is its control, and $\gamma>0$ is the barrier decay rate. The share $\rho_{ij}$ is the fraction of the pairwise safety obligation agent $i$ absorbs, and $(\cdot)_+$ clips at zero. The two shares sum to one, so the pair still jointly satisfies the barrier condition. The tightening term makes each share hold despite agent $i$'s own model error, with the conformal coverage probability.

The claim is twofold. First, with uniform worst-case tightening, the least reliable agent's error inflates every agent's margin, so feasibility and progress collapse first. Reliability weighting shifts the burden toward agents whose models are trustworthy. It should therefore keep the zero-violation property while sharply cutting deadlocks and infeasibility. Second, the same mechanism handles a computational gap with no change. If an agent's commands come from a noisy quantum circuit, its execution noise enters $\delta_i$ exactly like actuator drift.

Research Program

The system has three layers. The learner is MAPPO-Lagrangian from Multi-Agent Constrained Policy Optimisation. That paper formulates constrained Markov games and gives sequential, per-agent updates with constraint satisfaction per iteration. Its guarantees concern the expected cost of the learned policy and permit violations along exploratory rollouts, which is what we fix. The learner proposes nominal actions. The reliability-weighted filter edits them. The filtered actions, not the proposals, are what the learner trains on, with an intervention penalty fed to the Lagrangian cost.

This mirrors the base/perturbation split of DeCOM and the nominal-plus-residual idea of Generalizing Cooperative Eco-driving via Multi-residual Task Learning. Those works supply the architectural template. Ours differs in that the corrective layer is a certified filter whose margin is set by measured mismatch, not a learned module.

The mismatch estimator is the continuous, per-agent analogue of the mismatch region $B$ in Provably Safe Sim-to-Real Transfer. That paper shows real-world sample cost scales with the size of the region where simulator and reality differ, and it reaches zero unsafe iterations by mixing in a known safe policy. Its tabular, separable-shift assumptions are what we drop. In its place, each agent keeps a sliding window of real transitions, fits nothing, and simply recalibrates the residual quantile of $\hat f_i$. This makes $\delta_i$ cheap, decentralized, and responsive to drift. Neighbors exchange only the scalar $c_j-\delta_j$, not observations, which also addresses the communication-scaling concern in the file.

We analyze what the shift costs. We will prove that pairwise invariance holds with probability at least $1-\alpha$ per step under exchangeable residuals, where $1-\alpha$ is the conformal coverage level. We will also state where the guarantee fails: abrupt shifts break exchangeability, and so does the infeasible case where both $(c_i-\delta_i)_+$ and $(c_j-\delta_j)_+$ are zero. In that infeasible case we fall back to a pre-specified braking controller and count the event as a failure.

The quantum direction enters as an evaluation regime, deliberately not as a claimed speedup. One agent in each team runs a small parameterized quantum circuit (PQC) policy. A PQC is a quantum circuit with tunable rotation gates, trained like a neural network. It runs under hardware-calibrated noise: gate error, readout error, and the drift that Evolutionary Quantum Architecture Search for Parametrized Quantum Circuits and RoQNN show flatten landscapes and shift outputs. RoQNN reports drops of over 60% on IBMQ-Yorktown for MNIST-4 without its noise-aware training. This gives a genuinely heterogeneous, non-dynamical error source to test whether the filter treats "the controller is unreliable" the same way as "the plant is unreliable." Cost limits this regime. Benchmarking Quantum Reinforcement Learning reports about 12 minutes per 14-qubit, 100-epoch run. So quantum agents stay at a few qubits, and real-device execution is limited to a short deployment check.

Baselines

The naive reference is MAPPO-Lagrangian with no filter, trained in the nominal simulator and deployed directly in the shifted environment. It measures how many training and deployment violations occur when safety holds only in expectation. Safety-Gymnasium reports that PPO-Lagrangian cut violations 98% relative to PPO at a 45% reward drop in velocity tasks (Safety Gymnasium). That is single-agent, so it serves only as an orientation point. Provably Safe Sim-to-Real Transfer reports that unconstrained transfer was unsafe in 68.5% of real learning iterations in its gridworld, which indicates the scale of the problem.

The strongest existing method is MAPPO-Lagrangian plus the Strategy C filter of Safety Barrier Certificates. We give it the paper's online neighbor-parameter estimation and the same per-step QP solver. For the learner's numbers on Safe MAMuJoCo, the file reports only that MACPO and MAPPO-L achieve near-zero cost while unconstrained MAPPO, IPPO and HAPPO exceed thresholds. There is no reported number on Lacuna for MAPPO-L reward or cost values on Safe MAMuJoCo, so we will rerun it from the MACPO codebase.

A second strong competitor is the decentralized neural barrier method MDBC. It jointly learns policies and barriers and refines actions at test time, with empirical rather than certified safety. We train it on the same domain-randomized simulator.

The key ablation is uniform robust tightening: every agent uses the team-wide maximum $\delta$ and capability-proportional shares. This isolates whether the gain comes from per-agent reliability weighting or merely from margin inflation. A second ablation keeps per-agent $\delta_i$ in the tightening term but uses capability-only shares $\rho_{ij}$. This separates "tighten by your own error" from "redistribute responsibility by reliability."

All methods share the same simulator, the same perturbed "real" environments, 10 seeds, and an equal hyperparameter-search budget of 20 configurations. Every filter uses the same barrier functions and decay rate. Beating the strongest baseline means two things together. Training-time and deployment collision counts must be no higher than Strategy C's under nominal capability, which we expect to violate under unmodeled drift. And deadlock-plus-infeasibility rate must be at least halved relative to uniform tightening, at equal or better team reward.

Why not just…?

Why not just tighten every barrier by a worst-case margin? This is the real threat. If mismatch is roughly equal across agents, reliability weighting reduces to uniform tightening and adds nothing. The proposal predicts an advantage only when mismatch is heterogeneous. So the experiments sweep the spread of per-agent mismatch from zero upward, and we will report the crossover honestly. If uniform tightening matches us at realistic spreads, the contribution shrinks to the per-agent conformal estimator alone.

Why not just domain-randomize training and skip the filter? Randomization targets average robustness, not per-step safety. Generalizing Cooperative Eco-driving via Multi-residual Task Learning found pure multi-task deep RL across wide distributions raised emissions by up to 95% in some cases, while its residual design lost only 3% under sensor noise versus 18% for the nominal controller. We include a randomized MAPPO-L arm so that training-time violations decide this directly.

Why not just use Strategy C with its own online parameter estimation? That estimation fits known parameters, such as acceleration limits, inside a correct model family. Unmodeled residuals like actuator delay or contact effects fall outside it. The forward-invariance argument then fails, as Gap 2 of the file notes, citing Simulation-based reinforcement learning for real-world autonomous driving for the shifted dynamics. We inject exactly such out-of-family residuals, so this baseline's violation count tests the point.

Why not just make the quantum agent robust with noise-aware training? RoQNN recovers up to 43% accuracy on hardware by injecting noise during training. We will apply it to the quantum agent as its own arm. Our expectation is that it shrinks $\delta_i$ but does not eliminate drift. The two should therefore compose rather than compete. If RoQNN alone yields zero violations, the quantum regime simply adds no evidence for the filter, and we will say so.

Proposed Experiments

The main testbed is Safe MAMuJoCo (ManyAgent Ant and Coupled HalfCheetah) and the multi-agent Safety-Gymnasium tasks. We make teams heterogeneous by giving agents different actuator gains, masses and joint limits. The "real" environment applies per-agent unmodeled perturbations: actuator delay, friction shift, and slow drift, with severity sampled per agent. This lets us control the mismatch spread. Safe Multi-Agent Robosuite adds a dense manipulation case where QP infeasibility is most likely.

The quantum regime replaces one agent's policy with a PQC under calibrated noise. A final deployment check runs on cloud hardware, with commands batched to tolerate queue latency.

We measure cumulative collisions and cost events during training (not just at convergence), deployment violations, deadlock rate (no progress for a fixed window), QP infeasibility rate, team reward, and empirical coverage of each $\delta_i$ against its nominal level.

Three checks are decisive. First, as mismatch spread grows, the gap in deadlock and infeasibility rate between our filter and uniform tightening should widen while both keep violations near zero. A flat gap refutes the core claim. Second, Strategy C with nominal capability should accumulate violations proportional to injected out-of-family drift, while ours should not. Third, under an abrupt mid-episode shift that breaks exchangeability, we predict a short burst of violations bounded by the window length. Measuring that burst tells practitioners how fast $\delta_i$ must be recalibrated, which is the main practical limitation of the method.