Paying for Contributions You Cannot See: Budget-Balanced Transfers Under Secure Aggregation

Federated learning trains one shared model across many data holders, such as hospitals, banks or phones, without moving their data. Each participant trains locally and sends back only a parameter update. That shared model is a public good, and public goods invite free-riders: a participant can skip the costly work of collecting, cleaning and training on data and still receive the final model. The fixes that work today require the server to look at each participant's update. Secure aggregation is the cryptographic protocol that lets the server see only the sum of updates, and it is exactly what privacy-sensitive deployments rely on. It rules those fixes out. The result is an uncomfortable trade: operators can protect privacy, or they can stop free-riding, but not both.

We propose a mechanism that does both. It works like a Pigovian tax, meaning a charge or subsidy equal to the cost or benefit one's actions impose on others. Every round, each participant's peers estimate how much that participant's update helped the shared model, using contribution scores already known to work under secure aggregation. A running ledger averages these noisy estimates over many rounds. Participants whose accumulated score falls below their comparison group's average pay the difference to those above it. Transfers sum to zero by construction, so the operator needs no outside budget. Evaluators are assigned so that no participant's own reports can change its own payment. The claim is that this combination turns contributing into each participant's best response, even when the server never sees an individual update. We test that claim against participants who learn to shirk strategically.

Core Claim

The research file shows the missing link clearly. Private and Robust Contribution Evaluation in Federated Learning builds two contribution scores that survive secure aggregation. Its Everybody-Else (EE) score has clients evaluate each other rather than themselves. That paper stops at measurement and never turns the scores into incentives. FACT or Fiction: Can Truthful Mechanisms Eliminate Federated Free Riding? does the reverse. It builds a mechanism that makes truthful cost reporting and adequate contribution the dominant strategy, but its server must inspect individual contributions against a benchmark, so it is incompatible with secure aggregation. LOPT: Learning Optimal Pigovian Tax in Sequential Social Dilemmas shows that taxing negative externalities and subsidizing positive ones can rescue a shared resource in multi-agent games. It needs a planner that observes everything, and it leaves budget balance open.

Our mechanism takes the scoring from the first paper, the idea of decoupling a participant's reward from its own reports from the second, and the externality-pricing logic from the third. Let $s_k^t$ be the secure-aggregation-compatible score that participant $k$'s peers assign to its round-$t$ update. Let $\bar s_k$ be its exponentially weighted average over rounds, which we call the ledger. Let $C_k$ be $k$'s comparison group. The transfer $k$ receives is

$$ \tau_k = \alpha\Big(\bar s_k - \frac{1}{|C_k|}\sum_{j \in C_k} \bar s_j\Big), $$

where $\alpha$ converts score units into payment units. We partition clients at random into two halves, A and B. Members of A evaluate members of B and vice versa, and each client is compared only against members of its own half. Under this assignment, transfers sum to zero within each half, and $k$ never scores anyone in $C_k$. Without this assignment, budget balance would create a new perverse incentive: every client would gain by scoring its rivals low.

The underlying logic is the Groves-style argument. If $\bar s_k$ is an unbiased estimate of $k$'s marginal effect on the shared model, then $k$'s transfer moves one-for-one with the benefit its effort creates for others. Effort is worth spending whenever $\alpha\, \partial \bar s_k / \partial e_k$ exceeds the marginal cost of effort $e_k$.

The mechanism can fail in two known ways, and the proposal is built around them. The first is noise. Leave-one-out style marginal estimates in deep networks are very unstable. Leave-one-out Unfairness reports prediction flips for 77% of individuals on LFW when a single training point is removed. A per-round score may therefore be too noisy to reward effort reliably. This is the federated version of the moral-hazard gap that Mechanism Design Is Not Enough: Prosocial Agents for Cooperative AI identifies when effort is unobservable. The ledger exists to average that noise away across the repeated game. The second is score leakage. EE deliberately relaxes the "null player" property, so a client that contributes nothing may still receive a small positive score. Whether that residual is enough to sustain free-riding is an empirical question we answer directly.

Research Program

We first build a strategic-client simulator on top of standard FedAvg with secure aggregation simulated as sum-only visibility at the server. Each client is a simple learning agent, a multi-armed bandit over rounds. It chooses from an effort menu:

  1. full local training on all its data;
  2. training on a fraction of its data or with fewer local steps;
  3. plain free-riding, returning a zero update;
  4. disguised free-riding, returning the global model plus calibrated Gaussian noise.

The last option follows Free-rider Attacks on Model Aggregation in Federated Learning. That paper proves such clients look like perfect inliers and barely slow convergence, which is precisely why each individual is tempted to defect. Clients have private, heterogeneous per-sample costs. Their utility is a logistic function of their own test accuracy, following SPACE: Single-round Participant Amalgamation for Contribution Evaluation in Federated Learning, minus effort cost, plus transfer. This setup makes free-riding individually rational under plain FedAvg, which is the social dilemma we want to reproduce before we try to remove it.

Second, we implement the mechanism with EE scores and with the other secure-aggregation-compatible score from the same paper, Fair-Private (FP). We also adapt EE so that evaluators come from the opposite half. Whether EE's cross-evaluation can be restricted this way without breaking its secure-aggregation guarantee is a design risk we will check first.

Third, we analyze when the ledger restores the incentive. We model the score as marginal effect plus zero-mean noise of variance $\sigma^2$ that is independent across rounds, and use ledger averaging window $H$. The noise in $\bar s_k$ then shrinks roughly as $\sigma/\sqrt{H}$, because averaging independent errors reduces their spread by the square root of the count. This predicts a minimum window, depending on $\alpha$ and the cost spread, above which full effort becomes the learned behavior. We then check the prediction empirically.

Fourth, we stress the mechanism with two adversaries. One is a coalition of colluding evaluators, the weakness FACT names explicitly. The other is a group of clients that exploit EE's null-player relaxation.

Baselines

The naive reference point is plain FedAvg under secure aggregation with no incentive, run with the same strategic clients. It measures how far the dilemma degrades equilibrium effort and accuracy. We expect it to converge toward widespread free-riding. Because the free-rider paper shows accuracy stays close to the fair-only baseline at moderate free-rider fractions and only drops sharply near 90%, we will report the free-rider fraction alongside accuracy.

The strongest existing method is FACT. We run it with the server allowed to inspect individual contributions, because that is the only way it works. It therefore serves as a privacy-violating upper reference, not a same-conditions competitor. It uses the same partitions of CIFAR-10 and HAM10000, the same client cost distributions and effort menus, the same number of rounds, and the same hyperparameter search budget for its penalty scale as we give our $\alpha$ and $H$. FACT reports reducing agent loss by over 3x on CIFAR-10 and 66% for resource-constrained hospitals on HAM10000, both relative to local training. We will reproduce these figures in our harness before comparing. Beating FACT is not the target. Success means matching its equilibrium contribution rate and loss within a few percent while never exposing an individual update.

The simple secure-aggregation-compatible competitor pays clients in proportion to leave-one-out self-evaluation, with the same budget-balancing and tuning. It shows what the manipulation-resistant score adds. The key ablations remove one ingredient at a time. They are per-round EE transfers without the ledger, EE with the ledger but without the half-split evaluator assignment, and FP substituted for EE. The mechanism counts as working only if the full version sustains a markedly higher full-effort fraction than every ablation at equal global accuracy.

We found no reported ranking-correlation number on Lacuna for EE or FP, and no reported raw accuracy for FedEgoists. For those, we rely on our own reproductions.

Why not just…?

Why not just filter free-riders with robust aggregation or anomaly detection? Under secure aggregation, the server cannot see individual updates to filter them. Even without secure aggregation, Free-rider Attacks on Model Aggregation in Federated Learning shows disguised free-riders sit near the mean update and defeat outlier-based defenses. We include a cosine-filtering arm run without secure aggregation to confirm this in our harness.

Why not just pay each round in proportion to the EE score? This is the real threat. Our mechanism is that payment plus two additions, so if naive EE payment already works, the proposal reduces to a negative result about the extra machinery. The per-round-transfer ablation and the no-split ablation test this head-on. Our prediction is that the per-round version fails in the noisy, non-IID cross-silo settings, and that dropping the split lets clients profit by scoring rivals low. If neither failure appears, we will report that and recommend the simple version.

Why not just drop secure aggregation and use FACT? In regulated cross-silo settings, individual updates leak information, which is why secure aggregation exists. FACT itself lists the incompatibility as open. The comparison against FACT-with-inspection measures what staying private costs.

Why not make clients prosocial instead? Mechanism Design Is Not Enough: Prosocial Agents for Cooperative AI shows prosocial utilities close incontractible gaps. The same paper also shows that prosocial agents are exploited by selfish ones unless there is verification. An operator also cannot set a competitor hospital's utility function. The ledger serves as that verification layer. We add an arm mixing prosocial and selfish clients to see whether transfers protect the prosocial ones.

Proposed Experiments

We run on CIFAR-10 with Dirichlet label skew, on HAM10000 and ISIC2019 as cross-silo medical consortia, and on FEMNIST from LEAF: A Benchmark for Federated Settings for natural user heterogeneity at larger client counts. We report five metrics. The central one is the equilibrium fraction of clients choosing full effort, measured after bandit learning stabilizes. The others are global test accuracy with 10th and 90th percentile client accuracy following LEAF, social welfare net of effort cost, realized budget imbalance, and the free-riders' gain relative to contributors.

Three results are decisive:

  1. Ledger check. We sweep the averaging window $H$ and the noise level, the latter by varying local batch size and non-IID severity. The minimum window at which full effort becomes the learned behavior should track the square-root prediction. If effort never stabilizes at any $H$, the moral-hazard gap is binding and outcome-based transfers are insufficient.
  2. Leakage check. We measure whether disguised free-riders' accumulated EE score stays above zero enough to outweigh their saved cost. This settles whether EE's relaxed null-player property is practically exploitable.
  3. Collusion check. We vary the fraction of colluding evaluators and locate the point where the half-split assignment stops protecting honest contributors. This gives an explicit bound on the mechanism's robustness, which FACT does not supply.