Trust-Aware Federated Graph Learning for Secure and Energy-Efficient IoT Ecosystems

Abstract

The integration of Federated Learning (FL) and Graph Neural Networks (GNNs) has emerged as a promising paradigm for distributed intelligence in Internet of Things (IoT) environments. However, challenges related to trust, device heterogeneity, and energy efficiency continue to hinder scalable deployment in real-world settings. This paper presents Trust-FedGNN, a trust-aware federated graph learning framework that jointly addresses reliability, robustness, and sustainability in IoT ecosystems. The framework combines reliability-based reputation modeling, energy-aware client scheduling, and dynamic graph pruning to reduce communication overhead and energy consumption during collaborative training, while mitigating the influence of unreliable or malicious participants. Trust evaluation is explicitly decoupled from energy availability, ensuring that honest but resource-constrained devices are not penalized during aggregation. Experimental results on benchmark IoT datasets demonstrate up to 5.8% higher accuracy, 3.1% higher F1-score, and approximately 22% lower energy consumption compared with State-of-the-Art federated baselines, while maintaining robustness under partial adversarial participation. These results confirm the effectiveness of Trust-FedGNN as a secure, robust, and energy-efficient federated graph learning solution for heterogeneous IoT networks (a proof-of-concept evaluation across 10 federated clients).

1. Introduction

The proliferation of Internet of Things (IoT) devices has fundamentally transformed the data landscape: billions of sensors, wearables, smart-mobility nodes, and edge endpoints continuously generate streams of heterogeneous information from highly distributed locations. This shift from centralized to highly distributed data sources presents both opportunities and challenges for machine learning. Traditional centralized model training approaches face serious limitations in IoT contexts—data privacy and sovereignty concerns, bandwidth and latency constraints, device heterogeneity, and non-IID (independent and identically distributed) data distributions—that complicate scalable deployment of classical approaches [1,2].

In response, Federated Learning (FL) has emerged as a compelling paradigm for enabling collaborative model training across distributed IoT devices without requiring raw-data centralization [3,4]. In a typical FL setup, each device trains a local model on its own data, then shares only model updates with a coordinating server or aggregator, thereby preserving data locality and upholding privacy. Especially for IoT systems—characterized by limited compute, heterogeneous devices, dynamic network connectivity, and energy constraints—FL offers a pathway toward scalable, privacy-aware learning [3].

However, while FL addresses many concerns of centralized approaches, several key challenges remain open in the IoT domain. First, trust and security are critical: IoT devices may be compromised, hostile, or unreliable, and adversarial behavior (poisoning, model inversion, sybil attacks) can degrade the integrity of the federated model. Without robust trust-aware mechanisms, FL in IoT environments remains vulnerable [5]. Second, energy efficiency is often overlooked: devices engaged in FL must perform local computations, communicate model updates, and potentially stay active in dynamic networks—these operations impose energy and latency overheads, which are significant for battery-powered or resource-constrained IoT endpoints [6]. Third, the structural and relational nature of many IoT networks suggests that models that ignore topology—treating devices as independent nodes—may be sub-optimal. Graph Neural Networks (GNNs) have shown promise in modeling the relational structure of nodes and edges, capturing interactions, propagation paths, and network topology effects [6].

Taken together, these observations point to a convergence of three research directions: federated learning, graph-structured modeling, and trust/energy-aware design in IoT ecosystems. Although several studies have independently explored trust mechanisms in federated systems [5,7], topology-aware modeling through GNNs [8,9], and energy-efficient aggregation strategies [6,10], no existing framework jointly addresses these three challenges within a single, unified design. Existing trust-aware FL methods often ignore the graph relationships among IoT devices, while graph-based approaches rarely account for dynamic trust propagation or energy-adaptive scheduling. Furthermore, most energy-aware federated systems still assume homogeneous client reliability and communication links, limiting their applicability to real-world, large-scale IoT environments; in this paper we provide a 10-client proof-of-concept evaluation and discuss scalability considerations.

This paper addresses this gap by proposing Trust-FedGNN, a novel framework that unites federated graph learning with trust management and adaptive energy optimization specifically for IoT ecosystems. Our contributions can be summarized as follows:

• We develop a trust-aware federated graph learning model that incorporates device reputation, dynamic trust updating, and malicious-node mitigation within an IoT FL context.
• We introduce a graph-pruning and adaptive communication scheduling layer to minimize energy consumption and latency while maintaining model accuracy.
• We validate the proposed framework on realistic IoT datasets and scenarios, demonstrating improvements in detection accuracy, resilience to adversarial behavior, and reductions in energy/communication overhead relative to baseline FL and GNN models.

The remainder of this paper is organized as follows. Section 2 reviews the background and related work on federated learning in IoT, graph neural networks, trust mechanisms, and energy-aware edge computing. Section 3 presents the design of the Trust-FedGNN framework. Section 4 describes our experimental setup, benchmarks, and results. Finally, Section 5 concludes and outlines future research directions.

2. Background and Related Work

2.1. Federated Learning in IoT

Federated Learning (FL) has become a cornerstone for overcoming the limitations of centralized data processing in Internet of Things (IoT) ecosystems—particularly regarding data privacy, device heterogeneity, and communication constraints.

Recent works such as “Federated Learning for IoT: A Survey of Techniques, Challenges, and Applications” provide a comprehensive overview of how FL architectures address privacy and bandwidth issues in large-scale IoT environments [1].

Similarly, “Federated Learning: A Cutting-Edge Survey of the Latest Trends” highlights algorithmic innovations that reduce communication overhead and enable training on resource-constrained edge devices [11].

However, most existing studies primarily emphasize communication efficiency or privacy preservation, with limited exploration of energy efficiency and trust in real-world heterogeneous IoT networks.

2.2. Graph Neural Networks for Distributed Intelligence

While FL manages decentralized training, many IoT environments are inherently relational—devices form topological graphs connected by data or communication links.

Graph Neural Networks (GNNs) are therefore emerging as powerful tools to model such interdependencies by encoding nodes, edges, and their spatial-temporal relationships.

The recent surveys on Graph Neural Networks for IoT and NextG Networks outline key advances in using GNNs for IoT and 6G network optimization [9,12].

Furthermore, “A Comprehensive Survey on Trustworthy Graph Neural Networks” discusses privacy, robustness, and explainability aspects—directly relevant for trust-aware federated learning [8].

Nevertheless, the combined use of GNNs, FL, and energy-efficient trust modeling in IoT systems remains underexplored.

2.3. Trust and Security in Federated Systems

Trust is a critical enabler for federated architectures, especially in distributed IoT environments where malicious, compromised, or unreliable nodes may exist.

The study “Trust in Edge-Based Internet of Things Architectures” presents an extensive discussion on trust evaluation mechanisms in edge/IoT computing [13].

More recently, “Trust Management for IoT Devices Based on Federated Learning and Blockchain” integrates federated reputation modeling with blockchain validation to ensure data integrity and reliability in IoT systems [7].

These studies reinforce the importance of embedding trust-awareness into federated IoT learning—but they seldom consider the associated communication and energy trade-offs or exploit graph-structured representations of device interactions.

Beyond applied trust management mechanisms, a related and well-established line of research in graph theory studies diagnosability and fault identification in networked systems, i.e., the ability to infer faulty or unreliable nodes from local interaction outcomes and consistency relations over a network topology. Classical diagnosis models (e.g., self-comparative/comparison-based settings and the g-good-neighbor property) formalize when local checks among neighboring nodes are sufficient to isolate malfunctioning components under bounded failures. Recent advances further strengthen these conditions for large-scale topologies, including global reliable diagnosis results under self-comparative and g-good-neighbor assumptions [14].

Importantly, we refer to this body of work only as conceptual inspiration: it motivates designing trust mechanisms that exploit topology-aware, local-consistency signals rather than relying solely on centralized, global assumptions. In our setting, however, the “tests” are data-driven (e.g., validation consistency and update-behavior indicators), the environment is non-stationary and non-IID, and the learning dynamics do not match the premises of classical diagnosis theory. Therefore, Trust-FedGNN should be understood as a learning-based trust heuristic informed by the intuition of topology-driven reliability, and it does not claim formal diagnosability guarantees.

2.4. Energy Efficiency in Edge/Federated AI for IoT

Energy consumption remains a major bottleneck in edge and federated AI deployments.

Battery-powered IoT nodes must perform local training, data transmission, and periodic aggregation—operations that can significantly drain power if not optimized.

The comprehensive survey “A Comprehensive Survey on Energy-Efficient and Privacy-Preserving Federated Learning for Edge Intelligence and IoT” provides a systematic review of methods that jointly consider energy consumption, communication overhead, and privacy preservation in constrained IoT/edge federated learning settings [10].

Likewise, “Optimal Directed Acyclic Graph Federated Learning Model for Energy-Efficient IoT Communication Networks” introduces adaptive graph-based aggregation to minimize energy costs [6].

Nonetheless, most frameworks still treat energy optimization separately from trust management and topology-aware modeling.

This section has identified four major pillars underpinning the proposed work:

(1)

Federated learning for distributed IoT intelligence;

(2)

Graph neural networks as topology-aware learning frameworks;

(3)

Trust and security mechanisms in federated environments; and

(4)

Energy efficiency for sustainable edge computing.

While each dimension has advanced independently, a unified model that jointly optimizes trust, topology, and energy in federated IoT learning remains largely absent. The proposed Trust-FedGNN framework directly addresses this gap by integrating these dimensions into a cohesive design.

3. Proposed Framework: Trust-FedGNN

This section introduces the proposed Trust-FedGNN framework, which integrates trust-aware modeling, graph-structured representation learning, and energy-efficient federated optimization for secure and sustainable IoT ecosystems. The framework builds upon the principles of federated graph learning but extends them with a lightweight trust and reputation layer and an adaptive energy-aware communication scheduler.

3.1. System Overview

In conventional Federated Learning (FL), each IoT node trains a local model on its private data and transmits gradients or model weights to an aggregator. However, these aggregations often assume that all nodes are equally reliable and that the network topology is fully connected—assumptions that rarely hold in dynamic IoT environments.

The Trust-FedGNN architecture introduces two key innovations:

(1)

A graph-based representation of the IoT network, where each device is a node and edges encode communication or data-correlation strength.

(2)

A trust-adaptive aggregation layer that assigns dynamic reputation weights to nodes during model fusion, discouraging contributions from potentially malicious or unreliable participants.

The resulting architecture (Figure 1) comprises three layers:

Local Learning Layer: Nodes train GNN sub-models on their own graph partitions or local sensor streams.

Trust Management Layer: A trust coefficient ${\tau }_i$ is updated based on model consistency, behavioral metrics, and historical reliability.

Federated Aggregation Layer: The central or hierarchical aggregator performs trust-weighted model fusion while minimizing communication frequency according to energy budgets.

In Trust-FedGNN, the graph does not represent raw data relationships or shared samples across devices. Instead, it models a logical interaction topology among IoT nodes, where vertices correspond to devices and edges encode abstract interaction strength derived from locally computed statistics, such as feature similarity, communication history, or temporal correlation patterns. Importantly, adjacency information is constructed locally at each client, and no raw data, explicit neighborhood lists, or sensitive inter-device relationships are transmitted to the server. Only aggregated statistics or lightweight structural indicators (e.g., pruning masks or sparsity patterns) are shared during federated aggregation. This design preserves the core privacy guarantees of federated learning while still enabling topology-aware representation learning.

3.2. Trust Modeling and Reputation Update

Trust evaluation in Trust-FedGNN is designed to capture behavioral reliability while remaining robust to heterogeneous resource constraints commonly observed in IoT environments. To this end, we explicitly decouple reliability trust from energy availability, ensuring that honest but resource-constrained devices are not misclassified as unreliable or malicious.

3.2.1. Reliability Trust

For each client (node) $i$, a reliability-based trust score $T_i^{\left(t\right)}$ is maintained and updated at each federated round $t$ using an exponential smoothing rule:

$$T_i^{\left(t\right)}=\mathsf{\alpha }{T}_i^{\left(t-1\right)}+\left(1-\mathsf{\alpha }\right)\hspace{0.17em}{r}_i^{\left(t\right)},$$

where $\mathsf{\alpha }\in \left[\mathrm{0,1}\right]$ controls the influence of historical behavior, and $r_i^{\left(t\right)}$ denotes the instantaneous reliability score observed at round $t$. This formulation ensures temporal stability while allowing the trust score to adapt to recent client behavior.

Instantaneous Reliability Score. The instantaneous reliability score $r_i^{\left(t\right)}$ is computed as a weighted combination of two behavioral indicators: model-update consistency and validation performance consistency,

$${\tilde{r}}_i^{\left(t\right)}={\mathsf{\beta }}_1\hspace{0.17em}\mathsf{\varphi }\left(d_i^{\left(t\right)}\right)+{\mathsf{\beta }}_2\hspace{0.17em}\mathsf{\psi }\left(a_i^{\left(t\right)}\right),$$

where ${\mathsf{\beta }}_1,{\mathsf{\beta }}_2>0$ are weighting coefficients controlling the relative influence of divergence-based and validation-based indicators. No constraint ${\mathsf{\beta }}_1+{\mathsf{\beta }}_2=1$ is required, as explicit normalization is applied subsequently.

Model-Update Divergence. Model update divergence is measured as the normalized ${\mathrm{l}}_2$ distance between the local model parameters and the current global model:

$$d_i^{\left(t\right)}={\displaystyle \frac{{‖w_i^{\left(t\right)}-w^{\left(t\right)}‖}_2}{{‖w^{\left(t\right)}‖}_2+\mathsf{\epsilon }}},$$

where $w_i^{\left(t\right)}$ denotes the local model parameters of client $i$ after round $t$, $w^{\left(t\right)}$ is the global model, and $\mathsf{\epsilon }$ is a small constant introduced for numerical stability. The divergence-based reliability component is defined as

$$\mathsf{\varphi }\left(d_i^{\left(t\right)}\right)=\mathrm{e}\mathrm{x}\mathrm{p}\left(-d_i^{\left(t\right)}\right)$$

which ensures boundedness in $\left(\mathrm{0,1}\right]$ and penalizes highly inconsistent or anomalous updates.

Remark on non-IID heterogeneity: A large parameter divergence can arise either from malicious behavior or from benign statistical heterogeneity (e.g., a sensor operating under a rare but valid condition). Trust-FedGNN, therefore, does not rely on divergence alone. The divergence indicator is combined with the validation-consistency score, and the combined reliability is explicitly normalized and clipped to [0,1]. In our threat model, benign but heterogeneous clients tend to maintain stable validation-consistency over time, so their EMA trust remains high even when their updates deviate from the global average. Conversely, poisoned updates typically induce both abnormal divergence and degraded validation consistency, leading to a sustained trust decrease.

Validation Consistency. Validation consistency reflects the predictive quality of a local update and is defined as

$$\mathsf{\psi }\left(a_i^{\left(t\right)}\right)={\displaystyle \frac{a_i^{\left(t\right)}-a_{\mathrm{m}\mathrm{i}\mathrm{n}}}{a_{\mathrm{m}\mathrm{a}\mathrm{x}}-a_{\mathrm{m}\mathrm{i}\mathrm{n}}+\mathsf{\epsilon }}},$$

where $a_i^{\left(t\right)}$ denotes the observed validation accuracy of client $i$ at round $t$, and $a_{\mathrm{m}\mathrm{i}\mathrm{n}}$ $a_{\mathrm{m}\mathrm{a}\mathrm{x}}$ are fixed bounds derived from empirical validation statistics collected during an initial warm-up phase.

In the considered federated setting, validation accuracy $a_i^{\left(t\right)}$ is computed at the server by re-evaluating the received local model on a small, fixed public or synthetic reference batch that is independent of all clients’ private data. Only aggregated performance statistics are used for trust estimation; no raw predictions, gradients, or client-side validation data are stored or redistributed. This validation mechanism is intended as a lightweight behavioral consistency check rather than a cryptographic security guarantee and is aligned with the threat model assumed in this work. In practical deployments, this reference batch can be obtained from (i) a small, locally curated audit set collected during device commissioning, (ii) publicly available traffic traces that do not overlap with client data, or (iii) a synthetic batch generated from a benign traffic model. Importantly, the batch is never used for training or hyperparameter tuning; it is only used to score received updates, which mitigates overfitting risk. To further reduce any potential bias, the reference batch can be refreshed periodically (e.g., by re-sampling from a pool), and the trust score is updated via EMA, so a single round cannot permanently penalize a statistically unique but benign client. For fairness, baseline methods are evaluated under the same train/test splits and identical reporting protocol; the reference batch is not used to train any method, and it only affects Trust-FedGNN’s internal trust estimation.

Explicit Normalization. To ensure reproducibility and eliminate ambiguity, the combined reliability score ${\tilde{r}}_i^{\left(t\right)}$ is explicitly normalized to the unit interval using min–max scaling with clipping:

$$r_i^{\left(t\right)}=\mathrm{clip}\left({\displaystyle \frac{{\tilde{r}}_i^{\left(t\right)}-r_{\mathrm{m}\mathrm{i}\mathrm{n}}}{r_{\mathrm{m}\mathrm{a}\mathrm{x}}-r_{\mathrm{m}\mathrm{i}\mathrm{n}}+\mathsf{\epsilon }}},\hspace{0.17em}0,\hspace{0.17em}1\right),$$

where $r_{\mathrm{m}\mathrm{i}\mathrm{n}}$ and $r_{\mathrm{m}\mathrm{a}\mathrm{x}}$ are fixed bounds determined empirically during a calibration phase, and $\mathrm{clip}\left(\cdot \right)$ enforces the $\left[\mathrm{0,1}\right]$ range. This explicit normalization ensures that trust computation is fully specified and directly implementable.

Discussion. By construction, the reliability trust score captures both behavioral consistency and predictive quality while remaining independent of device energy state. Nodes with persistently low trust values $T_i^{\left(t\right)}$ are down-weighted during aggregation or, in extreme cases, temporarily excluded from participation, thereby progressively reducing the influence of unreliable or malicious clients over successive communication rounds.

3.2.2. Energy-Aware Availability Modeling

To account for sustainability constraints without conflating them with trustworthiness, energy is handled separately through an availability score $A_i^{\left(t\right)}$ derived from the normalized residual energy $E_i^{\left(t\right)}$.

This separation ensures that nodes with limited residual energy are not penalized in terms of trust, but may adaptively reduce participation frequency to preserve battery life and prolong network operation.

3.2.3. Discussion

By decoupling reliability trust from energy availability, Trust-FedGNN avoids misclassifying honest low-power devices while still enabling energy-aware optimization. The proposed formulation aligns with reputation-based aggregation and trust propagation mechanisms in federated systems [15,16,17,18], while extending them with a sustainability-aware design suitable for large-scale, heterogeneous IoT ecosystems.

3.2.4. Trust Computation Details

To ensure full implementability and reproducibility of the proposed trust mechanism,

Table 1. Summary of variables and operational definitions used in the trust computation process, including explicit formulas, value ranges, and computation location (client or server).

Variable	Description	Formula	Range	Computed at
$d_i^{\left(t\right)}$	Model update divergence	${\displaystyle \frac{{‖w_i^{\left(t\right)}-w^{\left(t\right)}‖}_2}{{‖w^{\left(t\right)}‖}_2+\epsilon }}$	$\left[0,\mathrm{\infty }\right)$	Server
$\mathsf{\varphi }\left(d_i^{\left(t\right)}\right)$	Divergence score	$\exp \left(-d_i^{\left(t\right)}\right)$	$\left(\mathrm{0,1}\right]$	Server
$a_i^{\left(t\right)}$	Validation accuracy	empirical	$\left(\mathrm{0,1}\right]$	Server
$\mathsf{\psi }\left(a_i^{\left(t\right)}\right)$	Normalized accuracy	min–max	$\left(\mathrm{0,1}\right]$	Server
$r_i^{\left(t\right)}$	Instant reliability (normalized)	$\mathrm{clip}\left({\displaystyle \frac{{\tilde{r}}_i^{\left(t\right)}-r_{\mathrm{m}\mathrm{i}\mathrm{n}}}{r_{\mathrm{m}\mathrm{a}\mathrm{x}}-r_{\mathrm{m}\mathrm{i}\mathrm{n}}+\epsilon }},\hspace{0.17em}0,\hspace{0.17em}1\right)$	$\left(\mathrm{0,1}\right]$	Server
$T_i^{\left(t\right)}$	Trust score	EMA update	$\left(\mathrm{0,1}\right]$	Server
$P_i^{\left(t\right)}$	Participation probability	sigmoid	$\left(\mathrm{0,1}\right)$	Server

summarizes all variables involved in the trust computation process, including their definitions, explicit formulas, value ranges, and where each quantity is computed in practice. This consolidated view clarifies the operational role of each term used in Section 3.2.1, Section 3.2.2 and Section 3.2.3 and addresses potential ambiguities in the trust update procedure.

3.3. Dynamic Edge Pruning for Energy Efficiency

To reduce local message-passing computation and indirectly lower overall communication frequency when combined with adaptive scheduling, Trust-FedGNN performs dynamic edge pruning on the underlying graph before each local training round.

Edges with low interaction frequency or weak feature correlation are temporarily pruned, resulting in a sparser subgraph that preserves essential graph-based interaction patterns for local message passing while reducing overhead.

Although classical federated learning typically follows a star-shaped communication topology, the use of graph neural networks introduces structured dependencies among node representations. In this context, dynamic edge pruning serves a dual purpose. First, removing weak or redundant edges from the local interaction graph reduces the computational burden of message passing during local GNN training. Second, by lowering local computational cost and accelerating local convergence, pruning indirectly reduces communication overhead when combined with adaptive client scheduling, as fewer client participations and fewer effective communication rounds are required over the course of training. Note that pruning does not reduce the payload size of model weights exchanged in standard FL; any communication savings are indirect (e.g., fewer effective rounds/participations due to faster local convergence and scheduling).

To ensure reproducibility and clarify the dataset-to-graph pipeline, we explicitly define how interaction graphs are constructed for each dataset considered in this work. In all cases, graph construction is performed independently at each client using only locally available information, and no raw features or adjacency structures are shared with the server.

For the TON_IoT and IoT-23 datasets, nodes represent locally aggregated traffic or telemetry entities observed within fixed processing units. Depending on data availability, these units correspond either to temporal windows or to fixed-size data chunks. Each node is described by a feature vector composed of statistical descriptors extracted from the corresponding local data segment (e.g., mean and variance of numerical features). In our experiments, these statistical descriptors are recomputed from each round’s local mini-batches, and the interaction graph is rebuilt every communication round.

Edges are established based on feature similarity between node pairs. Specifically, a similarity score s_{ij} is computed using cosine similarity between normalized node feature vectors. For each node, a fixed number of nearest neighbors is selected based on this similarity, resulting in an undirected and initially sparse interaction graph.

For the OpenFed-IoT benchmark, nodes correspond directly to simulated IoT clients or data partitions defined by the benchmark configuration. Node features encode local data statistics or task-related embeddings, and edges follow the predefined communication or collaboration structure provided by the dataset, yielding a structured but sparse interaction graph.

This unified construction procedure ensures that interaction graphs are topology-aware while remaining lightweight and privacy-preserving. The resulting graphs serve exclusively as logical interaction structures for local GNN message passing and do not encode explicit data-sharing relationships between clients.

Table 2. Average graph statistics per client before and after dynamic edge pruning across the evaluated datasets. Values are averaged across clients and reflect the interaction graphs constructed locally according to the proposed graph construction procedure. Note that although the pruning threshold is energy-adaptive, we enforce a stable target pruning regime for reproducibility by clipping the effective pruning ratio within a narrow band around 20%. Under the calibrated energy profiles used in our experiments, this yields an average pruning ratio of approximately 20%.

Dataset	Avg. Nodes	Avg. Edges (Before)	Avg. Edges (After)	Pruning Ratio (%)
TON_IoT	616.6	3699.6	2959.1	20.0
IoT-23	459.6	2757.6	2205.7	20.0
OpenFed-IoT	102.6	410.4	327.9	20.1

reports average graph statistics per client obtained from the constructed interaction graphs before and after dynamic edge pruning, illustrating the typical graph sizes induced by the proposed construction procedure across datasets.

Formally, given the adjacency matrix $A$, the pruned graph $A^{\prime }$ is obtained by thresholding:

$$A_{ij}^{\prime }=\left\{\begin{array}{c}{A}_{ij}, if s_{ij}\ge {\theta }_t,\\ 0, otherwise,\end{array}\right.$$

where $s_{ij}$ is a similarity or mutual-information score. The pruning threshold ${\theta }_t$ is defined adaptively as:

$${\mathsf{\theta }}_t={\mathsf{\theta }}_0+{\mathsf{\lambda }}_E\left(1-\overline{E_i^{\left(t\right)}}\right),$$

where ${\theta }_0$ is a base similarity threshold, $\overline{E_i^{\left(t\right)}}$ denotes the normalized residual energy of client i at round t, and ${\lambda }_E$ controls the sensitivity of pruning to energy constraints. This formulation increases graph sparsity as available energy decreases. No global agreement on edge existence is required, as interaction graphs are constructed and used locally within each client solely to guide intra-client GNN message passing.

The pruning threshold is adaptively adjusted based on local energy budgets and interaction relevance, ensuring that essential topological information is preserved while unnecessary computation and communication are avoided. As reflected in Algorithm 1, pruning is performed entirely on the client side and does not require sharing full adjacency structures, further limiting overhead and preserving privacy.

Recent studies such as [19,20,21] confirm that topology sparsification significantly reduces energy consumption without harming accuracy—supporting the rationale for this design.

3.4. Adaptive Communication Scheduling

Energy efficiency in federated learning is strongly influenced by the frequency of client participation and communication rounds. To balance energy consumption with training progress, Trust-FedGNN integrates an adaptive communication scheduler that determines whether a client participates in a given global round based on two complementary factors: (i) local convergence behavior and (ii) residual energy availability.

Local Convergence Indicator. Local convergence is quantified through a loss-decay metric that captures the relative improvement of the local training objective between consecutive rounds. For client $i$ at round $t$, the loss-decay indicator is defined as

$${\mathrm{LossDecay}}_i^{\left(t\right)}={\displaystyle \frac{{\mathcal{L}}_i^{\left(t-1\right)}-{\mathcal{L}}_i^{\left(t\right)}}{{\mathcal{L}}_i^{\left(t-1\right)}+\mathsf{\epsilon }}},$$

where ${\mathcal{L}}_i^{\left(t\right)}$ denotes the local training loss after round $t$, and $\mathsf{\epsilon }$ is a small constant introduced for numerical stability. Higher values of ${\mathrm{LossDecay}}_i^{\left(\mathrm{t}\right)}$ indicate that the local model is still actively improving, whereas values close to zero suggest near-convergence.

Residual Energy Availability. Residual energy availability is represented by a normalized energy score $E_i^{\left(t\right)} \in \left[\mathrm{0,1}\right]$, where higher values indicate a greater remaining energy budget. This score is updated locally based on cumulative energy consumption and is used exclusively for participation control. Importantly, energy availability is fully decoupled from trust estimation, ensuring that honest but energy-constrained devices are not penalized in terms of reliability.

Participation Probability. The participation probability of client $i$ at round $t$ is computed as

$$P_i^{\left(t\right)}=\mathsf{\sigma }\left({\mathsf{\gamma }}_1\hspace{0.17em}{\mathrm{LossDecay}}_i^{\left(\mathrm{t}\right)}+{\mathsf{\gamma }}_2\hspace{0.17em}{E}_i^{\left(t\right)}\right),$$

where $\mathsf{\sigma }\left(\cdot \right)$ denotes the sigmoid function, and ${\mathsf{\gamma }}_1,{\mathsf{\gamma }}_2>0$ are tunable coefficients controlling the relative influence of convergence urgency and residual energy availability, respectively. This formulation assigns a higher participation probability to clients who are both actively improving and sufficiently energy-capable.

Discussion. By jointly considering local convergence dynamics and residual energy, the proposed scheduler prioritizes informative client updates while progressively suppressing unnecessary communication from near-converged or energy-constrained devices. This adaptive behavior reduces redundant participation without compromising model accuracy and contributes to substantial energy savings across the federation. The scheduling mechanism operates independently of trust computation, which is handled separately during aggregation.

The proposed approach is conceptually related to adaptive participation strategies in prior federated learning studies [18,19,20], but extends them by operating in conjunction with trust-aware aggregation and graph-based local learning, enabling coordinated, resource-aware optimization in heterogeneous IoT environments.

3.5. Algorithmic Outline

The following algorithm summarizes the full process.

• Initialize global model $W^0$ and trust vector ${\tau }^0$.
• For each round t:

  a.

  Each selected node i updates local parameters $W_i^{\left(t\right)}$ on its data.

  b.

  Compute trust update ${\tau }_i^{\left(t\right)}$.

  c.

  Perform dynamic graph pruning.

  d.

  Aggregator executes trust-weighted fusion:

  $$W^{\left(t+1\right)}={\displaystyle \frac{{\sum }_i{\tau }_i^{\left(t\right)}{W}_i^{\left(t\right)}}{{\sum }_i{\tau }_i^{\left(t\right)}}}.$$

  e.

  Update communication schedule based on residual energy

• Repeat until convergence.

Algorithm 1 summarizes the complete Trust-FedGNN training procedure, detailing the interaction between reliability-based trust updates, energy-aware client scheduling, dynamic graph pruning, and trust-weighted aggregation. Trust scores influence model fusion, energy availability regulates participation frequency (hence the number of communication rounds/participations), and sparsification reduces local message-passing cost during GNN training.

Algorithm 1. Trust-FedGNN Training Procedure.

Input: Initial global model $w^{\left(0\right)}$; initial trust vector ${\tau }^{\left(0\right)}$; client set $\mathcal{N}$; total communication rounds T; trust smoothing factor α; reliability weights ${\beta }_1,{\beta }_2$; energy thresholds ${\left\{E_i^{\min }\right\}}_{\mathrm{i}\in \mathcal{N}}$. Output: Final global model $w^{\left(T\right)}$. Initialization: Each client $i\in \mathcal{N}$ initializes local model $w_i^{\left(0\right)}$ and trust score ${{\rm T}}_i^{\left(0\right)}=0.5$. for $\mathit{t}=1$ to T do 1. Client Selection (Energy-Aware Scheduling):  The server selects a subset of available clients based on the  participation probability $\left(p_i^{\left(t\right)}\right)$, which jointly accounts for local loss decay and residual  energy availability, as defined in Section 3.4. 2. Local Graph Construction and Pruning (Client-Side):  For each selected client $i\in {\mathcal{S}}^{\left(t\right)}$:  Construct a local interaction graph $G_i^{\left(t\right)}=\left(V_i,E_i\right)$ based on feature similarity or  communication history.  Apply dynamic edge pruning to obtain a sparse graph ${\tilde{G}}_i^{\left(t\right)}$, removing edges with low  relevance under the current energy budget. 3. Local Model Update:  Each client $i\in {\mathcal{S}}^{\left(t\right)}$ trains a local GNN model on ${\tilde{G}}_i^{\left(t\right)}$ and computes:              $d_i^{\left(t\right)}={\displaystyle \frac{\parallel w_i^{\left(t\right)}-w^{\left(t\right)}{\parallel }_2}{\parallel w^{\left(t\right)}{\parallel }_2+\epsilon }}$ 4. Reliability Evaluation:  For each $i\in {\mathcal{S}}^{\left(t\right)}$: Compute model update divergence $d_i^{\left(t\right)}$ (e.g., normalized ${\mathcal{l}}_2$-norm). Obtain validation performance $a_i^{\left(t\right)}$ via server-side or sanity-checked evaluation on a public/synthetic reference set. Compute instantaneous reliability score:            ${\mathrm{r}}_i^{\left(t\right)}={\beta }_1\hspace{0.17em}\varphi \left(d_i^{\left(t\right)}\right)+{\beta }_2\hspace{0.17em}\psi \hspace{0.17em}\left(a_i^{\left(t\right)}\right).$ 5. Trust Update:  Update reliability trust for each participating client:            ${\tau }_i^{\left(t\right)}=\alpha \hspace{0.17em}{\tau }_i^{\left(t-1\right)}+\left(1-\alpha \right)\hspace{0.17em}{R}_i^{\left(t\right)}.$ 6. Trust-Weighted Aggregation:  The server updates the global model using trust-weighted aggregation:              $w^{\left(t\right)}={\displaystyle \frac{{\sum }_{i\in {\mathcal{S}}^{\left(t\right)}}{\tau }_i^{\left(t\right)}\hspace{0.17em}{w}_i^{\left(t\right)}}{{\sum }_{i\in {\mathcal{S}}^{\left(t\right)}}{\tau }_i^{\left(t\right)}}}.$ 7. Energy and Availability Update:  Each client updates its residual energy estimate $E_i^{\left(t\right)}$ and availability score, which are  subsequently used to compute participation probabilities in future rounds. end for

3.6. Summary

The proposed Trust-FedGNN architecture thus introduces a cohesive integration of trust management, topology-aware learning, and energy-adaptive optimization.

Unlike prior frameworks that treat security, structure, and energy separately, this design jointly optimizes all three, targeting both resilience and sustainability in federated IoT learning.

4. Experimental Evaluation

4.1. Datasets and Experimental Setup

To validate the proposed Trust-FedGNN framework, experiments were conducted on benchmark and real-world IoT datasets widely used for evaluating federated and graph-based anomaly detection systems:

• TON_IoT (Telemetry-Oriented Network IoT Dataset)—a comprehensive telemetry and network dataset from the University of New South Wales, containing heterogeneous IoT, telemetry, and network traces for intrusion detection [22].
• IoT-23—a curated set of labeled benign and malicious traffic captures collected from multiple IoT devices, enabling malware detection and traffic classification [23].
• OpenFed-IoT—a synthetic yet realistic dataset for evaluating heterogeneous device participation and non-IID data distribution in federated learning [24].

Each dataset was preprocessed to extract feature embeddings suitable for GNN input (node features + edge adjacency).

Experiments were implemented in Python 3.11 using PyTorch 2.3, PyTorch Geometric 2.5, and Flower 1.7 for federated orchestration.

The federated environment comprised ten emulated IoT clients representing NVIDIA Jetson Nano–class devices and one aggregator node (AMD Ryzen 7 5800X). The federated learning environment was executed on a single physical host, where multiple client processes emulated the computational profile of resource-constrained IoT devices. This setup enables controlled and repeatable evaluation while approximating the behavior of low-power edge hardware.

Energy consumption was directly measured at the client side using PowerStat-based monitoring on Linux systems, capturing Central Processing Unit (CPU) and memory power usage during both local training and communication phases. Measurements were collected at runtime for each federated round and aggregated to obtain the total energy expenditure per client. To ensure fair comparison, all methods were evaluated under identical hardware configurations and software settings, and energy values were normalized to joules per training round. Communication-related energy costs were implicitly reflected through runtime power measurements rather than inferred from payload size.

For federated evaluation, each dataset was partitioned across ten clients following both IID and non-IID settings, depending on the experiment. In the non-IID configuration, data were distributed using label-skew partitioning, where each client observes a limited subset of labels, reflecting realistic heterogeneity in IoT deployments. Client datasets were fixed across all methods to ensure fair comparison. All experiments were repeated over three independent runs with different random seeds controlling data shuffling and model initialization, and reported results correspond to the mean and standard deviation.

To further improve clarity and reproducibility,

Table 3. Reproducibility summary of key implementation and experimental parameters.

Component	Setting
Graph similarity metric	Cosine similarity
Neighbors per node (k)	10
Graph construction	Client-side, local only
Graph rebuild frequency	Every communication round
Dynamic pruning ratio	20% (energy-adaptive)
Malicious client fraction	20%
Attack types	Label-flipping (50%), model poisoning (scaling ×5)
Attacker participation	Subject to the same scheduling rules as benign clients
Data partitioning	Non-IID, label-skew (Dirichlet, α = 0.5)
Number of clients	10
Random seeds	3 independent runs

summarizes the key implementation and experimental parameters used throughout this study. This consolidated overview complements the detailed descriptions provided above by explicitly reporting graph construction choices, attack settings, data partitioning strategy, and randomization controls, enabling straightforward replication of the proposed Trust-FedGNN framework.

4.2. Baseline Models

To assess relative performance, Trust-FedGNN was compared with the following baselines:

• FedAvg-GNN—classical federated averaging of GNN models without trust or energy adaptation [25].
• FLTrust—trust-weighted aggregation using cosine-similarity filtering [26].
• E-FedAvg—energy-aware federated learning using client selection heuristics [19].
• Local-only GNN—each device trains a GNN independently, without federation.

Hyperparameters were tuned via grid search: learning rate = 0.001, batch size = 64, and communication rounds = 100.

Trust-FedGNN’s weighting parameters were set to α = 0.8, β₁ = 2.0, β₂ = 1.2 after sensitivity analysis.

4.3. Performance Metrics

Throughout this paper, energy consumption is reported as the total energy consumed per client over the full training process, measured in joules (J). All energy values correspond to cumulative host-level measurements collected during the entire federated training and averaged across clients and runs.

Evaluation included metrics for both learning quality and resource efficiency (

Table 4. Evaluation metrics used in this study.

Metric	Description
Accuracy/F1-score	Model classification performance on unseen IoT data.
Energy (J/round)	Total energy consumed per client over the full training process.
Communication Overhead (Megabyte-MB)	Mean transmitted payload size per communication round.
Latency (ms)	End-to-end aggregation delay.
Trust Robustness (%)	Accuracy retention under adversarial conditions, relative to benign training
Convergence Rounds	Number of rounds to reach 95% of best accuracy.

).

Trust Robustness (%) measures the ability of the learning process to retain predictive performance in the presence of adversarial or unreliable clients. It is defined as the ratio between the model accuracy observed under attack and the accuracy obtained in the benign setting, expressed as a percentage:

$$\mathrm{Trust} \mathrm{Robustness}=100{\displaystyle \frac{{\mathrm{Acc}}_{\mathrm{attack}}}{{\mathrm{Acc}}_{\mathrm{benign}}}}$$

Higher values, therefore, indicate stronger robustness, corresponding to smaller relative performance degradation under adversarial conditions.

All metrics were averaged across three independent runs with different random seeds and are reported as mean ± standard deviation. The corresponding 95% confidence intervals can be derived assuming normality.

4.4. Threat Model and Robustness Assumptions

We consider a standard federated learning threat model in which a subset of participating clients may behave in an adversarial or unreliable manner. Unless otherwise stated, 20% of the clients are assumed to be malicious and participate throughout the training process.

Two representative attack types are evaluated. In the label-flipping attack, malicious clients deliberately flip the labels of a fixed fraction of their local training samples before performing local model updates. In the model poisoning attack, adversarial clients manipulate their local model updates by scaling or perturbing gradients to bias the global aggregation process.

Malicious clients do not have access to the private data of other participants and do not control the server-side aggregation process. Their objective is to degrade the overall model accuracy or convergence behavior without being trivially detected. Benign clients follow the prescribed training protocol.

This threat model captures common adversarial behaviors studied in federated learning and allows assessing the robustness of trust-aware aggregation and scheduling mechanisms under realistic adversarial conditions.

To evaluate the robustness of the proposed Trust-FedGNN framework, we consider a federated learning environment in which a subset of participating IoT devices may behave maliciously or unreliably. The threat model is designed to reflect realistic adversarial conditions in large-scale, resource-constrained IoT deployments while remaining consistent with standard assumptions in the federated learning literature.

4.4.1. Adversary Capabilities

We assume the presence of Byzantine clients that attempt to degrade global model performance through corrupted local updates. In particular, malicious clients may perform model poisoning or label-flipping attacks, generating local updates that deviate significantly from the expected optimization trajectory. Adversaries are assumed to have full control over their local data and training process, but no access to other clients’ private data, local models, or the server-side aggregation mechanism.

The attacker is considered non-adaptive, meaning that adversarial behavior does not explicitly adjust in response to the evolving trust scores or aggregation weights. This assumption aligns with widely adopted threat models in trust-aware federated learning and allows a focused evaluation of the proposed reputation and mitigation mechanisms.

4.4.2. Attack Intensity and Participation

Unless otherwise stated, a fixed fraction of clients (up to 20% of the total population) is designated as malicious during robustness experiments. Malicious clients participate in the federation under the same scheduling constraints as honest clients, subject to energy availability and communication rounds.

4.4.3. Defense Scope and Limitations

Trust-FedGNN does not aim to provide cryptographic security guarantees against fully adaptive or colluding adversaries. Instead, it targets behavioral robustness, leveraging reliability-based trust scoring, trust-weighted aggregation, and adaptive participation to limit the influence of unreliable or malicious nodes over time. Energy-aware scheduling further reduces unnecessary exposure to low-quality updates without conflating resource constraints with trustworthiness.

This threat model provides a principled and transparent basis for interpreting the reported robustness results, including the Trust Robustness metric evaluated under partial adversarial participation.

4.5. Communication and Energy Accounting

To ensure a fair and transparent comparison between Trust-FedGNN and baseline methods, we explicitly account for per-round communication payloads and energy consumption at the client side. While classical federated learning typically assumes that communication cost is dominated by full model transmission, Trust-FedGNN modifies both participation frequency and effective payload size through trust-aware aggregation, dynamic graph pruning, and energy-aware scheduling.

4.5.1. Communication Payload Breakdown

For each communication round, participating clients transmit model-related parameters along with lightweight metadata. Importantly, Trust-FedGNN does not rely on explicit parameter compression or sparse encoding of model updates. All compared methods transmit dense model updates of identical dimensionality. Differences in communication overhead arise primarily from adaptive client scheduling, which reduces the number of active participants per round, rather than from changes in the structure or density of transmitted model parameters.

Table 5. Communication overhead comparison across methods. Reported values correspond to the average payload transmitted per communication round by participating clients, measured in megabytes (MB). All methods transmit dense model updates of identical dimensionality; differences arise from adaptive client scheduling rather than explicit parameter compression. Communication overhead is computed as: Comm. (MB) = (Number of participating clients per round) × (Model update size in MB), averaged across all training rounds.

Component	Description	Payload Size (Relative)
Local model update	GNN weights or gradients after local training	Dominant term
Trust scalar ${\tau }_i^{\left(t\right)}$	Reliability trust score	Negligible (1 scalar)
Pruning mask/sparsity indicator	Binary or indexed representation of retained edges/parameters	Low
Scheduling metadata	Availability or participation flag	Negligible

Note: For baseline methods (FedAvg-GNN, FLTrust, E-FedAvg), only dense model updates are transmitted each round, without pruning masks or trust metadata.

summarizes the per-client communication payload per round.

4.5.2. Energy Measurement and Normalization

Energy consumption is measured using PowerStat at the host level during federated training execution. Measurements capture the total energy consumed by each client process, including local model training, graph pruning, and communication-related overhead as reflected in system runtime activity. While this approach does not isolate radio-level transmission energy (e.g., Wi-Fi or BLE), it provides a consistent proxy for relative energy consumption across methods under identical hardware and software conditions. Therefore, the reported energy savings should be interpreted as computational energy savings under controlled emulation. Any communication-energy savings on real IoT hardware are inferred indirectly from the reduction in communication rounds and active client participations, rather than being measured from radio Tx/Rx circuitry.

Although Trust-FedGNN introduces minimal additional computation for trust evaluation and pruning, these costs are outweighed by reductions in communication volume and fewer client participations per round. Consequently, Trust-FedGNN achieves a net reduction in energy consumption relative to baselines, as reported in Section 4.6. We should also note that although absolute energy values may differ on real wireless hardware, relative comparisons remain valid due to identical execution conditions across all evaluated methods.

4.5.3. Fairness of Comparison

All compared methods employ the same backbone GNN architecture, optimizer, learning rate, batch size, and local epoch settings. Differences in communication and energy consumption arise solely from client selection, sparsity of updates, and aggregation strategy, not from architectural advantages. This ensures that reported gains reflect the impact of trust-aware and energy-aware mechanisms rather than model capacity differences.

4.6. Results and Discussion

All reported results are presented as mean ± standard deviation over three independent runs with different random seeds; the corresponding 95% confidence intervals can be derived assuming a normal distribution. Unless otherwise stated, reported performance metrics are computed independently for each dataset and then aggregated using an unweighted average across datasets. This aggregation is adopted to provide a compact summary of comparative performance, while avoiding dominance by any single dataset. Unless otherwise specified, robustness results correspond to the threat model described in Section 4.4, with 20% malicious clients.

Table 6. Performance comparison of Trust-FedGNN and baseline methods across IoT datasets. All results are reported as mean ± standard deviation over three independent runs with different random seeds. Communication overhead and latency are measured per communication round. Corresponding 95% confidence intervals can be derived assuming normality. Energy values correspond to the average total energy consumed per client over the full training process, measured in joules (J/round).

Model	Accuracy (%)	F1-Score	Energy (J/Round)	Comm. (MB)	Latency (ms)	Trust Robustness (%)
Local-only GNN	87.2 ± 0.6	0.861 ± 0.009	3.24 ± 0.10	0.0± 0.0	0 ± 0	68.5 ± 1.2
FedAvg-GNN	90.6± 0.5	0.892 ± 0.007	3.10 ± 0.09	11.3 ± 0.4	84 ± 3	71.4 ± 1.5
FLTrust	92.1 ± 0.4	0.904 ± 0.006	3.05 ± 0.08	10.9 ± 0.3	86 ± 2	78.6 ± 1.3
E-FedAvg	91.7 ± 0.5	0.898 ± 0.008	2.68 ± 0.07	9.8 ± 0.3	81 ± 3	74.3 ± 1.4
Trust-FedGNN (ours)	96.3 ± 0.4	0.945 ± 0.006	2.09 ± 0.08	7.8 ± 0.2	73 ± 2	91.1± 1.0

summarizes the quantitative performance of Trust-FedGNN compared with representative baseline frameworks. The average performance across the evaluated datasets was computed as the unweighted mean of per-dataset results. The proposed approach consistently outperformed the alternatives across all metrics, achieving an accuracy of 96.3% and an F1-score of 0.945, while reducing the mean energy per training round to only 2.09 J/round. In contrast, the classical FedAvg-GNN and E-FedAvg models reached 90–92% accuracy with 30–50% higher energy consumption. These results indicate that integrating trust-weighted aggregation and dynamic edge pruning yields both higher predictive reliability and improved energy sustainability. High Trust Robustness values indicate that Trust-FedGNN preserves a large fraction of its benign accuracy even under adversarial participation, confirming its resilience to trust-based attacks.

Figure 2 illustrates the trade-off between learning accuracy and energy efficiency for all evaluated frameworks. While FedAvg-GNN and FLTrust exhibit marginal accuracy gains over traditional GNNs, they maintain relatively high power usage (>3 J per round). The proposed Trust-FedGNN achieves the best overall balance, simultaneously delivering the highest accuracy (96.3%) and the lowest energy footprint (approximately 2 J per round), confirming the effectiveness of its adaptive communication scheduling and trust-aware design.

Figure 3 illustrates the learning convergence behavior of all evaluated frameworks across 100 communication rounds. As shown, Trust-FedGNN consistently converges faster and reaches higher accuracy levels compared to baseline models. Specifically, it achieves 95% accuracy after roughly 60 rounds, whereas FedAvg-GNN and E-FedAvg require more than 80 rounds to reach comparable performance. This demonstrates the positive effect of the proposed trust weighting and adaptive communication scheduling in accelerating global convergence.

Figure 4 presents the trade-off between model accuracy and mean energy consumption per training round. The scatter plot shows that Trust-FedGNN occupies the Pareto-optimal region, attaining the highest accuracy (96.3%) while consuming the lowest average energy (approximately 2.1 J). In contrast, FedAvg-GNN and FLTrust deliver lower accuracy (approximately 90–92%) with significantly higher energy footprints (>3 J per round). These results confirm that integrating dynamic edge pruning and energy-aware scheduling achieves tangible energy savings without compromising learning performance.

To further assess the contribution of each architectural component,

Table 7. Ablation analysis showing the effect of removing individual components of the Trust-FedGNN framework on accuracy and energy efficiency.

Variant	Trust Layer	Edge Pruning	Adaptive Scheduling	Accuracy (%)	Energy (J/round)
Trust-FedGNN (full)	Yes	Yes	Yes	96.3 ± 0.4	2.09 ± 0.08
w/o Trust Layer	No	Yes	Yes	93.8 ± 0.5	2.12 ± 0.07
w/o Edge Pruning	Yes	No	Yes	94.1 ± 0.6	2.89 ± 0.11
w/o Adaptive Scheduling	Yes	Yes	No	94.4 ± 0.5	2.65 ± 0.10

reports an ablation analysis of the Trust-FedGNN framework. When the trust layer is removed, accuracy drops by approximately 2.5%, indicating the importance of reputation-guided aggregation. Omitting edge pruning increases energy consumption by more than 35%, while disabling adaptive scheduling results in slower convergence and 25% higher energy cost. The full configuration delivers the best overall balance, confirming that all three mechanisms—trust management, graph pruning, and adaptive scheduling—are synergistic in enhancing both performance and sustainability.

In summary, key findings include:

• Accuracy improvement: Trust-FedGNN achieved up to +5.8% higher accuracy and +3.1% higher F1-score on TON_IoT.
• Energy savings: A mean reduction of ~22% in energy was observed compared with E-FedAvg due to dynamic edge pruning and adaptive scheduling.
• Robustness: Under a 20% malicious-client scenario, performance degraded by only 4.2%, versus > 10% for FLTrust.
• Communication efficiency: The adaptive scheduling reduced the total transmitted payload by approximately 28% without significant convergence delay.

These outcomes indicate that Trust-FedGNN simultaneously enhances trust, resilience, and energy sustainability in federated IoT networks—fulfilling the framework’s design objectives.

Per-dataset performance trends were consistent with the aggregated results; therefore, aggregated metrics are reported for clarity. We note that absolute energy values depend on the specific hardware and communication interfaces used; however, relative comparisons remain valid due to identical execution conditions across all evaluated methods.

4.7. Summary

This evaluation demonstrates that integrating trust weighting, dynamic graph pruning, and adaptive communication scheduling yields tangible performance gains. The proposed framework not only mitigates malicious behavior but also lowers operational costs, providing a viable pathway for deploying scalable, secure, and energy-aware IoT intelligence.

5. Conclusions and Future Work

This paper introduced Trust-FedGNN, a federated graph-learning framework that unifies trust-aware aggregation, topology-adaptive representation, and energy-efficient optimization to enable secure and sustainable intelligence in Internet of Things (IoT) ecosystems.

Unlike conventional approaches that address privacy, reliability, or efficiency in isolation, the proposed framework jointly optimizes these dimensions within a single cohesive architecture.

Through extensive evaluation on multiple IoT benchmarks (TON_IoT, IoT-23, and OpenFed-IoT), Trust-FedGNN achieved consistent improvements: up to +5.8% accuracy and +3.1% F1-score compared with State-of-the-Art baselines, alongside an ≈22% reduction in energy usage per training round. The results demonstrate that incorporating dynamic trust scoring, graph pruning, and adaptive client scheduling can substantially enhance both model robustness and sustainability in federated learning systems.

The main contributions of this work can be summarized as follows:

• A trust-propagation model for reputation-aware aggregation, resilient to unreliable or malicious nodes.
• A graph-aware optimization strategy that captures relational dependencies among IoT devices.
• An energy-adaptive scheduling mechanism that minimizes unnecessary communication without compromising convergence.
• A comprehensive experimental evaluation confirming that the combined design improves accuracy, robustness, and energy efficiency across heterogeneous IoT datasets.

Several research directions remain open. First, large-scale real-world deployment should be explored using physical IoT testbeds or edge-cloud platforms to validate scalability and resilience under dynamic network conditions.

Second, integrating explainable-AI modules could enhance model transparency and enable human-interpretable trust diagnostics.

Third, applying federated continual learning may allow Trust-FedGNN to adapt to temporal concept drift in evolving sensor data.

Finally, hybrid implementations combining blockchain-based auditing and quantum-inspired optimization represent promising avenues for achieving both verifiable trust and ultra-efficient energy management in future 6G-enabled IoT systems.