Edge sensors such as grid meters, roadside units and drones often have to agree on a shared physical quantity, for example a bus voltage or a target's position. Today's methods for this agreement treat any sensor that disagrees with the group as suspect and throw its reading away. That rule fails in two opposite ways. A sensor that disagrees because it is the only one seeing a real local event, such as a line fault or a load surge, gets silenced exactly when its reading matters most. A group of compromised sensors that feed the same well-crafted false value can also become the majority, so the honest sensors end up looking like the outliers. The Delphi method is a decades-old procedure for building consensus among human experts. It handles a version of the first problem: panelists whose ratings fall outside the group range are not dropped, but are asked to revise their rating or defend it in writing, and the next round takes that defense into account. We propose to carry this idea into machine agreement among edge devices, with one change that the human method lacks. When a disagreement is large, both the dissenters and the majority must justify their value with physical evidence that the other nodes can check themselves. No coordinator is trusted to judge the arguments.
Put in two sentences: when edge sensors disagree beyond a set tolerance, we do not discard the minority. We pause and ask every side to show that its value agrees with the laws of physics and with readings it does not control, and the agreement step then weights nodes by how well that evidence holds up. The bet is that this one change can keep honest sensors that have spotted real anomalies, and can resist coordinated false data that fools median-based agreement, while costing close to what the fast agreement protocols cost today.
What exists and where the gap is
The closest machine work is Delphi: Efficient Asynchronous Approximate Agreement for Distributed Oracles. The name is shared, but it is not a justification procedure. It is an approximate-agreement protocol, meaning nodes only need to land within a small tolerance of each other rather than on exactly the same value, and it does not need digital signatures. It cuts the number of messages from growing with the cube of the node count to growing with the square by assuming that honest readings follow a thin-tailed distribution, one where values far from the center are very rare. It reports only 0.05% error relative to the honest average on Bitcoin price feeds from 10 exchanges, and an 8x speedup over FIN and Abraham et al. on a 160-node Raspberry Pi cluster. This paper supplies our efficiency target and our main baseline. It also motivates the proposal, because its guarantee rests on honest readings clustering tightly. Correlated false injections and genuine local anomalies both break that premise, and the protocol has no way to tell them apart.
Edge Computing Method for False Data Injection Attack Detection in Electromechanical Transient Simulation Grid supplies one of our evidence channels. It flags falsified grid measurements by comparing them with a model that combines a standard power-flow solver (Newton-Raphson) with a neural network that predicts the next grid state from the recent history of the node and its neighbors (an LSTM). It reaches 99.71% detection on the IEEE-14 test grid, against 95.51% for PCA-SVM and 91.24% for a KL-divergence detector, and 87.6% on stealthy 5%-amplitude attacks. It is purely a local detector: once a node is flagged, nothing lets neighbors agree on the true state or tell a fault from an attack.
Consensus-based edge security covers the same ground from the voting side. LiteChain uses a committee chosen by reputation to vet federated-learning updates. Blockchian Based Hybrid Consensus Algorithm for Data Security in Edge Computing puts a fixed set of trusted authority nodes in front of a standard Byzantine voting stage. Both decide by vote or by trusted authority, and the second admits that it concentrates risk in those authorities. Our design has no trusted judge. Each node re-checks the evidence on its own.
The human Delphi literature supplies the procedure. Byrne et al. and Dombrowski et al. describe anonymous rounds with feedback, in which outliers revise or defend their ratings. That literature also documents two failure modes that constrain our design. The first is coordinator bias, since a central facilitator summarizes the arguments and can filter dissent. The second is collusion, since a panel that shares a bias can lock in a wrong answer. In the edge setting, collusion is exactly the coordinated injection attack, and it is the reason the burden of proof has to fall on the majority as well as the minority. An LLM-based Delphi Study to Predict GenAI Evolution and AI Agents and the Future of Deliberation automate who takes part in Delphi panels or deliberations. They still argue in natural language over multi-week timescales and say nothing about devices that might be compromised.
Core Claim
Consider an agreement protocol among $n$ edge nodes. Suppose that, whenever the spread of proposed values exceeds a tolerance $\tau$, the protocol inserts a single justification round. In that round each node $i$ broadcasts a short evidence packet, and every node computes for itself a residual
$$r_i = \lVert z_{N(i)} - h(\hat{x}_i) \rVert + \lambda \lVert \hat{x}_i - f(x_{t-1}) \rVert,$$
where $\hat{x}_i$ is the local state implied by node $i$'s claimed value, $z_{N(i)}$ are the raw measurements of $i$'s physical neighbors, $h$ is the known power-flow measurement map, $f$ is the shared temporal predictor (the LSTM of Yang et al.), and $\lambda$ trades off physical consistency against temporal consistency. Nodes are then weighted by $w_i = \exp(-r_i/\sigma)$, with $\sigma$ the scale of honest residuals estimated from clean history, and agreement proceeds on the weighted values. A dissenter with a low residual keeps its weight even when it is alone. A majority whose claims do not fit uncompromised neighbors loses weight even though it is large.
Our claim covers attackers who control a subset of nodes whose injected values cannot be made consistent with every honest neighboring measurement. We do not claim robustness against an attacker who can falsify a complete stealthy set across the network. In that case no evidence local to the network can expose the attack, and we will report this boundary explicitly.
Research Program
We will build the protocol as a layer on top of the asynchronous approximate-agreement protocol from the Delphi-oracle paper. The fast path, where there is no disagreement, stays unchanged, so the added cost is paid only in rounds that trigger a justification round. The evidence packet is restricted to quantities the node already holds, namely its measurement, its claimed state, and a hash of its recent window, so that it fits within the bandwidth budget of a microcontroller.
The analysis has two parts. The first is a bound on the residual gap between honest and injected claims as a function of how many of the attacked node's neighbors the attacker controls. This identifies the measurement topologies where justification helps and the ones where it cannot. The second is an accounting of the extra messages per triggered round, together with how often rounds trigger under clean operation. The protocol is useful only if justification rounds are rare under clean conditions and rare enough under attack that the cost stays close to that of the base protocol.
Baselines
The naive reference point is a plain mean of all proposed values with no outlier handling. It shows how much damage each attack does when nothing defends against it.
The one-shot robust aggregators come next: coordinate-wise median, trimmed mean and Krum, taken from the ByzantineMomentum codebase. They represent "just clip the outliers", and they will be run on identical measurement streams.
The strongest agreement baseline is the protocol from Delphi: Efficient Asynchronous Approximate Agreement for Distributed Oracles. It reports 0.05% error relative to the honest average on its Bitcoin feeds and an 8x speedup over FIN on Raspberry Pi clusters. We found no reported result on Lacuna for this protocol under coordinated false injections or genuine local faults. We will therefore rerun it ourselves on the same Raspberry Pi cluster sizes, using the same checkpoint settings as its authors.
The strongest detection baseline is the LSTM detector of Yang et al., run at each node, followed by exclusion of flagged nodes and median agreement on the rest. It reports a 99.71% detection rate on IEEE-14 and 87.6% under 5%-amplitude stealth attacks. It will receive the same training data and the same threshold-tuning budget as our temporal predictor $f$, which is that very LSTM, so any difference comes from how evidence is used rather than from a stronger model.
Two ablations isolate the key ingredient. The first is "always justify": the evidence round runs every time rather than only on disagreement. It shows whether triggering only on disagreement costs accuracy. The second is "outliers only": only the minority must justify, as in human Delphi. It shows whether placing the burden on both sides is what defeats coordinated attacks.
Beating the field means three things on the same streams. Against the LSTM-plus-exclusion baseline, we must achieve lower state-estimation error under coordinated injection and wrongly exclude fewer honest sensors during genuine faults. We must also match it within noise on clean data. On message count, we must stay within a small constant factor of the Delphi-oracle protocol.
Why not just…?
Why not just run the LSTM detector at every node and drop whatever it flags? This is the most serious competitor. Yang et al. show that it catches most single-node attacks. But their detector flags any deviation from the predicted state, and a genuine fault deviates from that prediction just as an attack does. Their paper reports no way to tell the two apart and no way to recover the true state afterwards. The fault-injection experiment below measures directly how many honest, fault-observing sensors this baseline discards. If it discards almost none, our contribution shrinks to the coordinated-attack case, and we will say so.
Why not just use the median or the Delphi-oracle protocol, which already tolerate a Byzantine minority? These methods treat the bulk of the distribution as the truth. When colluding nodes make up the bulk at a given location, or when only one honest node sees a real event, the median is wrong by construction. The coordinated-cluster experiment tests whether physical evidence changes that outcome.
Why not just run classical physics-based bad-data detection on every reading? That is essentially the "always justify" ablation. If it matches our accuracy at acceptable cost, the Delphi-style triggering contributes only efficiency. We will report the message and latency gap on Raspberry Pi hardware, so that this question is settled by numbers rather than by framing.
Proposed Experiments
The main testbed is the IEEE-14 grid, simulated in MATPOWER as in Yang et al. We extend it with two families of scenarios. The attack scenarios are coordinated stealthy injections in which $k$ of the measurement nodes are compromised, with $k$ swept from one node up to a full stealthy set, at 5% and 10% amplitudes. The genuine-anomaly scenarios are line trips and load surges seen first by a single node. The second testbed is the drone object-detection dataset from the Delphi-oracle paper, extended with correlated bounding-box drift attacks. For the evidence channel there, neighboring drones' overlapping views of the same target play the role that the power-flow equations play in the grid.
The metrics are state error relative to the true simulated state; the rate at which honest sensors observing a real anomaly are excluded; attack-node exclusion rate; messages and bytes per agreement; and wall-clock latency on a 160-node Raspberry Pi cluster.
Three checks are decisive. Under coordinated injection that covers less than a full stealthy set, the proposal should keep error near its clean-data level while the median and Delphi-oracle baselines drift toward the attacker's value. During genuine faults, it should exclude far fewer honest sensors than LSTM-plus-exclusion. The "outliers only" ablation should fail on the coordinated-cluster scenario. If that ablation does not fail there, the symmetric burden of proof is not doing the work we claim, and the proposal needs revision.
References
- Delphi: Efficient Asynchronous Approximate Agreement for Distributed Oracles
- Edge Computing Method for False Data Injection Attack Detection in Electromechanical Transient Simulation Grid
- LiteChain: A Lightweight Blockchain for Verifiable and Scalable Federated Learning in Massive Edge Networks
- Blockchian Based Hybrid Consensus Algorithm for Data Security in Edge Computing
- An international, Delphi consensus study to identify priorities for methodological research in behavioral trials in health research
- Conservative Management and Biological Treatment Strategies: Proceedings of the International Consensus Meeting on Cartilage Repair of the Ankle
- An LLM-based Delphi Study to Predict GenAI Evolution
- AI Agents and the Future of Deliberation: Designing Human-AI Collaboration for Democratic Dialogue