Heterogeneous Teams as Error-Correcting Codes

When robots with different sensors work together, a faulty sensor on one of them does not stay local. A drone that misplaces a cup in its top-down image tells a ground robot where to reach, and the ground robot's failed grasp then becomes the team's failure. Quantum error correction has a mature habit of drawing exactly this kind of spread. You push a fault through a diagram and watch which "check" nodes light up and which protected quantities it corrupts without being seen. We propose to bring that habit to heterogeneous multi-agent teams. The team's shared beliefs about the world become the protected data. Places where two agents observe the same quantity through different sensors become the checks. The pattern of which agent reports what to whom becomes a code that can be designed and analyzed before any training.

The central observation is that heterogeneity helps here instead of hurting. In the coherent-parity-check picture of quantum codes, bit-flip and phase-flip errors are caught by different kinds of checks, and "cross-checks" catch the correlated case. A top-down camera and an egocentric camera fail in similarly complementary ways: one mislocates in height and under occlusion, the other in range and self-localization. We claim that assigning reporting duties so that heterogeneous observers form complementary checks gives more fault tolerance per message than identical redundant sensors at the same communication budget. We further claim that a simple diagram of how each fault moves through these checks predicts which faults will actually break team performance.

Core Claim

We model a team with a bipartite graph in the style of Quantum Codes From Classical Graphical Models. That paper represents data qubits as triangles and parity checks as stars, and it builds codes by editing the graph rather than deriving operators algebraically. In our version, the "data" nodes are world variables the team must agree on, such as object positions, teammate poses, and goal locations. Each agent contributes a measurement of some of these variables through its own sensor. A "check" node compares two or more measurements of the same variable, taken by agents with different modalities, against a tolerance.

Faults are typed by modality. For example, a height/occlusion fault belongs to the aerial view and a range/localization fault to the egocentric view. This mirrors the split into bit checks, phase checks and cross checks (matrices $B$, $P$, $C$) in Graphical Structures for Design and Verification of Quantum Error Correction. That paper verifies a code by pushing error nodes through rewrite rules until they either reach a syndrome measurement or silently alter data.

The quantity we design for is the analogue of code distance. Let $F$ be a set of agents whose sensors are faulty, $s(F)$ the set of checks that fire, and $\mathcal{L}(F)$ the set of decision-relevant variables that $F$ corrupts beyond tolerance. We define the team's fault distance as

$$d = \min \{\, |F| \;:\; s(F) = \emptyset,\ \mathcal{L}(F) \neq \emptyset \,\},$$

which is the smallest number of simultaneously faulty agents that can corrupt a decision without any check noticing. This is the team analogue of a "logical error" in a quantum code.

Given a communication budget of $K$ reported measurements per step, the design problem is to choose which agent reports which variable so that $d$ is maximized. Under the fault model, a budget spent on cross-modal checks should reach larger $d$ than the same budget spent on same-modality replication. The reason is that same-modality replicas share failure modes, so a single modality-level fault can zero their syndrome while corrupting the variable.

What is new relative to the closest work is that the parity structure lives in the physical sensing and communication layer of a heterogeneous team, and that it is designed for a guaranteed distance. Coding for Distributed Multi-Agent Reinforcement Learning also imports parity-check codes into multi-agent systems, but only to recover gradient updates from slow compute workers. It treats workers as identical and never touches sensing errors among physical agents. Dynamic Deep Factor Graph for Multi-Agent Reinforcement Learning uses factor graphs among agents, but its factors score joint payoffs and carry no error-detecting role.

Research Program

The work has three parts.

Design. We build a small solver that searches over reporting assignments for a given team and typed fault model and computes $d$ exactly by enumerating fault sets up to size three. This is feasible for the team sizes in the benchmarks below. We take the warning from Graphical Structures for Design and Verification of Quantum Error Correction seriously: random search over its check matrices stopped scaling beyond distance 3. We therefore restrict ourselves to small teams, where exhaustive verification is honest, and report explicitly where it stops scaling.

Propagation diagrams. For each single fault and each pair of faults, we trace the fault through two structures. First, the check graph tells us whether it is detected and whether it can be localized, meaning its syndrome is unique. Second, a coordination graph of which agent's action depends on which variable tells us which team decisions it reaches. The result is a per-fault "blast radius" that can be drawn and inspected. It is predicted before any policy is run, and we then test it against fault-injection experiments.

Using the syndrome. Fired checks are appended to each agent's observation. In addition, a variable whose syndrome localizes a fault to one agent has that agent's report masked in favor of the checking agent's report. The mask is a fixed rule, not a learned one, so that its effect can be separated from what the learner does. Policies are trained with standard heterogeneous learners, using the sequential per-agent updates of Heterogeneous-Agent Reinforcement Learning (HAPPO) and QMIX-style value mixing as in the CH-MARL baselines. In this project, those learners supply the method, and the codes are layered on top of them.

We deliberately borrow only the operational layer of the quantum toolkit: typed errors, typed checks, and fault pushing. We do not borrow shaded tangles or the ZX rewriting machinery. Shaded tangles for the design and verification of quantum circuits reports its calculus is sound but not complete, and nothing in the file suggests knot isotopy maps onto robot trajectories. Borrowing it would add formalism without testable content.

Baselines

The naive reference point is the CH-MARL communicating QMIX agent run exactly as published. This is the setup of CH-MARL: A Multimodal Benchmark for Cooperative, Heterogeneous Multi-Agent Reinforcement Learning, which pairs a top-down drone with an egocentric humanoid in VirtualHome. That paper reports unseen-layout success of 12.03% with a binary communication channel, 2.33% without communication, and 28.95% when policies receive ground-truth scene graphs instead of pixels. We rerun it with our fault injection, so that clean and faulted numbers come from the same code.

The strongest robustness competitor is distributionally robust value factorization, from Distributionally Robust Cooperative Multi-agent Reinforcement Learning with Value Factorization. It trains every agent's value against one shared worst-case adversary. It reports 10% to 40% higher average reward than non-robust QTRAN under climate and season shifts in SustainGym. On SMAC 3s_vs_5z with Gaussian observation noise, it reports only a qualitative win-rate improvement; there is no reported numeric result found on Lacuna for that setting. We give it the same fault-injected data and the same number of environment steps. Because that paper flags sensitivity to its uncertainty budget, we give it a tuning sweep over that budget matching our own tuning budget.

The strongest learned-structure competitor is MCGD, from Graph Diffusion for Robust Multi-Agent Coordination. It learns coordination edges by diffusion and reports up to 14.2% gains in shifted environments with disabled or degraded agents. This is the method most likely to learn, implicitly, to discount a faulty teammate. We run it on MPE and MAMuJoCo with our fault injection, using its published configuration and an equal compute budget.

Two ablations isolate the key ingredient. The first, random checks, keeps the same number $K$ of reported measurements but assigns them at random rather than to maximize $d$. The second, same-modality replication, spends the same budget on redundant reports from agents with the same sensor type. This is the homogeneous-redundancy analogue of the coded workers in Coding for Distributed Multi-Agent Reinforcement Learning. A third ablation feeds syndromes to the policy but disables masking, to separate detection from correction.

We count the proposal as beating a baseline only under specific conditions. The designed codes must match or exceed baseline success on clean episodes and exceed it under injected faults at matched budget. The margin must exceed the across-seed spread over five seeds. The gain must grow with fault rate rather than appearing only at one setting.

Why not just…?

Why not just train with noise, or with a worst-case adversary, and skip explicit checks? Robust training, as in DrIGM, makes each agent tolerate perturbation, but it does not tell any agent which teammate is wrong. Its own authors report that the uncertainty budget is brittle and can make policies overly cautious. Our claim is specifically about faults that are large but localized, such as one spoofed or biased sensor. A worst-case bound sized to such faults should be too conservative, and one sized smaller should miss them. This is a real threat for small, diffuse noise, where we expect DrIGM to match or beat us. The fault-magnitude sweep in the experiments below is designed to show where the crossover lies.

Why not just let a learned message-attention or graph model discover whom to trust? MCGD-style learned graphs can in principle learn this, and on in-distribution fault types they may. The case for designed checks is out-of-distribution: a fault type or fault location not seen in training. A learned gate has no guarantee there, while a code with $d \ge 2$ detects any single faulty agent by construction. We test this directly by holding out fault types and fault-bearing agents at test time. If MCGD matches us on held-out faults, the design component adds nothing beyond interpretability, and we will say so.

Why not just use classical residual tests between pairs of agents, or plain redundancy? Pairwise residual thresholding is exactly what our individual checks are. The question is which pairs to check under a fixed budget, and that is the part we contribute. The random-checks ablation measures the value of choosing well, and the same-modality ablation measures the value of heterogeneity itself. If random cross-modal checks do as well as designed ones, the contribution shrinks to "compare heterogeneous sensors." That would still be a finding, but a smaller one, and we would report it as such.

Proposed Experiments

The main testbed is CH-MARL in the scene-graph mode. There, world variables are explicit, and we inject typed faults into each agent's scene graph at controlled rates: drone faults as height and occlusion errors, humanoid faults as range and pose errors, and additionally constant bias, dropout, and adversarial displacement of one object. We measure four things: unseen-layout success, detection rate, localization accuracy, and false-alarm rate. Each is measured as a function of fault rate and communication budget $K$.

We run a second, natural-error test in the raw-pixel mode, where encoder mistakes supply real faults. There we ask whether cross-modal checks recover part of the gap between 12.03% and 28.95% that CH-MARL attributes to perception. This test is decisive in one direction: if designed checks recover none of that gap, our fault model does not describe real perception failures.

For continuous control and larger teams, we use MPE navigation and MAMuJoCo with MCGD's degraded-agent shifts, adding sensor faults on top. As a hardware sanity check, we use the Robotarium from The Robotarium: A remotely accessible swarm robotics research testbed. Its overhead-camera localization gives a second modality to check against onboard odometry.

The decisive checks are three.

First, at matched $K$, designed cross-modal codes must detect more faults and reach higher faulted success than same-modality replication. This is the claim that heterogeneity itself gives fault distance.

Second, the diagram-predicted blast radius of each single and paired fault, computed before training, must rank-correlate with the measured drop in success when that fault is injected into trained policies. We will report Spearman correlation across all enumerated faults, against a naive predictor that simply counts each agent's reported variables. If the diagram does not beat that count, the propagation-visualization half of the proposal fails.

Third, on held-out fault types, detection must stay near its designed guarantee while learned baselines degrade. If all three hold, heterogeneous teams can be engineered for fault tolerance the way codes are, before a single gradient step.