A swarm of half-blind sensors just learned to see — and to understand its own physics

Swarms of robots exploring a collapsed building, constellations of sensors watching a power grid, fleets of drones tracking an oil spill — in all of these, the hardware shares a quiet fantasy: that each node can see everything. It can't. Every sensor sees only a sliver of the state, each robot feels only its own joints and wheels, and the physics steering the whole system is often a mystery even to the engineers who built it. For decades, control theory has offered two separate fixes: observers that reconstruct hidden states from partial measurements, and learning algorithms that reverse-engineer unknown dynamics. But almost nobody had solved both at once, in a distributed network, in discrete time, where some nodes barely have any data at all. A new paper takes on exactly that tangle — and the researchers behind it, spanning the Technical University of Munich, HKUST-Guangzhou, Tongji, and USTC, propose a method they call COIN-GP that lets a network of partially blind, partially ignorant sensors teach each other into full clarity.

The key move is deceptively simple: instead of demanding that every sensor sees enough to learn on its own, the network lets neighbors share what they've learned, so that a robot with rich data can effectively lend its understanding to a robot with almost none. The result, the authors show both theoretically and in simulation, is a networked system that estimates both its hidden states and its unknown physics within provable error bounds — even when no single agent could have done it alone.

The Science

The setup is a class of systems called discrete-time Lur'e systems, which sound esoteric but describe something incredibly common. A Lur'e system is a linear dynamical core — think of the known, well-modeled part of a robot arm or a sensor platform — wrapped around an unknown nonlinear function $f(\cdot )$. The dynamics take the form

$${\mathbf{x}}_0(k+1)=\mathbf{A}{\mathbf{x}}_0(k)+\mathbf{B}\mathbf{f}({\mathbf{x}}_0(k)),$$

where $\mathbf{A}$ and $\mathbf{B}$ are known matrices describing the system's structure, and $f$ is the unknown function capturing latent trends like friction, drag, or a manipulator's gravity terms. The $N$ sensors each measure a partial slice of the state through

$${\mathbf{y}}_i(k)={\mathbf{C}}_i{\mathbf{x}}_0(k)+{\mathbf{v}}_i(k),$$

where each ${\mathbf{C}}_i$ is a known measurement matrix and ${\mathbf{v}}_i$ is bounded noise. Each sensor's view is incomplete — the pair $(\mathbf{A},{\mathbf{C}}_i)$ is observable in the technical sense, meaning the state could be reconstructed if the dynamics were fully known. But they're not. And that's the crux: traditional observers like the Luenberger filter assume a fully known model, so they're helpless when the nonlinear term is a mystery. High-gain observers and sliding-mode observers have their own problems when discretized — peaking phenomena, chattering, and instability from finite sampling rates.

So the authors turn to Gaussian process (GP) regression, a Bayesian machine learning method that treats the unknown function as a random draw from a distribution over functions defined by a kernel. GP regression has a prized property: it doesn't just give a prediction, it gives a prediction with a rigorous error bound. Given a training set $\mathbb{D}$ of $M$ noisy observations, the posterior mean $\mu (\mathbf{\xi })$ estimates $f(\mathbf{\xi })$, and the posterior variance ${\sigma }^2(\mathbf{\xi })$ quantifies uncertainty. Under mild smoothness assumptions — the function must belong to a reproducing kernel Hilbert space with bounded norm — the error satisfies

$$|\mu (\mathbf{\xi })-f(\mathbf{\xi })|\le \sqrt{\beta }\sigma (\mathbf{\xi }),$$

a deterministic bound inherited from the theory developed by Srinivas et al. This is what makes GP-based methods attractive for safety-critical control: you can prove your model error stays small, something neural networks can't offer.

The authors had already been developing adaptive observers that jointly estimate states and unknown dynamics (Yang, Dai, et al., 2025), and some prior work had married that idea with GPs. But nearly all of it assumed full state measurement, and prior distributed GP methods — like the product-of-experts aggregation or average consensus algorithms — were designed for offline datasets that never update during operation. They couldn't adapt as new measurements streamed in. And they assumed every subsystem maintained its own GP model with sufficient data.

COIN-GP breaks each of these assumptions. The network can now learn online, with partial measurements, in discrete time, and — crucially — without requiring every subsystem to hold its own GP model.

What They Found

The paper delivers three contributions, each with teeth. First is the data collection strategy. Here's the subtle problem: to train a GP on $f(\cdot )$, you need input-output pairs $(x,f(x))$. But with partial measurements and unknown dynamics, you can't directly observe $f(x)$ — the sensor's output is a garbled mix of the hidden state and the unknown function. The authors solve this by exploiting a structural identity. If $(\mathbf{A},{\mathbf{C}}_i)$ is observable, then by the Cayley–Hamilton–type relation in their Lemma 2, there exist matrices ${\mathbf{H}}_{i,d}$ such that

$${\mathbf{C}}_i{\mathbf{A}}^n=\sum _{d=0}^{n-1}{\mathbf{H}}_{i,d}{\mathbf{C}}_i{\mathbf{A}}^d.$$

This lets them define an auxiliary signal ${\tilde{\mathbf{y}}}_i(k)$ built purely from shifted measurements, which isolates the contribution of the unknown function. The insight is that they can construct valid training pairs — noisy observations of $f$ evaluated at reconstructed states — even though no single sensor ever measures the full state. They then prove a "data collectability" condition: a set of sufficient conditions guaranteeing that enough usable training data can be acquired. This is not hand-waving; it's a formal theorem with a noise-propagation analysis.

Second is the COIN-GP algorithm itself. Each sensor runs a local observer to estimate the global state, but the GP predictions are shared across the network. When a sensor's own dataset is too poor to be reliable — or when it has no GP model at all — it leans on its neighbors' predictions, weighted by their uncertainty. This is what the authors call dynamic cooperative learning: the sharing isn't static but adapts as data arrives, and a subsystem with rich data effectively becomes a teacher for its data-poor neighbors. The whole point is that not every subsystem needs inference capability — an explicit design goal no prior method achieved.

Third, and most important for real-world safety, is the joint error bound. The authors derive an upper bound that simultaneously covers the state estimation error and the model prediction error,

$$\Vert \mathbf{x}(k)-1_N\otimes {\mathbf{x}}_0(k)\Vert \le {ϵ}_x\text{and}\Vert \hat{\mathbf{f}}(\mathbf{x}(k))-1_N\otimes \mathbf{f}({\mathbf{x}}_0(k))\Vert \le {ϵ}_f,$$

for all $k$ beyond some transient horizon, with the boundedness built up from the deterministic GP error bounds and the stability of the observer dynamics. In plain terms: the network provably converges to within a specified tolerance of the true states, and its learned model of the physics provably stays within a specified tolerance of the true dynamics. For systems that interact with people — rehabilitation robots, assistive devices, industrial platforms — a guarantee like this is the difference between "probably fine" and "provably safe."

The simulations back this up. The authors run comparative experiments against existing distributed GP aggregation frameworks, including product-of-experts and other established baselines, and COIN-GP consistently outperforms them — both in state estimation error and in how well the learned function matches the true dynamics. The advantage is especially pronounced in the regime the paper was designed for: when some subsystems have limited or poor training data, the cooperation mechanism lets them catch up rather than fall behind.

Why This Changes Things

To appreciate what's new here, consider the state of play before. Distributed observers for multi-agent systems had been built for leader-following consensus and formation tracking, but those methods either handled state estimation or unknown-function modeling — never both at once. When GP was brought in, it was usually in a single-system setting, or with the unrealistic assumption that every sensor sees the full state and has a full dataset. Meanwhile, the neural-network-based distributed observers require the unknown function to be a linear combination of known features — a strong structural prior that real physics rarely honors.

COIN-GP clears all three obstacles simultaneously. It handles partial measurements, it learns the unknown dynamics online from streaming data, and it works in discrete time — the natural setting for anything digital, since every real controller runs on a clock with finite sampling. And it does away with the requirement that every node be self-sufficient.

That last point deserves emphasis, because it's quietly revolutionary for deployment. The hardware reality of sensor networks and robot swarms is that nodes are not created equal. Some have clean sightlines and rich measurements; others sit in a dark corner of the state space. The standard approach says: give every node enough data to learn, or accept that some nodes stay stupid. COIN-GP says: let the well-informed nodes carry the curve, and stream their understanding to the disadvantaged ones through the communication graph. It's collective intelligence with a formal safety certificate — the swarm raises its weakest members, and the guarantee covers everyone, not just the sensors with the best data.

There's a deeper conceptual point, too. The joint error bound isn't just a mathematical nicety; it's the kind of result that lets engineers sign off on autonomy. When you put a machine-learning model inside a control loop, the classical objection is that a learned model has no correctness certificate — it could be confidently wrong exactly where it matters. COIN-GP answers that objection with the GP's deterministic error bound, then composes it across the network so that the guarantee survives the messiness of partial observability and distributed communication. The bound on $\beta \le {\Gamma }^2+M$ shows how the confidence scales with data, and the falloff of the posterior variance as training points accumulate means the network genuinely sharpens its understanding over time.

What's Next

The authors are appropriately honest about the boundaries of what they've built. The scalar-function assumption ($m=1$) is a simplification, though they note it extends to multi-output cases by assuming independent outputs — a standard, if slightly coarse, reduction. The communication graph is undirected, which means information flows symmetrically between neighbors; real deployments sometimes have one-way links or switching topologies, and the authors' own prior work on switching topologies (Yang et al., 2024) suggests they're already thinking about that generalization. The observability condition per sensor is retained, even if it's relaxed from "every sensor needs its own GP"; a natural next step is to ask whether the network as a whole can be observable even when individual sensors are not.

The most exciting horizon is probably the control side. This paper stops at estimation — it proves the network can see the truth, not that it can steer toward it. But a provably convergent state-and-model estimator is precisely the substrate that safe, learning-based control gets built on. Pair COIN-GP with a model-predictive or learning-based controller, and you have a closed loop where the learning has a certificate and the control has a reliable model to plan with. For rehabilitation exoskeletons that must adapt to a wearer's gait, for fleets of drones operating in wind fields they can't fully model, for underwater vehicles navigating currents that shift mid-mission — that's the difference between autonomy that's an experiment and autonomy that's a product.

There's also the quiet matter of practicality. The authors cite recent data-driven methods for estimating the RKHS norm bound $\Gamma$, which removes what used to be a fiddly hyperparameter. And the cooperative architecture means you can deploy a network where some nodes carry the computational burden of GP inference while others are light — cheap, power-constrained sensors that contribute measurements and receive wisdom, without having to host a model themselves. That distribution of labor maps cleanly onto real hardware constraints, where battery life and compute budgets are as real as any theorem.

The paper closes a loop that has been open for a while: distributed systems can now jointly see their hidden states and learn their unknown physics, with guarantees, from partial measurements, online. The next wave of research will push that loop forward — into switching topologies, directed graphs, multi-output functions, and finally into control. But the foundation is laid, and it's a remarkably sturdy one: a networked swarm that turns many partial, uncertain views into a single, provably accurate picture of the world.