Paying for Freshness, Not for Tasks: Outcome-Based Incentives for Age-Optimal Offloading

Phones and sensors that send status updates (camera frames, positions, readings) to an edge server face a choice on each update: process it locally, which costs battery, or offload it, which costs radio energy and server time. Most of the systems literature solves this choice with a single cooperative scheduler that commands every device. Real devices belong to different owners who pay their own energy bills and will not run a policy that drains them for someone else's benefit. The usual fix is to pay devices, and the usual payment is per task or per unit of offloaded work. We argue that this is the wrong thing to pay for when the platform cares about freshness. Freshness is measured by the Age of Information (AoI): how old the newest delivered update is at the receiver, a quantity that climbs steadily and drops each time a fresh update arrives. Prior work shows that keeping tasks fast is not the same as keeping information fresh, so a device paid per task will flood queues and leave old updates stranded.

The proposal is to pay each device a per-slot "freshness rent" that falls linearly with the age the platform itself observes at the receiver, and to charge a separate congestion price for edge compute cycles. Under this rule a selfish, battery-limited device that maximizes its own profit ends up minimizing exactly its share of the cooperative age-plus-energy objective. The platform sets two scalars per device class from quantities it can already see, without learning anyone's battery level, queue, or energy cost. We will prove this alignment, show that the more intuitive alternative of paying for each drop in age cannot work, and test the mechanism against per-task Stackelberg pricing, age-dependent posted prices, and learned multi-agent equilibria.

Core Claim

The claim rests on a moral-hazard observation. The platform cannot see a device's actions or private costs, but it does see the outcome it cares about, receiver-side age $\Delta_i(t)$ for device $i$'s stream. Contracting directly on that observable outcome should recover the cooperative optimum. Concretely, the platform pays device $i$ a per-slot amount $r_i(t) = a_i - b_i \Delta_i(t)$, where $a_i$ is a fixed participation payment and $b_i$ is a freshness rate. It also charges a price $q$ per edge CPU cycle. The device's long-run problem is then

$$\min_{\pi_i}\ \lim_{T\to\infty}\frac{1}{T}\sum_{t<T}\mathbb{E}\big[\,b_i\,\Delta_i(t) + \theta_i\,E_i(t) + q\,f_i(t)\,\big],$$

where $\pi_i$ is the device's own policy over sampling, waiting, local CPU frequency, and offloading. $E_i(t)$ is its energy use, $\theta_i$ its private per-joule cost, and $f_i(t)$ the edge cycles it consumes. The cooperative problem solved by Lyapunov methods in Joint Task Offloading and Resource Allocation for Obtaining Fresh Status Updates in Multi-Device MEC Systems minimizes $\sum_i w_i\Delta_i + \sum_i \theta_i E_i$ subject to edge capacity $\sum_i f_i \le F_{max}$. Here $w_i$ is the platform's value per unit of age on stream $i$.

Setting $b_i = w_i$ and $q$ equal to the capacity constraint's shadow price makes each device's problem exactly one block of the decomposed cooperative problem. The device's private cost $\theta_i$ enters both problems the same way, so efficiency needs no knowledge of $\theta_i$. Private information matters only for the fixed payment $a_i$, which determines how much surplus the platform gives away.

A natural first design pays devices for each drop in age. That design fails for a structural reason: age grows at slope 1 between deliveries, so the drops over a horizon $T$ add up to roughly $T + \Delta_i(0) - \Delta_i(T)$. Total payment is then almost independent of behavior, and holding updates back to make later drops larger costs the device nothing. We will state this as a short proposition. It is the reason the rent must be charged on the level of age, not on its decrements.

Relation to Prior Work

Two papers already combine incentives with freshness, and the contrast with each is specific. Meta-Computing Enhanced Federated Learning in IIoT builds a Stackelberg game whose server reward depends on a static "satisfaction" score mixing data size, AoI, and latency, and it learns the equilibrium with multi-agent reinforcement learning. Age there is a scalar feature of a one-shot contribution rather than a queue state evolving in time, and devices train locally rather than offloading. Task Freshness-aware Incentive Mechanism for Vehicle Twin Migration designs a one-shot contract menu under hidden costs for roadside-unit migration, trading bandwidth for an end-to-end age metric. It does not address repeated interaction or device battery dynamics.

The closest mechanism is Dynamic Pricing and Mean Field Analysis for Controlling Age of Information. It posts a price that rises with current age to induce crowdsensing users to sample. Its price depends on the age at the moment the user acts, and it models no computation or edge queue. Our rent instead depends on realized receiver-side age after queueing and processing. A device that offloads into a congested server therefore earns less, which a posted price cannot express. This paper is our most serious competitor and is treated as such below.

On the incentive side, Game-based Pricing and Task Offloading in Mobile Edge Computing Enabled Edge-Cloud Systems supplies the market structure we reuse: competing providers set compute prices and selfish devices split work to minimize delay, energy, and payment. We keep its congestion-pricing role, but its device objective uses latency. Our motivation for replacing latency comes from Age-Based Scheduling for Mobile Edge Computing: A Deep Reinforcement Learning Approach and Age Based Task Scheduling and Computation Offloading in Mobile-Edge Computing Systems. Both show that delay-oriented schedulers favor fresh small tasks and starve old head-of-line updates. A Crowdsourcing Framework for On-Device Federated Learning shows that uncalibrated rewards waste budget against heterogeneous hardware costs, which motivates the menu over $(a_i, b_i)$.

Two results constrain the device side. Joint Status Sampling and Updating for Minimizing Age of Information in the Internet of Things proves that sampling immediately after each delivery is suboptimal under energy limits. Any incentive that rewards activity per task pushes devices toward exactly that suboptimal behavior, whereas the rent leaves deliberate waiting profitable. Age of Information: The Gamma Awakening shows that the right queue discipline depends on the service-time distribution. We therefore treat the edge's discipline (first-come-first-served versus last-come-first-served without preemption) as a design variable rather than assuming exponential service as Age of Information of Multi-user Mobile Edge Computing Systems does.

The cooperative Lyapunov controller of Joint Task Offloading and Resource Allocation for Obtaining Fresh Status Updates and the virtual-energy-queue machinery of Stochastic Joint Radio and Computational Resource Management for Multi-User Mobile-Edge Computing Systems supply the method that each device runs privately. The only change is that the age weight comes from the contract rather than from a central designer.

Research Program

The theoretical part has three pieces. The first is the alignment theorem: under risk-neutral devices and linear rent, every follower equilibrium at $(b_i = w_i, q = q^\star)$ achieves the cooperative optimum. With per-device Lyapunov control, the per-slot drift-plus-penalty problem decomposes under the price, giving the same $[O(1/V), O(V)]$ age-backlog trade-off that the cooperative controller attains. Here $V$ is the knob that trades how close the controller gets to optimal age against how large its energy-deficit queue may grow.

The second piece is the telescoping proposition ruling out payment per age decrement. The third is the adverse-selection layer. When the platform also wants to keep its payments low and costs $\theta_i$ come from a known distribution, it offers a menu of $(a, b)$ pairs. Standard screening logic predicts it will shade $b$ below $w$ for high-cost types. We will characterize how much age this distortion costs, using the monotonicity tools that Task Freshness-aware Incentive Mechanism for Vehicle Twin Migration applies to non-concave contracts.

The algorithmic part has the leader learn $q$ online by raising it when aggregate edge demand exceeds capacity, a dual-ascent step that needs only observed load. The leader learns $b$ per class when $w_i$ is set by an upstream application.

The empirical part builds a slotted multi-user edge simulator. Its device energy coefficients come from Energy-efficient Caching and Task offloading for Timely Status Updates in UAV-assisted VANETs: $10^{-27}$ CPU energy coefficient, $10^{-8}$ J/bit transmission, and tasks of 100–150 Kbits needing $10^7$–$1.5\times10^7$ cycles. Two population scales follow prior work: 15 devices, as in He et al., and 50 devices over a 200 m cell, as in Su et al..

To escape the exponential-service assumption, we add a realistic workload. Device and edge compute times, plus payload sizes, are measured from split-computing models in SC2 Benchmark, using the sc2-benchmark code on ImageNet classification and COCO detection. A device's offload action then includes choosing among a few encoder-and-bitrate configurations. This gives nearly deterministic compute times, the regime where queue discipline matters most.

Baselines

The naive reference points are local-only execution and a flat per-task reward. Local-only is the floor any offloading mechanism must clear; He et al. report that their scheduler achieves average age about 4x lower than local-only. Flat reward is the "just pay them" reference whose inefficiency Pandey et al. quantify at up to 22% in reward efficiency (71% in randomized settings).

The incumbent incentive mechanism is per-task Stackelberg pricing in the style of Su et al.. Devices minimize a weighted sum of delay, energy, and payment, and the provider adjusts prices by backward induction. That paper reports a price of anarchy below 150%, follower convergence in 7 iterations, and a 7.5% revenue gain over uncoordinated pricing. None of those numbers measure age, so we rerun it in our simulator with its weights tuned on a held-out seed set.

The strongest freshness-aware incentive competitor is the age-dependent posted price of Dynamic Pricing and Mean Field Analysis for Controlling Age of Information, adapted to offloading. No reported number on Lacuna is comparable to our setting; the file says only that its approximate closed-form policy loses little relative to exhaustive dynamic programming. We also run a learned Stackelberg equilibrium with multi-agent deep deterministic policy gradients and an age-containing satisfaction utility, following Li et al.. That paper reports server utility at least 23.7% higher than its baselines on MNIST federated learning, a different task from ours.

The upper reference is the omniscient cooperative Lyapunov controller of Joint Task Offloading and Resource Allocation for Obtaining Fresh Status Updates, for which no reported numerical result was found on Lacuna. Alongside it we run the centralized learned scheduler of He et al..

Every method gets the same arrival traces, channel realizations, edge capacity, total payment budget, and an equal hyperparameter search of 50 configurations on separate seeds. Learned methods get the same number of environment slots. Beating the field means two things at equal budget: lower time-average age than every incentive baseline, and age within a few percent of the cooperative oracle.

Ablations isolate the key ingredient. The first ablation pays the rent on age measured at sampling time instead of at the receiver. The second ablation pays per age decrement, where the telescoping argument predicts the incentive collapses. The third removes the congestion price. The fourth removes the rent and keeps only the congestion price.

Why not just…?

Why not just run the cooperative Lyapunov controller and reimburse devices' energy? Reimbursement requires each device to report its battery state and per-joule cost, and a device paid on its reported cost has every reason to overstate it. The rent reaches the same allocation without any report, because it contracts on age the platform observes. We will test this directly. Devices in the reimbursement scheme are allowed to inflate their reported cost by the profit-maximizing amount, and we measure the platform's extra spending and the age lost when it caps reimbursements. If truthful reporting were enforceable, this alternative would be equivalent, and we say so.

Why not just add an age term to the device utility in per-task Stackelberg pricing? A self-interested device has no reason to carry a term for the platform's freshness unless it is paid for it. Adding the term by fiat assumes the altruism the incentive problem exists to replace. The rent is precisely the payment that makes such a term rational, and its weight $b_i$ is chosen by the leader rather than assumed. The decrement-payment ablation shows that the obvious ways of "paying for age" do not create this term.

Why not just use the age-dependent posted price from the mean-field pricing work? This is a real threat. Under light load, with negligible queueing, the age at the moment of acting and the age at delivery nearly coincide, and the two mechanisms should tie. We predict they separate as edge load rises and as compute times become heavy or deterministic. In that regime a device acting on a high posted price offloads into a congested queue, and its update arrives stale. The experiments sweep load from 0.3 to 0.95 of edge capacity and compare exponential with SC2-measured service times. If the posted price stays within noise of the rent across the sweep, we will report that the simpler mechanism suffices.

Why not just learn the whole Stackelberg equilibrium with multi-agent reinforcement learning? Li et al. do this, and it can absorb arbitrary utilities. The evidence from He et al. cuts against it: plain deep deterministic policy gradients failed to converge within $10^6$ slots on a smaller centralized version of this problem, without even strategic leaders. We will report age against training slots for both approaches. If the learned equilibrium matches the rent's age at comparable sample cost, the remaining case for the rent is its equilibrium guarantee and two-scalar interpretability.

Decisive Checks

The first check is alignment. At $(b_i = w_i, q = q^\star)$, the decentralized market's time-average age and energy should lie within the Lyapunov $O(1/V)$ gap of the cooperative oracle at both 15 and 50 devices. A persistent gap would falsify the decomposition claim, for example one caused by coupling through the edge queue order that the price does not capture.

The second check is mechanism separation. Per-task pricing should show rising age with load, accompanied by growing head-of-line ages on devices. The rent should keep idle waiting profitable, visible as positive deliberate wait times consistent with Zhou et al..

The third check is the posted-price comparison across the load sweep described above, which decides whether receiver-side measurement matters.

The fourth check covers screening and gaming. We measure the age cost of the optimal contract menu under hidden types. We also test a timestamp-forging adversary that backdates generation times. This exposes the mechanism's main practical weakness: it is only as good as the platform's ability to verify when an update was created, for example through edge-side timestamps on raw data or signed sensor clocks.