FOGNITE: Fog-Based Grid Intelligence

• FOGNITE is a fog–cloud smart grid architecture that integrates federated learning, reinforcement learning, and digital twins for proactive, validated energy optimization.
• It uses a four-layer design (perception, fog, cloud, control) to enable local processing, reducing latency and energy waste while preserving data privacy.
• The framework employs a CNN–LSTM model in FL, a PPO-based RL scheduler, and hierarchical digital twins to ensure secure, efficient, and adaptive task execution.

FOGNITE, short for “Fog-based Grid Intelligence with Neural Integration and Twin-based Execution,” is a fog–cloud architecture for smart grids that integrates federated learning, reinforcement learning, and digital twins into a single closed control loop. It is designed for distributed energy systems that are simultaneously distributed, data-rich, dynamic, and privacy-sensitive, and it targets fast, intelligent, and energy-aware computation near the edge while preserving locality of fine-grained consumption data. The framework spans a four-layer fog–cloud continuum and shifts grid control from reactive correction toward proactive, validated optimization (Sobati-M, 22 Jul 2025).

1. Conceptual definition and operating context

FOGNITE is positioned in the context of modern smart grids with dispersed distributed energy resources, smart meters, IoT sensors, storage, electric vehicles, and prosumers. In that setting, the operational requirements identified for the architecture are load balancing, real-time decision-making close to the edge, energy-aware computation, and privacy preservation. The motivating claim is that conventional cloud-only or non-intelligent architectures exhibit high latency, high bandwidth usage, elevated privacy risk, reactive behavior, and central points of failure, which are poorly matched to rapid fluctuations in demand and renewable supply (Sobati-M, 22 Jul 2025).

The architecture is explicitly presented as a unified response to three gaps in prior approaches. First, earlier systems are described as addressing isolated subproblems such as forecasting, load disaggregation, missing data, or fog–cloud coordination. Second, they are characterized as not being fully energy-aware or privacy-preserving at scale. Third, they are described as lacking pre-deployment validation of decisions. FOGNITE therefore combines learning, scheduling, and safety validation in one loop rather than treating them as separate subsystems.

A central interpretive point is that FOGNITE is not merely a forecasting pipeline or a task scheduler. Its defining feature is the tight coupling of three decision mechanisms with different roles and timescales: federated learning supplies predictive intelligence, reinforcement learning selects actions under uncertainty, and digital twins validate those actions before they affect the physical system. This suggests a cyber-physical control design in which predictive modeling, runtime optimization, and execution safety are co-engineered rather than layered independently.

2. Four-layer architecture and communication structure

FOGNITE is organized into four layers: the perception layer, the fog layer, the cloud layer, and a control/digital twin layer. The perception layer consists of smart meters, IoT sensors, and DER controllers producing voltage, current, power, frequency, environmental metrics, and device-level load data. It performs local preprocessing including noise filtering, basic compression, and possibly local feature extraction before forwarding information to fog nodes (Sobati-M, 22 Jul 2025).

The fog layer is the core intelligence layer. Each fog node, exemplified in the experimental system by a Raspberry Pi, runs three containerized services. The first is a local federated learning module implementing a CNN–LSTM model trained on private local energy consumption data. The second is a PPO-based deep reinforcement learning scheduler that observes local state, including CPU load, memory, queue length, network delay, and energy type or availability, and chooses where and when to execute tasks. The third is an edge-tier digital twin that simulates local hardware and performance characteristics such as CPU latency, thermal behavior, network conditions, and power draw before actions are committed (Sobati-M, 22 Jul 2025).

The cloud layer provides a global federated aggregator, described as receiving local model updates, aggregating them with FedAvg, and redistributing the global model. It also maintains cloud-tier digital twins that emulate macro-level behavior such as grid-wide stability and cascading failures, and it offers fallback control and long-term planning if fog nodes fail or become overloaded. The digital twin subsystem is formally represented as

$$\mathcal{T} = (\mathcal{T}_e, \mathcal{T}_c, \mathcal{T}_m),$$

where $\mathcal{T}_e$ denotes edge-tier twins, $\mathcal{T}_c$ cloud-tier twins, and $\mathcal{T}_m$ the monitoring interface (Sobati-M, 22 Jul 2025).

Communication is defined along upward, downward, and lateral paths. Upward flows carry filtered measurements from perception to fog and model parameters $w^{(k)}$ rather than raw data from fog to cloud. Downward flows carry the updated global model $w_{t+1}$, forecasts, and fallback commands. Lateral flows connect the RL scheduler to the edge digital twin and connect cloud digital twins to FL and RL subsystems. The resulting closed loop is summarized in the source as sensing, local training, global aggregation, policy-driven scheduling, digital twin validation, and execution.

3. Federated learning subsystem

The federated learning component uses fog nodes as clients and a cloud aggregator as server. In the reported testbed, the clients are 20 Raspberry Pi 4B devices and the cloud-tier server is an AWS EC2 instance. Each client stores local smart-meter streams and environmental context, trains locally, and shares model weights or gradients only. Raw data never leaves the fog nodes, and privacy is therefore achieved through data-local training rather than through explicitly stated differential privacy or secure aggregation mechanisms (Sobati-M, 22 Jul 2025).

The global update is given in FedAvg-like form by

$$w_{t+1} = w_t + \sum_{k=1}^K \frac{n_k}{N}\left(w^{(k)}_{t+1} - w_t\right),$$

equivalently

$$w_{t+1} = \sum_{k=1}^K \frac{n_k}{N} w^{(k)}_{t+1},$$

with $K$ fog nodes, $n_k$ local sample counts, and $\mathcal{T}_e$0. Each node trains locally for 5 epochs with batch size 32 and synchronizes every 5 rounds (Sobati-M, 22 Jul 2025).

The local predictive model is a CNN–LSTM architecture for time-series energy consumption segments. Its CNN block uses a 1D convolution with 32 filters, kernel size 5, stride 1, followed by max-pooling. The recurrent stage is a bidirectional LSTM with 64 hidden units and dropout 0.3. The dense stage comprises fully connected layers of 128 and 64 neurons with ReLU activation and a linear output layer for regression. The model has approximately 287,489 trainable parameters and is optimized with Federated Adam using $\mathcal{T}_e$1 and $\mathcal{T}_e$2. The training loss is mean squared error with L2 regularization,

$\mathcal{T}_e$3

To fit fog devices, the framework applies 8-bit quantization and weight pruning, removing parameters with $\mathcal{T}_e$4. The stated result is a $\mathcal{T}_e$5 size reduction with negligible accuracy loss. A plausible implication is that the FL subsystem is intended not only to preserve privacy but also to make recurrent forecasting viable on resource-constrained edge hardware.

4. Reinforcement learning scheduler and reward design

The scheduling subsystem is a Deep RL agent based on PPO running on each fog node. Its environment is defined as the local fog node together with its workloads, the network path to the cloud, and available energy sources. The state $\mathcal{T}_e$6 is a 15-dimensional vector that includes CPU load, memory availability, task queue length, network delay, and energy type or availability, with the possibility of additional status variables such as thermal or battery indicators. The action $\mathcal{T}_e$7 chooses where and how to run incoming tasks, including local execution, forwarding to another fog node, or offloading to the cloud, as well as ordering, throttling, or deferring tasks based on energy conditions (Sobati-M, 22 Jul 2025).

The policy objective is stated as

$\mathcal{T}_e$8

with discount factor experimentally set to $\mathcal{T}_e$9. The reward is multi-objective:

$\mathcal{T}_c$0

where the components encourage low response time, penalize high energy use while favoring renewable or low-cost energy usage, and promote balanced utilization across resources. The coefficients are tuned according to grid policy priorities. The text as provided contains a malformed equation, but the intended semantics are explicit: latency, energy, and utilization are jointly optimized rather than handled through separate heuristics.

The PPO implementation uses separate policy and value networks, both with fully connected layers of 128 and 64 units and ReLU activation; the policy head outputs action probabilities through softmax and the value head outputs a scalar state value. The training hyperparameters are a learning rate of $\mathcal{T}_c$1, discount factor $\mathcal{T}_c$2, and entropy coefficient $\mathcal{T}_c$3. The paper notes that scheduling decisions occur at the task arrival or queueing timescale, in the range of milliseconds to seconds, which is substantially faster than federated aggregation cycles.

In functional terms, the scheduler is the architecture’s online optimization mechanism. Federated learning predicts likely future conditions; PPO decides how to allocate computation under present conditions; digital twins determine whether the proposed action is admissible. This suggests that FOGNITE treats uncertainty as both predictive and operational: forecasts reduce uncertainty about demand, while PPO and digital twins address uncertainty in execution and system response.

5. Hierarchical digital twins and validated execution

The digital twin layer is described as a hierarchy of live software replicas of both local fog resources and the broader grid and communication infrastructure. Its role is to simulate the consequences of actions before execution so that RL decisions remain safe, efficient, and robust to network variability and partial failures. This is the feature that most sharply differentiates FOGNITE from architectures that perform scheduling without pre-deployment validation (Sobati-M, 22 Jul 2025).

The edge-tier twins $\mathcal{T}_c$4 are implemented as containerized replicas co-located with fog nodes. They simulate CPU latency variations of $\mathcal{T}_c$5, network delay from 20–100 ms, and packet loss from 0.1–2% using tc-netem, and they perform power modeling, for example via Intel RAPL counters. Their output concerns short-term metrics such as response time, local power draw, and thermal stress. The cloud-tier twins $\mathcal{T}_c$6 are built in OMNeT++ to emulate macro-level network and grid behavior, including load propagation and cascading failure risks. Their failure probability model is

$\mathcal{T}_c$7

with node and link failure probabilities. As in the reward equation, the transcription is malformed, but the structure clearly expresses system-level failure probability as a product-based composition over node and link risks. The monitoring interface $\mathcal{T}_c$8 aggregates metrics, enforces validation thresholds for latency, power, and failure probability, and feeds the results back to the RL agent.

The validation pipeline is sequential. The RL agent proposes an action $\mathcal{T}_c$9 for state $\mathcal{T}_m$0; the edge-tier twin estimates local performance and energy cost; if local constraints are violated, the action is vetoed or replaced; if broader system impact is implicated, the cloud-tier twin evaluates risk metrics such as $\mathcal{T}_m$1; only validated actions are executed on the physical system. The paper attributes substantial reductions in execution errors and energy waste to this mechanism.

A common misconception in discussions of digital twins is to equate them with passive monitoring dashboards. In FOGNITE they are instead active gating mechanisms inserted in the decision path. Their purpose is not merely observability but runtime admissibility testing. That distinction is central to the architecture’s claim of “validated optimization.”

6. Experimental evaluation, comparative results, and limitations

The reported testbed comprises 20 Raspberry Pi 4B fog nodes with 4 GB RAM each, an AWS EC2 c5.4xlarge cloud server, and 150 simulated smart meters sampled at 15 Hz over 72 continuous hours. Across that period the experiments included 5,000 load balancing decisions, 100,000 data imputations, and 50 injected fog-node failures. On each fog device, the FL learner, RL agent, and edge digital twin run in separate Docker containers. The data are described as heterogeneous smart meter streams with non-IID local distributions across nodes, though the exact dataset source and train/test split are not detailed (Sobati-M, 22 Jul 2025).

The baseline is FOCCA, a fog–cloud architecture using a Q-Balance neural network for load balancing, centralized data aggregation, and no digital twin validation or full automation in decision-making. The comparison therefore isolates the effects of federated learning and digital twin validation within a fog–cloud setting rather than comparing against a purely cloud-based system.

The principal metrics and reported values are as follows.

Metric	FOCCA	FOGNITE
Average Response Time (ms)	120	85
Load Balancing Efficiency (%)	78	92
Energy Consumption (kWh)	1.2	0.9
Model Accuracy (%)	85	91
Fault Recovery Time (s)	4.5	1.8

These results correspond to a response-time reduction from 120 to 85 ms, a load-balancing increase from 78% to 92%, an energy-consumption reduction from 1.2 to 0.9 kWh, a model-accuracy increase from 85% to 91%, and a fault-recovery reduction from 4.5 to 1.8 s. Runtime errors over 72 hours are reported as 187 for FOCCA and 112 for FOGNITE, equivalent to approximately 2.6 and 1.6 errors per hour, respectively, or about 40.1% fewer runtime errors. The abstract additionally reports up to a 93.7% improvement in load balancing accuracy and a 63.2% reduction in energy waste under specific experimental configurations (Sobati-M, 22 Jul 2025).

The source attributes performance gains to the combination of better local adaptation through federated learning, dynamic task placement through PPO-based scheduling, and pre-deployment validation through digital twins. It also notes an architectural and computational trade-off: FOGNITE increases computational and memory complexity per node, but the distributed training and operational improvements offset that overhead in the reported setting.

Scalability is analyzed through asymptotic complexity. Centralized FOCCA training is given as $\mathcal{T}_m$2, whereas FOGNITE training across $\mathcal{T}_m$3 nodes is

$\mathcal{T}_m$4

with the $\mathcal{T}_m$5 term representing aggregation overhead. Inference complexity rises from $\mathcal{T}_m$6 in FOCCA to $\mathcal{T}_m$7 in FOGNITE because of RL overhead. Communication shifts from raw-data transfer $\mathcal{T}_m$8 to model-parameter transfer $\mathcal{T}_m$9. Load balancing increases from rule-based $w^{(k)}$0 to RL-based $w^{(k)}$1, and memory from $w^{(k)}$2 to $w^{(k)}$3.

The stated limitations are correspondingly concrete. Deployment effort is roughly 15% higher than FOCCA because of the modular FL + RL + DT design. Memory demand per fog node is about 20% higher. RL incurs an initial learning phase associated with 5–10% startup latency before convergence to effective policies. The digital twin models, especially at cloud tier, rely on probabilistic abstractions rather than full physical power-flow equations. Transfer to different grid topologies requires careful tuning because RL is trained on a specific testbed. Future work proposed by the authors includes 5G integration, blockchain-secured FL updates, pushing digital twins to embedded edge devices, multi-objective RL possibly using transformer-based models, and real-world microgrid pilot deployments (Sobati-M, 22 Jul 2025).