How Do AI Agents Spend Your Money? Analyzing and Predicting Token Consumption in Agentic Coding Tasks

Longju Bai; Zhemin Huang; Xingyao Wang; Jiao Sun; Rada Mihalcea; Erik Brynjolfsson; Alex Pentland; Jiaxin Pei · pdf · 2026 source ↗ Reader 🖥️

Agent Cost Attribution Pre-Execution Cost Prediction (Agent Self-Prediction)AI Unit Economics Coding Agents Context Tax (Retry-Driven Cost Accumulation)Evals Token Efficiency

Because agentic coding tasks burn tokens overwhelmingly through accumulating, cache-read input context rather than output generation -- and because that spend is highly variable, only weakly tied to human-perceived difficulty or to accuracy, and only weakly predictable by the executing agent itself before the task runs -- transparent upfront pricing for AI coding agents is not currently achievable, so consumption-based billing (with, at best, coarse-grained self-predicted budget alerts) is the only viable near-term model.

theoretical · argumentative — An empirical study (eight frontier LLMs x 500 SWE-bench-Verified problems x four runs) establishing descriptive facts about where and how agentic coding tasks spend tokens, then testing a specific capability claim (can agents predict their own cost pre-execution). The propositions are almost all 'X is true of agent token consumption,' but the paper explicitly frames its motivation and conclusion around a practical design question -- how agent pricing should work -- so the theoretical findings are marshalled in service of a practical argument about pricing policy (consumption-based billing remains necessary).

Structure

Part	Role
Introduction (Sec 1): frames the problem as a transparency/completion-guarantee failure in current agent pricing, and states the three motivating questions (where do tokens go, which models are efficient, can agents predict their own cost).	context
Data and Method (Sec 2): OpenHands agent framework, SWE-bench-Verified, eight frontier models, four independent runs per problem, fine-grained token/action metrics parsed from completion logs.	methodology
Overall Consumption Patterns (Sec 3): agentic tasks vs. chat/reasoning cost comparison; variance across problems and runs; token cost vs. accuracy (inverse at the high end); human difficulty ratings vs. actual cost (Kendall tau_b = 0.32).	evidence
Model Token Efficiency (Sec 4): accuracy-cost trade-off across 8 models; token efficiency persists across shared success/failure subsets, so it's model-specific behavior, not task difficulty; fine-grained file-action analysis (repeated views/edits).	evidence
Token-Cost Dynamics Across Phases and Rounds (Sec 5): five-phase trajectory taxonomy (Setup/Explore/Fix/Validate/Closeout); cache-read tokens dominate volume and dollar cost in every phase; round-level case study (astropy-7336) showing cache-read as a steady baseline punctuated by discrete cost spikes from new-content actions.	evidence / mechanism
Predicting Token Consumption Before Execution (Sec 6): formalizes the self-prediction task; agents achieve weak-to-moderate correlation (up to 0.39) and systematically underestimate real cost, especially input tokens; prediction overhead is usually less than task cost but not monotonically tied to accuracy.	evidence
Discussion (Sec 7) and Conclusion (Sec 8): limitations (8 models, single harness/benchmark), argues for the pricing implications -- subscription models break under agentic variance, self-prediction can support coarse budget alerts but not exact pricing, consumption-based pricing stays the practical default.	conclusion / practical argument
Appendices A-D: output-token-mirrored analyses, explicit cost-calculation formulas (Claude-style explicit cache vs. GPT-5-style implicit cache), the full self-prediction system prompt and worked in-context example, and a no-example ablation showing underestimation persists (and worsens) without the demonstration.	supporting detail / robustness check

Key terms

Token consumption / token usage
Used interchangeably (explicit footnote) to mean both input and output tokens used by an LLM agent across an entire multi-round trajectory, not per-call.
Agentic coding task
A multi-round, tool-using, autonomous problem-solving process on a SWE-bench-style GitHub issue, carrying the full conversation history forward each round -- contrasted explicitly with 'code reasoning' (single-turn, no tools) and 'code chat' (multi-turn dialogue, no repository interaction).
Phase (Setup / Explore / Fix / Validate / Closeout)
A five-way functional segmentation the authors impose on every trajectory's rounds, used purely for aggregation and reporting, not something the agent itself declares.
Cache read / cache creation / non-cached input
The three sub-categories of input tokens under Anthropic-style explicit prompt caching: cache creation writes new context into the cache (priced at a chosen TTL, here the 5-minute rate); cache read retrieves previously-cached context at a steep discount; non-cached input is genuinely fresh, full-price prompt content.
Self-prediction
The specific experimental design where the same coding agent used to execute a task is repurposed, via a different system prompt, to estimate its own future token cost before executing -- as opposed to training or querying a separate, external cost-prediction model.
Prediction overhead
The ratio of the token/dollar cost spent producing a self-prediction to the actual cost of executing the task -- a cost-of-cost-estimation metric.

Propositions

explicitAgentic coding tasks consume roughly three orders of magnitude more tokens than single-turn code reasoning and multi-turn code chat tasks, and this gap is driven almost entirely by input-token growth rather than output tokens.conf: high
explicitToken usage on agentic coding tasks is highly variable and inherently stochastic: the abstract's headline figure is that repeated runs of the identical task and model can differ by up to 30x in total tokens, but the paper's own per-model average (Figure 2b: max/min cost ratio averaged across all 500 instances) is only about 2x -- so 30x is a heavy-tail extremum, not the typical run-to-run spread, and the most expensive problem costs on average ~7 million more tokens than the cheapest.conf: high
explicitcontestedHigher token spend does not translate into higher task accuracy -- accuracy peaks at intermediate cost quartiles and saturates or declines at the highest cost levels ('inverse test-time scaling').conf: high
contradictsAgentics / Tech Things: Tokenmaxxing is dead, long live tokenmaxxing · p5 — Tokenmaxxing's 'compounding correctness' regime-shift thesis claims more token spend generally yields better agentic-loop outcomes; this paper's own 500-task, 8-model SWE-bench study finds the opposite at the high end -- accuracy peaks at intermediate cost and saturates or declines with more spend -- directly supplying the general coding-task benchmark evidence that extract-tokenmaxxing#g1 says is missing.
supportsThe Economics of Agentic AI: Engineering for Imperfection · p3 — That essay argues theoretically that 'no amount of additional... inference-time compute can resolve a failure caused by a missing structural constraint'; this paper's empirical finding (more tokens do not raise accuracy, and high-cost runs show more redundant, unproductive exploration) is concrete benchmark evidence for the same underlying claim.
explicitThe most expensive runs show a sharply higher rate of repeated (redundant) file-view and file-modify actions on the same file, compared to cheaper runs on the same problem -- consistent with wasted, unproductive exploration rather than deeper reasoning.conf: high
supportsUber's Zero Growth Stack: Scaling Services, While Optimising Infrastructure and AI Cost · p8 — Uber's move away from aggregate cost/throughput tracking toward granular metrics like 'net code quality ratio' is motivated by suspicion that gross spend hides waste; this paper supplies a concrete mechanism (repeated, redundant file view/edit actions inflating cost on failed or expensive runs) that would specifically require Uber-style granular attribution to detect.
explicitModels differ substantially and consistently in token efficiency (Kimi-K2 and Claude Sonnet-4.5 consume, on average, over 1.5M more tokens than GPT-5 on the same tasks), and this ranking holds even on the subset of tasks every model solves and the subset every model fails -- so the difference is an inherent model trait, not a byproduct of task difficulty or of harder models attempting harder problems.conf: high
refinesThe Almedra Token-Efficiency Benchmark, Updated For GLM 5.2 · p5 — Almedra's benchmark (harness varied, model held fixed) concludes harness design is the dominant driver of efficiency differences. This paper (model varied, harness/OpenHands held fixed) finds model identity is an independent, robust driver of efficiency, stable across shared success/failure subsets. Together they show efficiency has (at least) two independent axes -- harness and model -- rather than either being the sole driver.
explicitHuman expert-rated task difficulty (time-to-resolve categories from SWE-bench-Verified) is only weakly associated with actual agent token cost (Kendall tau_b = 0.32); 6.7% of tasks rated '<15 minutes' cost more tokens than the average '>1 hour' task, and 11.1% of '>1 hour' tasks cost fewer tokens than the average '<15 minute' task.conf: high
explicitCache-read input tokens are the single largest category of both raw token volume and dollar cost in every phase of an agentic coding trajectory, even though output tokens are priced roughly 80x higher per token -- because the sheer accumulated volume of reused context outweighs the higher per-token price of generation.conf: high
extendsI benchmarked CC's caveman plugin against 'be brief'. The token math is wild. · p4 — Caveman's finding is scoped to output-token compression in a single-turn/chat-style setting ('output tokens are the mechanism for reasoning'). This paper shows that in long-horizon agentic coding specifically, the dominant cost driver is cache-read *input* accumulation, not output -- extending token-economics analysis to a task regime where the caveman finding's premise (output tokens are the main lever) does not hold.
explicitFrontier models can predict their own token cost before executing a task only with weak-to-moderate correlation with actual usage (up to 0.39, achieved by Claude Sonnet-4.5 on output tokens), and input-token prediction is harder than output-token prediction for most models -- with one named exception, Kimi K2, which attains its highest correlation (0.38) on input tokens rather than output.conf: high
explicitAll tested models systematically underestimate their own real token usage when self-predicting, with the bias most pronounced for input tokens as real values scale into the millions; this underestimation persists (and worsens) even when no in-context worked example is given, indicating the bias is not merely an artifact of the demonstration.conf: high
explicitThe cost of producing a self-prediction (prediction overhead) is usually well under the cost of executing the task itself, but overhead and prediction accuracy are not monotonically related -- some models (Sonnet 3.7, Sonnet 4) spend over 2x the task's eventual cost on prediction without achieving the best correlations, while Sonnet 4.5 achieves its best correlation at only 0.32x task cost.conf: high
explicitdevelopedBecause token usage is highly variable and hard to predict, and self-prediction only yields coarse-grained rather than instance-precise estimates, purely upfront/fixed pricing for agentic products is not currently viable, and consumption-based (usage-metered) pricing will remain the practically necessary model until pre-execution estimation improves.conf: medium
extends ←How to Respond to the Coming AI Cost Shock · p4 — Draws the practical, executive-facing conclusion (abstract AI budgeting doesn't work) from the same underlying fact the research piece establishes empirically: token usage is highly variable and poorly self-predictable, undermining fixed/upfront pricing.
implicitAn agent's capacity to reason about and estimate its own resource consumption is one measurable instance of a broader, more valuable capacity for behavioral self-modeling -- the same capacity that would let an agent decide whether a task is worth attempting or recognize when to stop.conf: medium
implicitHuman perceptions of task difficulty and an LLM agent's actual computational effort are different constructs measuring different things, not two imperfect measurements of one shared underlying 'difficulty' -- so improving human time-estimates would not by itself improve token-cost prediction.conf: medium

Arguments

Purely upfront, fixed-price billing for agentic coding products is not currently achievable, so consumption-based (usage-metered) pricing must remain the practical default. strength: medium

Explicit premises:

Token usage varies enormously across problems and across repeated runs of the same problem (up to 30x).
Frontier models can self-predict their own cost only with weak-to-moderate correlation and systematically underestimate real usage.

Implicit premises:

A viable pricing scheme must be either accurate-and-upfront or transparently usage-based -- there is no third option that is simultaneously fixed-price and reliably profitable/acceptable to users at this level of variance.
The executing agent's self-prediction, with its privileged access to the repository and its own planned tool calls, represents close to the best-case predictor available; if it cannot beat weak-to-moderate correlation, no cheaper external predictor is likely to do much better.
Providers and users would not accept a fixed price calibrated to a systematically-biased-low estimate (the underestimation problem), which is itself an argument against using current self-prediction directly as a pricing input.

Inferences:

If self-prediction is used operationally for 'budget alerts' as the paper suggests, and the bias is systematically toward underestimation, then alerts built on raw self-predicted numbers will themselves warn too late or too low unless a calibrated safety margin is added -- a practical risk the paper does not spell out even though its own data (Fig. 11) directly implies it.

Excess token spend on expensive-but-failed runs reflects redundant, unproductive agent exploration rather than genuinely deeper or more careful reasoning. strength: medium