Federated Satellite Learning Overview

• Federated Satellite Learning is a distributed training paradigm where satellites and ground systems train locally and exchange model updates to preserve data privacy.
• It leverages intermittent, deterministic connectivity driven by orbital mechanics, enabling architectures like ground-assisted, intra-orbit, hierarchical, and OTA aggregation.
• Resource constraints and security challenges are addressed via energy-aware scheduling, blockchain-backed trust, and optimized communication protocols to enhance efficiency.

Federated Satellite Learning (FSL) is the application of federated learning to satellite constellations and ground-to-satellite systems, in which satellites or other satellite-connected participants train on local data and exchange model updates rather than raw data. Across the literature, FSL is characterized by deterministic but intermittent connectivity driven by orbital mechanics, time-varying multi-hop topologies with or without inter-satellite links (ISLs), contact-driven orchestration through ground stations or on-orbit parameter servers, and a relatively small but centrally manageable client population compared with terrestrial mobile FL (Matthiesen et al., 2022). In concrete implementations, FSL has been realized as ground-assisted FL in LEO constellations, on-board FL over intra-orbit rings, hierarchical clustered FL, satellite-assisted heterogeneous FL, over-the-air aggregation, split-federated learning, and blockchain-backed secure multi-vendor collaboration (Razmi et al., 2021).

1. Definitions, scope, and architectural regimes

A recurring definition treats FSL as a distributed training paradigm in which multiple satellites train locally on onboard datasets and collaborate by exchanging model updates, not raw data. Aggregation can occur at a ground station, a high-altitude platform (HAP), an on-orbit parameter server, or through decentralized mechanisms over ISLs. This preserves data privacy and reduces bandwidth relative to raw data transmission (Carlos et al., 2023).

The literature distinguishes several communication regimes. One taxonomy classifies FSL by communication capabilities, constellation design, and parameter-server placement: systems without ISLs and a ground-based parameter server correspond to sporadic direct connection; systems with intra-orbit ISLs and an on-orbit or ground parameter server can provide near-persistent cluster-to-server reachability; inter-plane or multi-hop inter-cluster systems point toward distributed or “true in-constellation FL” (Matthiesen et al., 2022). A related 6G-oriented formulation places FL clients on the ground and satellites as relays or aggregators, yielding a cloud-server mode and a satellite-server mode; the latter reduces latency by avoiding additional satellite–cloud and ISL delays in each round (Chen et al., 2021).

Concrete system realizations span several layers of the stack. Ground-assisted asynchronous FL uses a single ground station as coordinator and exploits deterministic pass sequences to update the global model whenever a satellite contacts the station (Razmi et al., 2021). On-board FL for satellite clusters uses intra-orbit ISL rings so that each orbital plane behaves as a connected cluster from the ground station’s perspective (Razmi et al., 2024). Hierarchical clustered FL partitions the network into satellite regions, designates one satellite per cluster as an in-orbit parameter server, and uses ground stations only at the global aggregation stage (Liu et al., 18 Feb 2025). Satellite-assisted terrestrial FL instead uses LEO satellites as relays for peer-to-peer personalized model exchange among ground devices while terrestrial servers maintain the global model (Zhang et al., 2024). This suggests that “FSL” in current usage encompasses both satellite-as-client and satellite-as-infrastructure formulations, provided that orbital connectivity and space-segment constraints materially shape the learning protocol.

2. Learning objectives and aggregation mechanisms

The underlying optimization problem is usually standard empirical risk minimization. A representative formulation is

$F(w) = \sum_{k} \frac{D_k}{D} F_k(w),$

with local losses defined over each client’s dataset and global aggregation implemented by FedAvg-style weighted averaging (Razmi et al., 2024). In ground-assisted LEO FL, the paper states the empirical objective as

$$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$

and studies synchronous FedAvg, FedAsync, and an “unrolled” asynchronous FedAvg procedure called FedSat (Razmi et al., 2021).

Several distinct aggregation patterns appear in the FSL literature. The simplest is direct global aggregation at a ground station, as in synchronous FedAvg or asynchronous convex mixing of arriving updates (Razmi et al., 2021). A second pattern is intra-orbit aggregation: satellites in the same orbital plane build a ring or tree, compute partial aggregates hop by hop, and deliver only one per-plane update to the parameter server (Razmi et al., 2023). A third pattern is hierarchical aggregation. FedHC performs stage-1 cluster aggregation at a satellite parameter server, then stage-2 ground-station aggregation across visible cluster parameter servers; within each cluster it uses loss-based weights

$p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$

and globally it aggregates with dataset weights $D_k/D$ (Liu et al., 18 Feb 2025). OrbitChain introduces another hierarchical variant: satellites send encrypted updates to HAPs, HAPs compute local aggregates with trust- and freshness-aware weights $\alpha_{v,k}^t$, and cross-HAP fusion uses weights $\beta_h^t$ (Elmahallawy et al., 9 Dec 2025).

Other works modify the model factorization itself. SFL-LEO combines split learning with FL by splitting the model into satellite-side and ground-side sub-models, adding an auxiliary satellite-side network so satellites can continue local updates while disconnected, and aggregating the client-side sub-models asynchronously with staleness-aware weighting (Wu et al., 18 Apr 2025). A related, more general split-learning work proposes Communication and Storage Efficient FSL, where a client-side auxiliary network removes the need for server-to-client gradient transmission and allows the server to keep only a single server-side model (Mu et al., 2023). Although that work is not satellite-specific, it provides a concrete model of FSL as “partitioned model” training and is directly relevant to satellite environments with constrained onboard computation.

Over-the-air FSL defines aggregation at the physical layer. In the scalar AirComp form,

$y = \sum_{i=1}^{N} h_i x_i + n,$

and in vector form with a receive array,

$y = Hx + n.$

With $x_i = g_i w_i$ and $g_i \approx \alpha_i/h_i$, the receiver analog-computes the desired weighted sum of local updates up to noise and mismatch (Carlos et al., 2023). This does not replace the FL objective; it replaces the communication primitive used to realize aggregation.

3. Connectivity, scheduling, and communication geometry

The dominant systems issue in FSL is not merely limited bandwidth, but the interaction between visibility windows, orbital periodicity, and aggregation timing. In the absence of ISLs, the main bottleneck is the ground-station contact process. FedSpace formalizes this as a staleness–idleness trade-off: if aggregation is too frequent, received updates are stale; if aggregation is too infrequent, many contacts become idle because satellites have no fresh update to send. It defines staleness

$$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$0

and idleness

$$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$1

then schedules aggregation decisions over a horizon using a learned utility function (So et al., 2022).

Visibility-aware scheduling is also central when ISLs are present. A two-level scheduler for on-board FL uses a Global Update scheduler at the ground station and a Cluster Update scheduler within each orbit. The global scheduler sets the next aggregation time

$$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$2

while the cluster scheduler allocates local epochs by

$$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$3

so local training duration is proportional to usable time before the next global update (Razmi et al., 2024). This is a direct exploitation of predictable orbital visibility rather than random client participation.

In-network aggregation over ISLs further transforms the timing model. “On-board Federated Learning for Satellite Clusters with Inter-Satellite Links” organizes each orbital plane as a stable ring, distributes the global model via ISLs, and aggregates partial updates along a directed tree toward a sink satellite selected predictively using orbital propagators (Razmi et al., 2023). “Sparse Incremental Aggregation in Satellite Federated Learning” retains the same ring but introduces sparse incremental aggregation and constant-length sparse incremental aggregation; the latter enforces a fixed per-hop payload of $$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$4 bits and yields bandwidth-efficiency gains that exceed $$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$5 as the number of satellites per orbital plane increases (Razmi et al., 20 Jan 2025). This suggests that in FSL, scheduling and aggregation are inseparable from topology: the aggregation rule determines whether orbital connectivity acts as a bottleneck or as a computational resource.

A distinct communication-geometric line models the satellite link itself. In OTA FSL, satellites are transmitters on a spherical shell and the receiver is equipped with a linear array. The channel is determined by array factors and satellite angles, with unitarity and maximum-capacity conditions obtained by phase placement

$$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$6

The same work analyzes a Rotman lens transfer matrix

$$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$7

for true-time-delay beamforming in KU-band satellite systems (Carlos et al., 2023). In a related MIMO-broadcast study, the channel adopts a Vandermonde LoS structure, and average capacity is approximated through eigen-moment expansions of $$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$8 (Pinard et al., 2023). Those works are communication-theoretic rather than algorithmic, but they establish the physical-layer conditions under which satellite FL traffic can be delivered or aggregated efficiently.

4. Resource constraints and systems co-design

Energy, onboard compute, and model size strongly constrain FSL. An explicit energy-aware treatment considers synchronous FL over 20 Starlink LEO satellites and two ground stations over a 96-hour horizon. Training is scheduled across sunlight and eclipse intervals to minimize battery cycle-life consumption without changing the FL cadence or the number of local epochs. The scheduler solves a difference-of-convex program over sunlight and eclipse compute allocations $$\min_{\theta\in\mathbb{R}^d} \sum_{k\in K} \frac{n_k}{n}\frac{1}{n_k}\sum_{x\in D_k} f(x;\theta),$$9, using a Lithium-ion battery aging model based on depth-of-discharge. With $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$0 minutes, $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$1 W, $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$2 W·min, and $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$3, average consumed cycle life drops from 2.88 cycles to 0.76 cycles, yielding “more than 3× improvement” in battery lifetime over energy-agnostic scheduling (Razmi et al., 2024).

Several other works reduce resource pressure by redesigning the learning task. FL-SEC applies personalized divide-and-conquer to decompose a multi-class problem into binary one-vs-all subtasks across satellites in an orbit, filters redundant satellite images, and performs orbital model retraining before any ground upload. It reports lightweight models with measured training power between 1.38 W and 2.25 W on Jetson Nano hardware, and model sizes from 0.437 MB to 26.68 MB depending on the task (Elmahallawy et al., 2024). SatFed addresses a different resource regime—satellite-assisted terrestrial FL—and prioritizes which personalized models to transmit over short contact windows using freshness-based queues. It uses measured Starlink rates of roughly 100 Mbps downlink and 12 Mbps uplink, which makes “upload-all-cache” strategies untenable and motivates queueing by freshness gap (Zhang et al., 2024).

Model placement also matters. Space-ification analyses that adapt off-the-shelf FedAvg, FedProx, and FedBuff to Walker-Star polar LEO constellations conclude that connectivity, not compute, is the dominant bottleneck for the small models considered, and that access-aware scheduling plus intra-cluster relays can reduce multi-month training cycles to days. In that study, parameter sweeps cover up to 100 satellites, ground networks of up to 13 stations, and cluster sizes up to 10; deeper clusters are generally more beneficial than increasing the number of clusters, because co-orbital trailing produces near back-to-back ground contacts (Kim et al., 18 Nov 2025). This suggests a systems principle visible across the literature: FSL performance is often limited less by SGD itself than by how much orbital motion can be turned into scheduled communication opportunities.

5. Security, trust, privacy, and failure handling

Privacy by data locality is a baseline property throughout the literature: raw data remain on satellites or end devices, and only model parameters, gradients, or split activations are exchanged. Multiple papers state this directly but do not add formal differential privacy or secure aggregation mechanisms (Carlos et al., 2023). Where stronger guarantees are required, blockchain-backed trust layers and cryptographic provenance have been proposed.

OrbitChain targets multi-vendor LEO networks and uses HAPs as permissioned Proof-of-Authority validators. Satellites train locally, send encrypted updates and minimal metadata to HAPs, and only updates with valid signatures and on-chain digests are aggregated. The framework records Commit, PartialAgg, GlobalAgg, and Distribute events, and uses rolling Merkle accumulators to provide end-to-end provenance; its deterministic finality threshold is

$p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$4

with prototype quorum settings of 1-of-5, 3-of-5, and 5-of-5 validators (Elmahallawy et al., 9 Dec 2025). The main purpose is not faster learning in isolation, but trustworthy aggregation under collusion, replay, equivocation, and stale or incomplete contributions.

SBFL-LEO implements a sharded blockchain with role specialization. Each cluster forms a shard with learners, miners, and a head satellite. Learners train locally; miners compute cosine similarity to the previous global model, cluster updates with DBSCAN, aggregate within each density-consistent group, and vote for the best group aggregate; heads perform cross-cluster validation and maintain model and reputation chains (Wu et al., 2024). The framework assumes majority-vote correctness when malicious miners or heads are below 50%, and it reports higher resilience than cosine-similarity thresholding alone under poisoning scenarios.

Robustness also appears outside explicit security frameworks. In asynchronous split-federated learning, stale client-side models are weighted by a function proportional to $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$5 with $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$6, and updates that exceed a staleness threshold may be dropped (Wu et al., 18 Apr 2025). In asynchronous cluster-based FL, minimum inter-update time $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$7 is used to avoid bias toward densely connected clusters (Razmi et al., 2023). Failure handling in in-network aggregation includes “determine-new-sink,” which predictive rerouting studies show can reduce failure-handling time by roughly $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$8 versus fixed-direction relaying as cluster size increases (Razmi et al., 2023). A common misconception is that satellite FL is naturally secure because data remain local; the literature instead shows that model manipulation, stale-update bias, and compromised relays remain central concerns, and that privacy-by-locality does not obviate provenance, validation, or robust aggregation.

6. Empirical performance, trade-offs, and open directions

Reported performance spans communication efficiency, convergence time, energy, and consensus latency, but the metrics are highly architecture-dependent. In ground-assisted asynchronous LEO FL, FedSat is consistently more robust than FedAsync under heterogeneity and avoids the severe wall-clock penalties of synchronous FedAvg, whose first iteration can exceed 9 hours in a five-plane constellation (Razmi et al., 2021). FedSpace, evaluated on 191 satellites and 12 ground stations with the fMoW dataset, reduces time-to-40% top-1 accuracy to 2.3 days in IID and 2.7 days in non-IID settings, compared with 3.2 and 4.4 days for FedBuff, and 30.3 and 45.8 days for synchronous FL (So et al., 2022). “On-board Federated Learning for Satellite Clusters with Inter-Satellite Links” reports up to a sevenfold increase in convergence speed and a $p_i = \frac{(1/L_i)}{\sum_{i\in C^k}(1/L_i)},$9 reduction in communication load through in-network aggregation over ISLs (Razmi et al., 2023).

Hierarchical and clustered designs emphasize time–energy trade-offs. FedHC reports up to about $D_k/D$0 reduction in processing time and up to about $D_k/D$1 reduction in energy consumption compared to centralized C-FedAvg, while maintaining or improving accuracy relative to clustered baselines (Liu et al., 18 Feb 2025). The energy-aware sunlight/eclipse scheduler improves battery lifetime by more than $D_k/D$2 without affecting FL convergence speed (Razmi et al., 2024). FL-SEC reports nearly $D_k/D$3 reduction in convergence time, training power as low as 1.38 watts, and accuracy up to roughly 96% on EuroSat through binary decomposition and orbital retraining (Elmahallawy et al., 2024).

Security-backed systems add another dimension. OrbitChain finalizes more than 1,000 blocks with sub-second latency—0.16 s, 0.26 s, and 0.35 s for 1-of-5, 3-of-5, and 5-of-5 quorums—and sustains throughput above 200 tx/s while reducing convergence time by up to 30 hours on real satellite datasets compared to single-vendor FSL (Elmahallawy et al., 9 Dec 2025). SBFL-LEO reaches 90% accuracy in 6.415 s and $D_k/D$4 rounds under its experimental setup, versus 9.331 s and $D_k/D$5 rounds for a cosine-similarity-only secure baseline; it also reports 266.34 J per round versus 285.48 J for FedAvg at 120 satellites (Wu et al., 2024).

Across these results, a stable set of trade-offs emerges. Communication efficiency and aggregation fidelity are in tension in OTA and sparse incremental aggregation; minimizing interference can reduce capacity; larger validator quorums improve safety but raise latency; more aggressive scheduling can reduce round duration but starve local computation; and more offloading from ground clients to satellites can reduce heterogeneity but increase satellite battery burden (Carlos et al., 2023). Open directions named repeatedly include realistic Doppler and fading models, multi-ground-station coordination, adaptive quorum and validator selection, secure aggregation and Byzantine robustness, joint optimization of power, bandwidth, scheduling, and client selection, cross-plane and inter-cluster aggregation, and learning-theoretic convergence analysis under orbital intermittency (Matthiesen et al., 2022). This suggests that FSL is no longer a single protocol family but a design space in which orbital mechanics, network topology, energy systems, and aggregation rules are co-equal determinants of learning behavior.