Federated learning trains one shared model across many devices without collecting their raw data. Each device trains locally and sends back only a weight update. When no single party can be trusted to combine those updates, a blockchain (a ledger replicated across mutually distrustful validators, who must agree before anything is written) can take over that role. The price is delay. Every update has to be ordered into blocks, agreed on, and checked for conflicting writes before it counts. For models that track a changing world, such as cellular traffic, vehicle flows or sensor telemetry, what matters is how old the information inside the currently committed model is, not how many transactions per second the ledger sustains. We propose to measure that staleness directly, as the "age" of the committed global model. We then use a genetic algorithm to choose, before training runs, which clients feed which validator committee and when each committee cuts a block. The aim is to minimize that age without sacrificing accuracy.
The claim can be tested and is not obvious. Blockchain freshness studies already show that ledger parameters affect staleness non-monotonically. They also show that sending updates more often can make data older, because conflicting writes get rejected. But those studies only cover scalar sensor readings. Blockchain federated learning systems, for their part, optimize round latency or energy and never ask how old the committed model is. We argue that model age, not round latency, is the quantity that predicts the model's prediction error on drifting data. We also argue that minimizing it requires deciding jointly which client goes to which committee and which late updates to drop. That joint decision is a discrete assignment problem that a tuned grid over block size cannot solve.
Core Claim
Following the redefinition of age in edge computing as the time since the earliest unprocessed packet (Age-Based Scheduling for Mobile Edge Computing), we define the age of the committed model at time $t$ as
$$A(t) = t - \min_{i \in S(t)} g_i,$$
Here $S(t)$ is the set of local updates folded into the most recent ledger-committed global model, and $g_i$ is the time client $i$ sampled the data and base model its update was trained on. Under this definition one stale contributor makes the whole model old. That is the right pessimism when the task drifts.
Our hypothesis has three parts. First, on drifting prediction tasks, the time-average of $A(t)$ predicts test error better than mean round latency or ledger throughput does. Second, $A(t)$ depends jointly on three decisions: the assignment of clients to validator committees, the per-committee block size and timeout, and a staleness admission threshold $\tau$. Updates older than $\tau$ are discarded rather than aggregated, which is the federated analogue of dropping an old packet mid-service to make room for a new one. Third, a genetic algorithm run offline against a calibrated ledger-and-channel simulator finds assignments that reduce $A(t)$ at matched accuracy, beyond what tuned scalar parameters with greedy client selection achieve.
The threshold $\tau$ matters because queueing theory predicts a trap here. With regular service times and high arrival rates, dropping in-flight packets to favor newer ones can drive age to infinity (Age of Information: The Gamma Awakening). Aggressively discarding late federated updates could likewise starve the ledger of completed contributions. Admitting them all makes the model old and invites rejected writes.
Where the Idea Sits
Two studies motivate the ledger side. Is Blockchain Suitable for Data Freshness? measured Hyperledger Fabric, a widely used permissioned blockchain. It found a U-shaped dependence of age on block size, with a sweet spot at a 0.3 s timeout and a block size of about 5. It also found that frequent writes to one key trigger multi-version concurrency control rejections: Fabric's check that discards a transaction if the value it read has since changed. Those rejections make data staler. Age of Information Analysis in Hyperledger Fabric Blockchain-enabled Monitoring Networks showed that Fabric consensus latency is well fit by a Gamma distribution. It also showed that raising the target wireless success probability can hurt age. We reuse both findings, the Gamma latency model and the rejection mechanism, to build our simulator. Both studies handle scalar sensor writes with fixed or swept parameters. Neither handles model updates whose usefulness depends on which base model they were computed from.
Three works constrain the federated side. BAFFLE splits models into chunks that fit Ethereum gas limits and tunes its round thresholds by hand. Trustworthy Federated Learning via Blockchain (B-FL) runs PBFT, a classic Byzantine-tolerant agreement protocol, over edge servers. It tunes continuous bandwidth and power with TD3, a deep reinforcement learning method for continuous actions, and targets round latency. Blockchain-based Federated Learning: A Comprehensive Survey names the mismatch between block intervals and training rounds as open but offers no freshness formulation. We take its "flexibly coupled" design, where validators are separate from training clients, as our architecture.
Two works supply the optimization method. A Safe Genetic Algorithm Approach for Energy Efficient Federated Learning contributes three pieces: penalty-based fitness for constraint violations, extra mutation when the population plateaus, and elitist memory. Crucially, it runs the genetic algorithm offline in a simulator, to avoid spending more than the optimization saves. DRDST shows that a genetic algorithm can partition ledger nodes into shards faster and more stably than standard genetic algorithms or differential evolution, though its objective is latency and load rather than freshness.
Our contribution differs from each of these in the same way. The chromosome encodes which client feeds which committee, plus each committee's block parameters and the admission threshold. The fitness is model age measured through a simulated ledger. Neither the Safe GA's energy objective nor DRDST's latency objective sees how stale the contributors are.
Research Program
The work proceeds in four stages.
Stage 1: testbed and calibration. We build a flexibly coupled testbed. There are $N$ training clients with heterogeneous compute and wireless links; the 40-worker, 80/20 high-end/low-end profile from the Safe GA paper provides a reproducible starting point. There are $K$ validator committees, each running a Fabric channel that aggregates its clients' updates, followed by a periodic cross-committee merge. Each client writes to its own ledger key, and only the aggregation transaction touches the shared model key. From this testbed we calibrate a discrete-event simulator. Consensus latency is Gamma distributed, with parameters fit by maximum likelihood per committee size and block configuration, as in the Fabric monitoring study. The rejection rate is a function of how many transactions touching the aggregate key share a block. Wireless delay follows Rayleigh fading at a chosen success probability.
Stage 2: offline search. The genetic algorithm searches offline against this simulator. A chromosome encodes a client-to-committee assignment, a block size and timeout per committee, and $\tau$. Fitness is the time-averaged $A(t)$ over a simulated horizon. A penalty applies whenever simulated accuracy after a fixed wall-clock budget falls below a floor; this penalty is what stops the search from buying freshness by excluding slow clients whose data are needed.
Stage 3: online adaptation with honest cost accounting. The deployed configuration is refreshed every epoch of several rounds by a short warm-started run seeded from the previous population. The wall-clock and energy cost of that run is charged to $A(t)$ itself, so the concern that optimization costs more than it saves is measured rather than assumed away.
Stage 4: validation on the real testbed. We check that the simulator's rankings of configurations match rankings measured on the real testbed.
Baselines
The naive reference is FedAvg on a single Fabric channel at the published sweet spot (0.3 s timeout, block size about 5) from Is Blockchain Suitable for Data Freshness?, with random client selection and every update admitted. That paper reports an age-violation probability below 0.1 at a threshold of roughly 1.9 s for scalar writes. There is no reported result on Lacuna for model age in a blockchain federated system. We will therefore report this baseline's age ourselves and use it as the zero point.
The strongest simple competitor is a tuned grid. It sweeps block size, timeout and $\tau$ exhaustively per committee, combined with the greedy selection scheduler used as a baseline in the Safe GA paper, which picks the fastest clients. It gets the same simulator, the same number of fitness evaluations as the genetic algorithm, and the same client-to-committee assignment rule (round-robin). To beat it, the genetic algorithm must lower time-averaged model age by a margin exceeding run-to-run variability over at least five seeds, at equal or better accuracy after a fixed wall-clock budget. If it cannot, the assignment component is not earning its keep.
The strongest existing optimizer is B-FL's TD3 allocator from Trustworthy Federated Learning via Blockchain. B-FL reports 97.9% MNIST accuracy with 40% malicious devices. We extend its action space with a relaxed, rounded assignment and train it with a matched simulator-step budget, with both its original round-latency reward and our model-age reward.
We also port the Safe GA with its energy and deadline fitness. That paper reports up to an 83% energy reduction over random selection, iterations 20% faster than random and 12% faster than greedy selection, and 0.04 deadline violations per worker; we check whether it reproduces the direction of those gains in our setting before using it.
Two ablations isolate the key ingredients. The first keeps our genetic algorithm but swaps the fitness to DRDST-style latency and load balance (DRDST). This isolates whether the freshness objective, rather than the search method, drives any gain. The second replaces the genetic algorithm with random search over the same chromosome and evaluation budget, to check that selection and crossover matter.
Why not just…?
Why not just tune block size and timeout by grid search, as the Fabric freshness study did? This is the most serious threat. If the only knobs were scalar ledger parameters, a grid would suffice and a genetic algorithm would be decoration. Our position is that the assignment of heterogeneous clients to committees dominates: a single slow client in a committee sets that committee's contribution age. That is a combinatorial choice a grid cannot cover. The tuned-grid baseline with greedy selection tests this directly. If it matches the genetic algorithm, we will report that the scalar parameters are enough and drop the assignment search.
Why not just use deep reinforcement learning, as B-FL does? B-FL shows that TD3 handles continuous power and bandwidth well. In the edge-computing age study, DDPG, a related actor-critic method, failed to converge after $10^6$ slots when learning scheduling from scratch (Age-Based Scheduling for Mobile Edge Computing). Discrete client-to-committee assignment also has no natural continuous relaxation. We do not treat this as settled: the TD3 baseline with the model-age reward and a matched budget is the test.
Why not just run asynchronous federated learning that accepts every update and down-weights stale ones? This removes scheduling entirely and is attractive. However, accepting everything means frequent writes to the shared aggregate key. Rejections of exactly this kind raised staleness in the Fabric freshness study, and the queueing analysis warns that neither "keep all" nor "drop all" is safe in general. Setting $\tau = \infty$ in our system is precisely this alternative, and we run it with staleness-discounted weighting as an additional baseline.
Why not just minimize round latency or maximize throughput? BLOCKBENCH reports Fabric peaking around 1,273 transactions per second on YCSB, a standard key-value workload, and struggling beyond 16 nodes (BLOCKBENCH). Yet high-throughput settings produced multi-second staleness in the Fabric freshness study. Whether this divergence carries over to model accuracy is the empirical question our first decisive check answers.
Why not just use a central aggregation server? This alternative sits outside our scope. We assume settings with no trusted aggregator, which B-FL's Byzantine results motivate. Even so, we report a centralized FedAvg run so readers can see the full cost of decentralization in model age.
Proposed Experiments
We need tasks where freshness should matter. The primary tasks are the Telecom Italia Milano and Trento cellular-traffic datasets, forecast hourly with the released chuanting/FedDA code, and the NYC taxi data used by BAFFLE. Both drift over time, so a model built from old samples should forecast worse. FedDA reports mean squared error gains over FedAtt of up to 10% and 30% on the two Telecom Italia datasets, which gives a reference scale for error differences. The Heart Activity non-IID data, MNIST and CIFAR-10 serve as stationary controls. On those tasks model age should matter little, and a method that "wins" on age there without an accuracy gain is suspect. No CIFAR-10 accuracy reported for B-FL was found on Lacuna.
We report the following metrics: time-averaged and peak model age; the probability that age exceeds a threshold; forecast error or accuracy against wall-clock time; the rejection rate; energy per client; and the optimizer's own compute cost.
Three checks are decisive.
Check 1: does model age predict error? Across all configurations visited during search, we regress test error at each time on $A(t)$ and, separately, on mean round latency, for both drifting and stationary tasks. The proposal's premise holds only if age explains substantially more error variance on drifting tasks and not on stationary ones.
Check 2: does the admission threshold show a non-monotonic effect? We sweep $\tau$ at the best found assignment, with regular versus highly variable client compute times, to test whether the Gamma-service prediction that "dropping stale work backfires" appears in federated aggregation.
Check 3: does search on assignment beat the alternatives? This is the head-to-head against the tuned grid, TD3 and asynchronous accept-all, with the optimizer's own cost charged. Scaling runs at 20, 40 and 100 clients and 1 to 8 committees show where, if anywhere, assignment search pulls away from the grid. We expect the gap to grow with client heterogeneity, because a single slow client dominates the minimum in $A(t)$.
References
- Age-Based Scheduling for Mobile Edge Computing: A Deep Reinforcement Learning Approach
- Age of information: The gamma awakening
- Is Blockchain Suitable for Data Freshness? - Age-of-Information Perspective
- Age of Information Analysis in Hyperledger Fabric Blockchain-enabled Monitoring Networks
- BAFFLE : Blockchain Based Aggregator Free Federated Learning
- Trustworthy Federated Learning via Blockchain
- Blockchain-based Federated Learning: A Comprehensive Survey
- A Safe Genetic Algorithm Approach for Energy Efficient Federated Learning in Wireless Communication Networks
- DRDST: Low-Latency DAG Consensus Through Robust Dynamic Sharding and Tree-Broadcasting for IoV
- BLOCKBENCH: A Framework for Analyzing Private Blockchains