Paying for News, Not Agreement: Retrospective Credit for Federated Learning with Selfish Clients

In federated learning, many devices train a shared model on their own data and send back updates. Devices pay for this in battery, compute and bandwidth, so rational owners will cut corners unless they are rewarded. Two separate toolkits exist. Confidence gates are filters that decide whether an incoming update is trustworthy enough to apply, and they protect the model. Incentive mechanisms decide how much each participant is paid, and they keep participants honest about their costs. The obvious way to join them is to pay clients in proportion to their gate score. We argue this is a trap. Almost every gate in use measures agreement: with a server reference gradient, with past momentum, or with the majority. A selfish client can score perfectly by copying the direction the model was already moving, which costs nothing and teaches the model nothing. The same rule underpays honest clients whose data is unusual or whose sensors and links are degraded, because their updates disagree with the consensus.

We propose to pay for news instead. That means paying for the part of a client's update that the server could not have predicted from the model's own momentum, and only to the extent that the later movement of the model, driven by everyone else, turns out to confirm it. A copier's update contains no news and earns nothing. A client with degraded sensors or a bad link sends noise that is uncorrelated with where the model later goes, so it earns about zero but is not punished. A poisoner's news points against where the model later goes, so it earns negative credit. The sign of the credit separates malice from bad luck, and its size measures contribution. We will test this on standard non-identically-distributed federated benchmarks, on network traces, and on a small physical edge testbed. The physical testbed matters because the mechanism depends on timing and on missing updates, which closed-world simulation handles poorly.

Core Claim

Confidence-as-agreement is a sound rule for aggregation but an unsound rule for payment. Used as payment, it creates an equilibrium in which echoing the consensus is the cheapest high-paying strategy. A payment signal built from leave-one-out retrospective confirmation of the unpredictable part of an update has three properties. Copying earns zero in expectation. Honest effort on minority data earns positive credit once the rest of the federation catches up. Environmental degradation is attenuated rather than treated as defection.

Concretely, let $m_t$ be the server's global momentum at round $t$ and $g_{i,t}$ client $i$'s update. The news component is the residual after removing the predictable direction, $r_{i,t} = g_{i,t} - \frac{\langle g_{i,t}, m_t\rangle}{\|m_t\|^2} m_t$. Let $\Delta^{-i}_{t\to t+k}$ be the global model's movement over the next $k$ rounds computed from all clients except $i$, with its own projection onto $m_t$ removed to give $\tilde\Delta^{-i}$. Client $i$'s credit is then

$$C_{i,t} = \|r_{i,t}\| \cdot \cos\big(r_{i,t},\ \tilde\Delta^{-i}_{t\to t+k}\big).$$

Leaving $i$ out of $\Delta$ prevents a client from confirming its own claim. Payment is a monotone function of accumulated $C_{i,t}$, net of reported cost. Separately, a standard agreement gate decides how much weight the update gets in the aggregate.

Relation to Prior Work

The gating side supplies the method and the failure mode. FLTrust scores each client by the ReLU of cosine similarity to a gradient computed on a small clean server dataset, normalizes magnitudes, and zeroes updates more than 90° away. It reports an MNIST error of 0.04 under attack where Krum reaches 0.90. CAdam withholds coordinate updates whose current gradient disagrees with historical momentum, in a single centralized optimizer. Vision trackers gate memory updates on response-map peaks or a confidence threshold, as in Multi-step Temporal Modeling for UAV Tracking and DARTer. All of these reward agreement. None face an agent who chooses its update to maximize a payment. We keep FLTrust-style gating for aggregation. We take from CAdam the idea that momentum defines what is "already known", but we use it in the opposite way, as the thing to subtract before paying.

The incentive side motivates the gap. FACT makes truthful cost reporting a dominant strategy through penalized federated learning and a three-agent "sandwich" game. It reports loss reductions over local training of more than 4x on MNIST, 3x on CIFAR-10 and 66% on HAM10000. However, its proofs assume identically distributed data, and it never inspects the content of updates, so a client who truthfully reports costs and then sends a cheap echo is not caught. Joint Participation Incentive and Network Pricing Design treats learning value as a function of sample count inside a three-level leader-follower game, using Elisa Oyj traffic traces. Federated fog formation weights clients by dataset size. Volume-based value is exactly what an echo or dummy update can fake. We replace volume with confirmed news, and we can sit underneath FACT rather than compete with it.

The selfish-node literature constrains the design. Retaliation schemes such as Gradual strategies in Yan Lü and positive-only reputation in CORE treat poor service as deliberate. Under bursty real-world loss, that treatment causes honest nodes to punish each other. CORE's refusal to propagate negative reports is a useful warning. Negative credit should therefore affect only a client's own aggregation weight, never other clients' standing. Finally, DecTest and the EIP-2930 study (Dissecting the EIP-2930 Optional Access Lists) show two things: incentive designs are typically validated only on synthetic agents, and they can fail on live infrastructure (1.46% adoption in that study). This shapes our evaluation.

Research Program

The first piece of work is analytic. In a stylized model where clients choose effort and can copy $m_t$ at zero cost, we will show three things. Under trust-score pay, copying weakly dominates whenever the honest update's expected cosine with the reference is below one. Under retrospective credit, copying yields zero expected credit. Honest effort yields positive expected credit whenever the client's data shifts the population optimum. We will also characterize how $k$, the confirmation horizon, trades off two quantities. A longer $k$ lets minority data be confirmed. A shorter $k$ means faster pay and less exposure to client churn. We expect credit for a client holding a fraction $p$ of a minority distribution to be confirmed roughly when the other clients' cumulative movement toward that distribution exceeds noise. This argument suggests a horizon that scales with $1/p$, and we will check that prediction empirically rather than assume it.

The second piece is the system. A server keeps per-round residuals with a bounded history. These can be compressed by random projection so that storage does not grow with model size. The server computes leave-one-out movements incrementally and settles payments with a delay of $k$ rounds. Reported costs still enter through a FACT-style layer, so cost truthfulness and content value are handled by separate parts of the mechanism.

The third piece is adversarial. Colluding clients could each submit the same fabricated residual and confirm each other, because leave-one-out removes only one of them. We will test leave-group-out variants. These remove clusters of mutually similar residuals before computing $\Delta$, and the agreement gate bounds how far any coalition can move the model. This is the main known weakness, and we report it as such.

Baselines

The do-nothing reference is federated averaging with a flat payment per participating round. It shows how fast rational simulated agents decay to minimum effort when content is not checked.

The obvious combination is FLTrust aggregation with payment proportional to each client's trust score FLTrust. It is the most natural competitor and the one our core claim predicts will reward copiers. It will use the same 100-sample root set and the same rounds as our method.

The strongest incentive method is FACT, run with its own penalty and sandwich game on the same partitions. We will also run FACT stacked on FLTrust aggregation. The strongest number in the file for this line is FACT's reported loss reduction over local training: more than 4x on MNIST, 3x on CIFAR-10, and 66% for constrained hospitals on HAM10000. The file reports no accuracy figures for FACT under non-identically-distributed partitions or under copier attacks. For FLTrust, the file's only number is an MNIST error of 0.04 under attack, and it contains no reported result on Lacuna for FLTrust on CIFAR-10.

The strongest content-based alternative is immediate marginal value: pay by the reduction in root-set loss from adding the client's update, which is a leave-one-out contribution score. This also serves as the ablation for our retrospective ingredient.

Two further ablations isolate our ingredients. The first is retrospective credit without subtracting momentum, which tests whether removing the predictable direction matters. The second uses $\Delta$ including client $i$, which tests self-confirmation.

All methods will share the same partitions, model, round budget, root set, communication budget, and an equal hyperparameter search of twenty configurations each. Beating the baselines means three things. Copier payoff minus honest payoff must be negative for our method and non-negative for trust-score pay. Global accuracy must stay within one standard deviation of FACT+FLTrust in clean settings. Minority-data and degraded honest clients must retain participation that is clearly higher than under trust-score pay or immediate marginal value.

Why not just…?

Why not just pay clients their FLTrust trust score? Because the score is cosine to a server gradient that is itself strongly correlated with momentum, so echoing $m_t$ earns a near-maximal score at zero cost. FLTrust never had to face this, since it assumes clients participate for free. Our first experiment measures the copier's payoff directly. If copiers turn out not to profit under trust-score pay, for instance because the root gradient decorrelates from momentum, our motivation weakens and we will say so.

Why not just use FACT, which already makes cost reporting truthful? FACT secures honest reports of cost and contribution volume, but it never looks at what an update contains. A client can truthfully report a low cost and then send a cheap echo. FACT's dominance proof also assumes identically distributed data. We will run FACT with injected echo clients under Dirichlet-skewed partitions. Our proposal is a content layer meant to complement FACT, and we expect the stack to be the best configuration.

Why not just pay by immediate marginal improvement on the server's clean data? This is the real threat. It already penalizes copiers, because an echo adds little beyond momentum, and it needs no delay. Its weakness is that the root set reflects the server's distribution. Clients holding rare classes or rare hospitals' images help the population but may not reduce root-set loss. Immediate marginal value also cannot separate degradation from malice, since both simply fail to help now. The decisive experiment uses HAM10000 hospital splits and CIFAR-10 with held-out classes absent from the root set. If immediate marginal value matches our method's credit for minority clients there, the retrospective machinery is unnecessary and we would simplify to it.

Why not just use robust aggregation such as Krum or a median? These filter updates but pay nothing, so rational clients have no reason to spend battery. They also fail without a root of trust: the 0.90 Krum error in FLTrust shows this. Robust aggregation answers the question of which updates to apply, not who deserves payment.

Proposed Experiments

On MNIST, CIFAR-10 and HAM10000 under Dirichlet non-identically-distributed partitions, we will mix five client types. Honest clients have majority data. Honest clients have minority data. Honest clients are degraded by blur, low-light darkening and label noise. Copiers echo $m_t$ or the last global delta. Poisoners use sign-flipping and scaled attacks. Clients are learning agents that choose effort to maximize payment minus a private cost, so equilibrium behavior is observed rather than assumed.

The metrics fall into four groups. The first is final accuracy, overall and per minority group. The second is the payoff gap between each strategy and honest effort. The third is the effort level reached after best-response dynamics. The fourth is the rank correlation between credit and true contribution. True contribution will be measured by exact leave-one-out retraining on a 20-client subset, where this is affordable. We will also measure how well the sign of credit separates poisoners from degraded clients, reported as area under the curve.

Trace-driven runs will add two sources of realism. Elisa Oyj hourly load will drive delays and drops caused by congestion. The WS-Dream QoS data will set per-client throughput heterogeneity, so that straggling and missing rounds come from measured distributions rather than Gaussian noise.

Finally, we will run a 16 to 24 node physical deployment on embedded boards of the Jetson AGX Xavier class used in Multi-step Temporal Modeling for UAV Tracking, over shared Wi-Fi. This will test whether delayed settlement, residual storage and leave-one-out computation survive real asynchrony, real thermal throttling and real bursty loss. We will compare the ranking of methods on hardware with the ranking in trace simulation. If the rankings flip, that is itself a reportable finding about the reality gap.

The decisive checks are four. Trust-score pay must reward copiers while retrospective credit does not. Minority and degraded honest clients must keep participating under our scheme, where they drop out under immediate marginal value. The sign of credit must separate poisoners from degraded clients. These conclusions must hold on hardware, not only in simulation.