When one device on an Internet of Things (IoT) network detects an attack, the obvious move is to turn that detection into a rule and share it with every other device. On a network where a smart bulb, a Modbus industrial controller and an IP camera share the same address space, that move backfires. A rule tuned to a camera's traffic can flood a sensor's operators with false alarms, and a single poisoned rule can reach every device at once. Journals face the same kind of problem with manuscripts. They do not send every submission to every reviewer. An editor screens it, routes it to a few reviewers with matching expertise, accepts it into a specific venue or section, and escalates when reviewers disagree. We propose to build this workflow for shared intrusion-detection rules and test it. Each rule is reviewed only by validators drawn from the device classes it would affect. It is accepted or rejected separately for each class rather than globally. The total number of review evaluations is capped. Reviewer diligence is audited with planted "canary" rules whose correct verdict is already known.
In two sentences: treat detection rules as submissions and edge validators as a limited pool of specialized reviewers. Route, accept and audit by device class, and the network gets the benefit of shared threat intelligence without spreading false positives or poisoned rules to devices the rule was never meant for.
Core Claim
Under a fixed review budget, class-scoped review has four parts: expertise-matched assignment, per-class acceptance, escalation on disagreement, and canary audits. We claim it achieves lower post-deployment false-positive rates and lower poisoned-rule acceptance than flat, network-wide validator voting. We also claim it recovers most of the cross-class detection benefit that "keep every rule local" gives up. The new element is the unit of decision, which is a (rule, device class) pair rather than a rule, together with the rationing of validator effort. Neither appears in the closest existing systems.
What Exists and Where It Stops
The closest work is Decentralised Trustworthy Collaborative Intrusion Detection System for IoT. It splits nodes into contributors, validators and passive consumers, stores rules off-chain, and uses a smart contract to track validator reputation, filtering poisoned rules within 3 to 5 seconds. It supplies our reputation mechanics and our strongest baseline. It differs from our proposal in two ways. Every validator judges every rule identically, and a rule is accepted or rejected for the whole network. Its evaluation also ran on 15 Raspberry Pis with no device-class diversity. We keep its roles but change who reviews what and where the rule is allowed to go.
Two papers motivate the claim that scoping matters. Boosting-Based DDoS Detection in Internet of Things Systems sorts devices into four classes by how predictable their traffic is, measured as the coefficient of variation of received-to-sent byte ratios. It shows that class-specific models reach 99.92–99.99% accuracy where monolithic models do worse. Its classes are static and its models are never shared, so it says nothing about how intelligence should flow between classes. The cross-dataset drop reported in Intrusion Detection in IoT Using Deep Residual Networks with Attention Mechanisms, from 99.55% on ToN_IoT to 89.23% on UNSW-NB15, is further evidence that detectors transfer poorly across traffic distributions. That is exactly the failure scoped acceptance is meant to contain.
Hierarchical IoT learning systems supply the tiered structure but not the review semantics. Async-HFL runs a three-tier sensor–gateway–cloud hierarchy and selects clients by gradient affinity and diversity. FedDynST weights edge clients by loss and parameter divergence. In both, gateways combine numbers but never accept or reject content. ReSIoT offloads cryptography to edge agents that it assumes are honest-but-curious, and it does not check whether those agents do their work. That unchecked assumption motivates our canary audits.
The editorial and organizational literature constrains the design more than it supplies methods. Principal-agent analysis of multi-tier delegation, in Dong and Yang, names moral hazard: agents shirk when unobserved. A validator that approves rules without executing them is the IoT version. Multi-agent studies give a mixed verdict on hierarchy. In Multi-Agent Collaboration in Incident Response with Large Language Models, leaderless heterogeneous teams succeeded 12/20 times against 14/20 for centralized ones, but the centralized teams failed through rigid procedure-following. Embodied LLM Agents Learn to Cooperate in Organized Teams found that designated leaders help, but electing leaders dynamically raises communication cost. We read both results as a warning against adding language-model deliberation to the core. Our editor is a cheap, auditable routing and escalation policy, and we test whether adding a language model changes anything only as a secondary question.
Research Program
Rules. A rule is a short conjunction of thresholds over CICFlowMeter-style flow features. This keeps rules executable on modest gateways and easy to inspect. Contributors are per-class detectors, either logistic model trees as in Cvitic et al. or C5.0-style trees as in Zhu et al.. Each contributor trains on its own class's traffic and emits rules for the attacks it observes. A fraction of contributors are adversarial. Some craft rules that fire on a target class's benign traffic, which is a denial-of-service attack by false alarm. Others craft rules that effectively whitelist an attack.
Device classes. Traffic sources in each dataset are grouped into predictability classes using the Cvitic criterion. Each class hosts a small set of validators, each holding a private slice of that class's benign and attack traffic.
The desk step. A central editor sees only summary statistics from each class, such as per-feature quantiles, not raw traffic. It predicts which classes a rule would fire on. Rules whose predicted benign firing rate is extreme in every class are desk-rejected. For the remaining rules, the editor assigns a small number of validators from each relevant class.
Scoped acceptance. For rule $r$ and class $c$, each assigned validator $v$ reports an estimated benign firing rate $\hat f_{v}(r,c)$ and an attack-recall gain $\hat g_{v}(r,c)$ on its private data. The rule is deployed to class $c$ when
$$\sum_{v} w_v \big[\hat g_{v}(r,c) - \lambda\, \hat f_{v}(r,c)\big] > 0,$$
where $w_v$ is validator $v$'s normalized reputation and $\lambda$ is the operator's cost of one false alarm relative to one missed attack. If the reports disagree by more than a set margin, the rule is escalated. It then receives extra validators from the same class or a central evaluation on held-out data, and each escalation is charged against the budget.
Budget. The total number of (validator, rule) executions is capped at $B$ per round. Flat voting spends $B$ uniformly across validators, so the comparison between methods is at equal compute.
Canary audits. A small fraction of assigned rules are planted canaries whose true per-class verdict the editor already knows. Validator reputation $w_v$ is updated from canary agreement as well as from downstream outcomes. This targets validators that shirk or collude, which outcome-based trust detects only slowly.
Baselines
The naive reference points bracket the problem. The first is local-only: every rule stays in the class that produced it and no sharing happens. Any gain in cross-class recall has to beat this, and any false-positive comparison has to not lose badly to it. The second is broadcast-all, where every rule goes everywhere without review. It sets the ceiling on harm.
The strongest existing method is flat reputation-weighted voting as in Putra et al.. Every validator, regardless of class, evaluates rules on its own data, and a global trust-weighted vote decides network-wide acceptance. We reimplement its trust update off-chain so that ledger latency does not enter the comparison. It gets the same rules, the same adversarial fraction, and the same budget $B$, with validators subsampled uniformly when the budget binds. Its trust threshold is tuned on the same validation split used to tune $\lambda$ and the escalation margin for our method. Putra et al. report honest trust converging near 0.75 and malicious trust dropping to 0.1, with 3–5 s latency. For per-class false-positive rate or poisoned-rule acceptance under heterogeneous classes, I found no reported result on Lacuna. We therefore run this baseline ourselves. We count it as beaten if our method achieves a lower mean per-class benign false-positive rate and lower poisoned-rule acceptance at equal $B$, without lower held-out recall, across seeds, with non-overlapping 95% bootstrap intervals.
A second strong baseline is an oracle scoped evaluation that runs every rule on every class's full validation data. It is the upper bound that budgeted review approximates, and it tells us how much of the oracle's advantage we recover per unit of budget.
Three ablations each isolate one ingredient. Random assignment with per-class acceptance tests whether expertise-matched routing matters. Matched routing with global acceptance tests whether per-class decisions matter. Removing canaries tests the audit against shirking validators.
For context, the detection-accuracy literature reports 99.55% on ToN_IoT and 89.23% on UNSW-NB15 (ResNet-CBAM), and 0.9947 on Edge-IIoTset and 0.9932 on CICDDoS2019 (FedDynST). These are single-model classification accuracies, not rule-sharing outcomes. We use a centrally trained model of this kind only as a reference for the recall achievable with full data access.
Why not just…?
Why not just keep one strong central detector in the cloud? For raw accuracy on pooled data, a central model may well win. The file's ResNet-CBAM and FedDynST numbers suggest centralized learning is very accurate within a dataset. That model is the reference point, not the competitor, because the setting we study is one where raw industrial or healthcare traffic cannot leave its site (FedDynST; Gupta et al.). There, what gets shared is rules, not data. The cross-dataset drop reported by ResNet-CBAM also warns that a pooled model fails silently on unfamiliar classes. We report the central model's per-class false-positive rate alongside ours so the reader can see what privacy costs.
Why not just keep Cvitic-style per-class models and never share? This is the most serious threat. If attacks rarely transfer across classes, local-only is nearly as good and much simpler. Our leave-one-class-out experiment settles it directly: an attack is introduced only in class A, and we measure whether class B is protected. If local-only matches our cross-class recall, the proposal's benefit reduces to poisoning resistance. We would then report the idea as a defensive filter rather than a sharing mechanism.
Why not just use flat reputation voting, since it already filters poisoned rules? Putra et al.'s trust scores do separate honest from malicious validators. However, a rule that is correct for cameras and harmful for sensors is not a poisoned rule, and no validator reputation flags it. Global acceptance must either ship it everywhere or throw it away. The "matched routing with global acceptance" ablation measures exactly how much of our gain comes from per-class decisions rather than from better reviewers.
Why not just call this edge–fog–cloud and put a language-model team on top? The tier structure is indeed ordinary three-tier edge computing, and we do not claim otherwise. What is borrowed from editorial practice is specific: budgeted expert assignment, desk rejection, venue-scoped acceptance, and planted-item audits. None of these appears in Async-HFL. A language-model editor is tempting, but the incident-response results show rigidity and deadlock failures (Liu). We therefore test one only as a variant of the escalation step and keep it only if it lowers false positives at equal budget.
Proposed Experiments
The datasets are ToN_IoT, Edge-IIoTset, CICDDoS2019 and UNSW-NB15. Within each, traffic sources are partitioned into predictability classes by the Cvitic criterion. Validator data are disjoint per-class splits, and a held-out test period follows the review rounds.
The main experiment sweeps three settings: the budget $B$ (from one validator per rule up to all validators), the adversarial contributor fraction (0 to 30%), and the fraction of validators that shirk by approving without executing. The primary metrics are:
- mean and worst-class benign false-positive rate after deployment;
- held-out attack recall per class;
- poisoned-rule acceptance rate;
- rounds until shirkers' reputation falls below the honest mean.
The decisive checks are three. First, at the smallest budget where flat voting reaches its best poisoned-rule rejection, the worst-class false-positive rate under scoped review should be strictly lower. Second, in leave-one-class-out attack injection, scoped review should recover a large share of broadcast-all's cross-class recall while staying close to local-only's false-positive rate. If it cannot beat local-only on recall, sharing is not worth the machinery. Third, with canaries removed, shirkers should survive measurably longer, which would show the audit is what defends against moral hazard. A final robustness run recomputes predictability classes on shifted traffic windows. It checks whether stale class assignments, the static-class weakness Cvitic et al. inherit, erode the scoped method's advantage.
References
- Decentralised Trustworthy Collaborative Intrusion Detection System for IoT
- Boosting-Based DDoS Detection in Internet of Things Systems
- Intrusion Detection in IoT Using Deep Residual Networks with Attention Mechanisms
- Async-HFL: Efficient and Robust Asynchronous Federated Learning in Hierarchical IoT Networks
- A Dynamic Spatiotemporal Deep Learning Solution for Cloud–Edge Collaborative Industrial Control System Distributed Denial of Service Attack Detection
- Reconfigurable Security: Edge-Computing-Based Framework for IoT
- Dilemmas and Governance Strategies in the Implementation of the Modern Apprenticeship System in Chinese Vocational Colleges: A Perspective from Principal-Agent Theory
- Multi-Agent Collaboration in Incident Response with Large Language Models
- Embodied LLM Agents Learn to Cooperate in Organized Teams
- IoT Equipment Monitoring System Based on C5.0 Decision Tree and Time-Series Analysis
- Leveraging Trusted Execution Environments For Data Security in Healthcare Workflows