The anatomy of an agent dollar

Abstract

A model is priced per token. An agent's cost accrues per trajectory, and the two are diverging fast enough to matter. A conventional model request takes an input and returns an output. An agent may read files, query databases, search the web, pick tools, plan, call another model, change its plan, reread earlier state, retry failed actions, check its own answer, and recover from errors before it produces what the user asked for.

The empirical record on this is recent but consistent. Agentic coding tasks can consume about 1,000 times the tokens of code reasoning or chat, runs of the same agent on the same task can differ 30x in consumption, more tokens don't reliably mean better results, and the models are bad at predicting their own costs, with correlations between predicted and realized spend topping out near 0.39 [1]. On SWE-Bench Verified, reads took 76.1% of tokens against 12.1% for execution and 11.8% for editing [3]. In a ChatDev experiment on 30 tasks, initial coding was 8.6% of tokens and review was 59.4%, with inputs at 53.9% of the total [4]. Across more than 100 trillion tokens on OpenRouter, average prompt length went from about 1,500 to over 6,000, and reasoning models went from near zero to more than half of volume [2].

What this adds up to is that producing the answer is often the cheap part. The expensive part is holding enough state, context, and confidence to get there.

This paper proposes an accounting framework for that cost. We call the unit an agent dollar: one dollar of marginal spend needed to move a task from accepted intent to verified completion. The goal isn't to shrink the dollar for its own sake. It's to find out how much verified work the dollar buys. The Intelligence Exchange [15] reported an 87% reduction ($47.00 per day to $6.10) against a signed, workload-constant counterfactual. This paper describes how to instrument the inside of those two curves and see where every dollar went.

Keywords: agent economics; trajectory cost; context amplification; inference governance; cost per verified outcome; agentic AI.

1 The token is becoming the wrong unit

A token is a fine billing unit. It measures what went into a model and what came out. It's a bad unit for describing autonomous work, and the gap between the two is where the money hides.

1.1 One task, many economic events

Ask a model to review a function and you get one prompt and one answer. Ask an agent to fix a production defect and the story gets longer. It has to understand the request, find the repository, read its structure, search for the relevant code, open several files, form a theory about the bug, look at the tests, write a patch, run the tests, read the results, discover its first theory was wrong, check another dependency, revise the patch, rerun the tests, confirm the fix, summarize the change, and hand back proof that it's done.

The user saw one task. The inference system ran a graph of paid events.

OpenAI described this from inside its own Codex harness: a single task can involve a series of model requests and tool calls, and a task with 30 requests pays any per-request overhead 30 times [5]. They name context growth, tool loading, repeated history, and repeated computation as system-level problems, distinct from model quality.

1.2 The cost equation

For a one-shot call:

C = T_input × P_input + T_output × P_output

For an autonomous task, something closer to:

C_task = Σ_{i=1}^{N} (T_{i,useful} × P_{i,useful} + T_{i,context} × P_{i,context} + T_{i,output} × P_{i,output} + C_{i,tools} + C_{i,compute}) + C_verification + C_recovery

where N isn't known before execution.

Token price is one input to this. The bigger inputs are the shape of the trajectory: how many calls, how large the context got, how much was repeated, what was cached, which model served each step, how many branches failed, how much got replayed, and how much verification happened before a bad result propagated. Two systems on the same model can land at very different costs. So can two runs of the same system on the same task [1, 3, 4, 6, 7].

Interpretation. Agent cost is path dependent. A budget built on expected cost alone will be wrong in the tails, and the tails are where enterprises get surprised.

2 The context snowball

The first economic difference between chat and agents is accumulation.

2.1 How it happens

A stateless question might carry 2,000 tokens in and 500 out. An agent doesn't start from zero after each action. The next decision may need the original instructions, tool definitions, everything accumulated so far, whatever was retrieved, prior outputs, tool results, error messages, and the latest observation. Then another step happens, and the pile grows.

Say an agent starts with 5,000 tokens of instructions and state and adds 2,000 tokens of history per step. If the whole accumulated history gets resent for 20 calls, the input total comes to about 480,000 tokens, before any output. The task may have introduced only tens of thousands of tokens of new information. The system processed hundreds of thousands because old information kept riding along.

Stanford's Digital Economy Lab calls this a snowball. The agent reads the task, generates an action, then reprocesses the task and its own response alongside the next observation. They find input tokens driving the high consumption in agentic coding [1]. OpenAI's harness works the same way, resending instructions, history, tool definitions, and earlier results within one user turn. Their current design keeps exact prefixes stable to maximize cache reuse and limits tool exposure to slow the growth [5].

2.2 What the market data shows

This isn't confined to lab benchmarks. OpenRouter's analysis of agentic volume found 86% of tokens were cached prompt [2]. Not completion, not reasoning, not new input. Context the agent carries forward because it's cheaper to cache it than to figure out what it still needs. The same dataset shows average prompts quadrupling past 6,000 tokens, with programming workloads the heaviest [2].

2.3 Context amplification factor

Since cost compounds with path length, ordinary token counts miss what's going on. We define the context amplification factor (CAF) as:

CAF = total input tokens processed during a task / unique information tokens introduced during that task

A CAF of 1 means every piece of information was processed once. A CAF of 8 means each unique token of useful information was, on average, run through the model eight times over the life of the task. Caching lowers the price of some of those passes. Compression lowers the count. Retrieval changes what enters at all. The amplification itself is a property of the architecture and worth measuring on its own. Analyst-grade derived metric.

Interpretation. Market data (86% cached context) and benchmark data (76.1% reads) point the same way. Agent spend is dominated by carrying state, not producing output.

3 Three inversions

The record so far overturns three assumptions most people carry about where agent money goes.

3.1 Agents read more than they write

The popular model of generative AI is about output. The model writes the email, the code, the report. Agent economics run the other way.

SWE-Pruner analyzed Mini-SWE-Agent trajectories on SWE-Bench Verified with Claude Sonnet 4.5, sorting operations into reading, executing, and editing [3].

The edit is the thing the user paid for. The agent spent three quarters of its budget deciding what to edit.

This turned out to be fixable. SWE-Pruner put task-aware filtering between file retrieval and the agent. Token consumption dropped 23% to 38% depending on the model, and success rates went slightly up, not down [3]. Removing information didn't make the system less capable. In some settings it made it slightly more capable, which suggests context has a negative marginal value past some point: it costs money and adds noise that sends the agent exploring. The relevant question stops being how large a context window the model accepts and becomes how small a state is sufficient for the next correct action.

3.2 The first draft is often cheap

A different experiment gets to the same place from the other direction. Researchers instrumented ChatDev on 30 software tasks with a GPT-5 reasoning model and split tokens across design, coding, completion, review, testing, and documentation [4].

Generation was the small number. Refinement was the big one. A capable model can produce a plausible candidate quickly, but production work doesn't end when something plausible exists. The system still has to find out whether it's right, which means inspecting the output, comparing it against requirements, running tests, resolving contradictions, repairing failures, or getting a second opinion before letting the result propagate.

We call this the verification tail. It isn't waste. When the alternative is shipping a wrong action into production, verification may be the best money in the whole trajectory. But it should be visible on the bill.

3.3 More tokens don't buy more intelligence

If consumption tracked difficulty, budgeting would be tractable. Hard problem, more tokens. The data doesn't cooperate.

The Stanford study ran eight frontier models on SWE-bench Verified [1]. Consumption on the same task varied up to 30x. Higher consumption didn't mean better accuracy; performance often peaked at intermediate spend and then flattened. Human ratings of task difficulty only weakly predicted what the agent actually spent. And the models were poor at forecasting their own consumption, with predicted-to-realized correlations no better than 0.39 and a consistent bias toward underestimating.

So agent spend carries what we'd call trajectory risk. The budget is set partly after execution begins. An action changes the environment, the observation changes the next decision, a failed branch adds context, that context shifts the model's behavior, and a retry changes the path again. Cost is endogenous to execution. The same task won't produce the same trajectory even when nothing about the system appears to have changed.

For an enterprise, this means expected cost isn't enough. A workload that averages $1 per success but occasionally costs $40 behaves very differently from one that reliably costs $1.10, even if the means are close. A useful cost report needs the median, the distribution, the tail, and the probability of breaching a budget. Research on web agents makes the same point: under fixed token budgets, variance changes the conclusions, so one-shot leaderboards mislead [10].

Interpretation. In all three inversions, the visible output (the edit, the draft, the answer) is a minority of the spend. The majority is the work of making the output trustworthy. That's why "AI writes the thing" is the wrong mental model for agent cost.

4 Three ledgers

A pie chart of input versus output doesn't explain agent economics. Neither does splitting a task into planning and execution. The same token can be classified on several independent axes, so we propose three ledgers kept simultaneously.

The functional ledger asks why the spend occurred: orientation, planning, action, verification, repair, or final delivery.

The context ledger asks what information was paid for: instructions, tool definitions, task state, retrieved evidence, environment observations, prior trajectory, or generated reasoning.

The outcome ledger asks what happened to the work: accepted path, necessary control, failed branch, duplicated work, replayed work, or abandoned work.

A file-read token might be necessary orientation on the functional ledger, repeated history on the context ledger, and part of an abandoned branch on the outcome ledger. None of those labels contradicts the others. Together they explain the dollar.

Keeping three ledgers also prevents a common mistake, which is labeling everything except final generation as waste. Reading is often necessary. Verification is often necessary. Security controls are often necessary. Retries can be rational under uncertainty. The point is to find out what the system needed to spend to produce a verified result, what it could have skipped, and whether a different architecture would have gotten there for less.

5 Seven destinations

On the three-ledger framework, an autonomous workload decomposes into seven economically distinct activities. The Intelligence Exchange introduced these in Section 3.5 [15]; here each gets its external evidence.

Orientation is the cost of understanding the environment: retrieving documents, inspecting repositories, querying databases, discovering tools, and reading state. Production builders report input-to-output ratios near 100:1 [11], and instrumented coding agents spend 76.1% of tokens on reads [3]. It's the largest destination by volume and the most responsive to compression, caching, and deterministic bypass.

Coordination is the cost of deciding what happens next: planning, delegation, model selection, summarization, state management, tool choice, and inter-agent communication. In the tiers reference workload, coordination is 60% to 70% of loop tokens and routes to cells priced about 35x below frontier without measurable quality loss [15]. Representative production composition.

Production is what people think they're buying: the analysis, code, decision, document, or action. In the ChatDev experiment it was 8.6% of tokens [4]. Frontier capability is most often needed here, and here is a minority of the volume.

Verification is the cost of finding out whether an output satisfies the task: evaluation, tests, consistency checks, independent review, policy checks, validation against intent. In ChatDev, review took 59.4% [4]. Ungoverned workflows either consume the output unchecked or lean on manual review. Governed workflows verify at the call and produce the labels that routing, audit, and underwriting need.

Repair is the cost of something having gone wrong: retries, rerouting, backtracking, re-execution, local recovery. TheAgentCompany ran 175 workplace tasks against a simulated firm's tools; the best frontier model completed 24% fully [12]. At that rate there are roughly three failed attempts per success, and each failed attempt already paid for orientation, coordination, and production tokens that produced nothing verified.

Carriage is the cost of moving information through the trajectory: repeated prompts, prior messages, persistent state, schemas, tool definitions, retrieved evidence. OpenRouter's 86% cached-context figure [2] is mostly carriage. It compounds with context length and is the main target of compression and prefix-aware caching.

Settlement is the cost of proving what happened: logging, security inspection, provenance, policy disposition, audit evidence, and the final record. This one has a public price tag. On August 18, 2026, OpenAI disclosed that its internal monitoring system consumes roughly 20% of inference compute, varies a lot across workloads, and is applied inconsistently [13]. That's what settlement costs when it's bolted on by the provider. In the tiers production system, the audit record is a byproduct of the governance path, so settlement is closer to operating exhaust than a separate line item [15].

The list separates making the answer from making the answer trustworthy, and that separation is the economic difference between generation and governed execution.

Interpretation. Orientation, coordination, and carriage dominate the dollar and are all compressible, cacheable, bypassable, or routable to cheaper models. Production needs quality-constrained routing. Repair is governed by verification. These destinations are the mechanism under the 87% result in The Intelligence Exchange [15].

6 The harness matters about as much as the model

Model comparisons usually hold the interaction architecture fixed and implicit. That's fine for chat. For agents it hides most of the variance.

6.1 What the harness decides

A model doesn't decide in a vacuum. It gets whatever state the harness builds for it. The harness decides which tools are exposed, how much tool output enters the prompt, whether history is replayed, when context is compressed, whether results are cached, when to retry, when to escalate to a bigger model, and whether a failure gets repaired locally or restarts the whole task. OpenAI's recent efficiency work is explicit that its gains came from harness changes (deferred tool discovery, tool-output limits, prompt-prefix stability, reuse of repeated context), not from the model, and that repeated per-request costs compound across a multi-request task [5].

6.2 Four independent results

SWE-Pruner changed context handling and nothing else. Tokens fell 23% to 38% on SWE-Bench Verified and solve rates ticked up [3]. Verified.

Composio, in July 2026, ran Kimi K3 through six agent harnesses on 26 identical coding tasks. The cost spread was 3.8x, success rates ran from 65% to 81%, and per-task consumption ranged from 61,000 to 340,000 tokens [7]. The harness was the only variable. Their stated conclusion was to test the harness before switching models. Verified.

Meta-Harness, from Lee et al. at Stanford and MIT (arXiv:2603.28052), is the strongest result I've seen on this [6]. An automated system evolved only the code for context management, memory, and retrieval. Weights were frozen. It produced a 6x performance gap on production coding benchmarks, 4x token compression with accuracy 7.7 points higher than state-of-the-art agentic memory systems, and converged 10x faster than conventional optimizers. The discovered harnesses transferred zero-shot to five held-out frontier models. Verified.

LLMLingua reported up to 20x prompt compression at about 1.5 performance points in benchmark settings [14], with the caveat from later work that compression has an operating envelope: preprocessing can cost more than it saves when prompt length, ratio, and hardware don't line up. Verified with scope qualifier.

Caching layers on top of all of this. Anthropic discounts cache reads up to 90%, OpenAI discounts cached input 50% [15], and OpenAI's harness is designed around keeping prefixes reusable [5].

6.3 A systems property

The model determines what cognition is available. The harness determines how often you have to buy it. Agent efficiency is a property of the whole system, and a benchmark that compares Model A to Model B with the harness held implicit is measuring less than half of it.

Interpretation. The harness is an independent optimization surface with returns on the same order as improving the model [6]. The 87% production result in The Intelligence Exchange [15] reflects routing, context, verification, and settlement acting together, which is why no single-mechanism vendor reproduces it.

7 The cheapest token isn't the cheapest task

The routing literature already established that different models supply different capability at different prices. FrugalGPT matched the best single model with up to 98% cost reduction using cascades under benchmark conditions [16]. RouteLLM showed more than 2x reductions in some evaluations without losing measured quality [17]. Agents make the math harder, and two production platforms have now published data showing how.

7.1 Production evidence

Devin's Fusion architecture findings [8] have the clearest example. Fable 5, which costs more per token than Opus 4.8, came out cheaper per run. It delegated more effectively to a cheaper sidekick model, finished in 11.5 turns instead of 26.5, and in 81% of runs made no code edits itself. The cheaper model per token was the more expensive model per task. Reported production disclosure.

Factory published that gateway-only routing, without harness governance, costs 2.12 to 2.37x more than governed execution on long sessions [9]. The overhead is exactly what this paper describes: context accumulation, repeated state, and unmanaged trajectory growth. Reported production disclosure.

7.2 The general shape

Take two models. Model A costs a quarter as much per token but needs 30 calls. Model B costs four times more per token but finishes in five. Model A's extra calls each resend the accumulated state. A mistake on call six forces a rerun of calls three through five. Model B clears verification the first time and Model A needs two repair cycles. By the end, dollars per million tokens has stopped being the relevant price. Dollars per verified completed task is. Illustrative.

7.3 Routing inside the agent

Routing research has historically asked which model should answer a query. Inside an agent, the question is which model should perform each step. Planning may not need the model that does the substantive analysis. State summarization may not need the model that makes a hard coding decision. Tool selection may not need the model that verifies the output. Basic math may not need a model at all.

The Intelligence Exchange lays out the multiplicative version of this [15, Section 8.6]: deterministic bypass removes calls, overhead routing reprices coordination tokens, model routing reprices substantive calls, compression shrinks what's transmitted, caching lowers the price of repeated context, downtiering shifts assignments as evidence accumulates, and verification lets all of that run more aggressively. The open question this study should answer is how much frontier intelligence an average trajectory actually needs.

Interpretation. Per-token price is the wrong unit for agent procurement. The winning configuration completes the required work at the lowest cost per verified task within the enterprise's quality, security, latency, and reliability constraints. That's a clearing price, and it's what CPII in The Intelligence Exchange [15, Section 7.3.1] is designed to publish.

8 From token efficiency to work efficiency

The inversions and the seven destinations suggest metrics that should sit next to model price. These formalize the definitions in The Intelligence Exchange, Section 3.5 [15].

Cost per verified outcome (CVO):

CVO = total cost of all attempts / number of verified successful outcomes

Failures stay in the numerator on purpose. A system that attempts 100 tasks for $100 and completes 50 has demonstrated $2 per verified completion, not $1.

Context amplification factor (CAF):

CAF = processed input tokens / unique information introduced

Repair tax (RT):

RT = cost incurred after detectable divergence / total mission cost

Verified work yield (VWY):

VWY = verified work units completed / dollars spent

Frontier premium (FP):

FP = observed mission cost / minimum observed cost meeting the same quality threshold

All five are analyst-grade derived metrics.

They measure different things, which is the point. A model can have low amplification and poor success. A system can carry a high repair tax and still propagate far fewer failures. A frontier model can be expensive per token and carry a small frontier premium on tasks where nothing else clears the bar. The accounting should show those differences instead of collapsing them into one savings number.

Bret Taylor, Chairman of OpenAI, put the buyer-side version of this on CNBC on July 20, 2026: the end state is "paying for outcomes, not managing token consumption" [18]. That's CVO. Price discovery only means something when it's attached to a verified result. Reported executive statement.

9 What's already been measured

The Intelligence Exchange [15] ran a signed, workload-constant shadow counterfactual. The governed workload and its enterprise-default alternative were recorded in parallel for 14 days, with both streams cryptographically signed. On the reference workload, the endpoints were $47.00 per day ungoverned and $6.10 governed, an 87% reduction at maintained task quality. The cohort average is 83.08% and optimized cohorts reach 87.9%.

That paper is careful to separate the verified result from its explanation. The per-mechanism allocation is labeled representative, not independently signed, and the result comes from one platform and one workload mix. The prior experiment answers what happened to total cost under governance. This study is designed to answer where each dollar went and which intervention moved which component. Those need different instruments.

10 The experiment

The strongest form of this work is a controlled, repeatable benchmark, not a literature review. It uses the same principle as the signed counterfactual: hold the work constant, vary the architecture.

10.1 Four workload families

Software engineering, because that's where the external literature is deepest and gives independent benchmarks to compare against. Research and synthesis, with large document sets, search, retrieval, and evidence-backed output, where reading dominates and source quality matters more than code execution. Enterprise operations, where agents hit structured systems, make tool calls, transform data, run workflows, and satisfy explicit policy. And analytical work mixing extraction, math, reasoning, and deterministic computation, where not every step should touch a language model.

Every mission starts from the same state snapshot. Every tool returns the same output under controlled conditions. Every agent gets the same requirements. Live dependencies are replayed from snapshots where possible. A task succeeds only if an independent verifier says the requested result was delivered. And because identical runs vary so much [1], every cell runs many times.

10.2 Five execution arms

Because each mission is paired across arms, the study can show how the anatomy of the dollar changed from one arm to the next, and not only what happened to the total.

10.3 Instrumentation

Every model request gets a unique event ID and a parent ID linking it into the execution graph. Before a request goes out, the runtime records the provenance of its input tokens: system instructions separate from tool definitions, tool definitions separate from task instructions, original task data separate from retrieved evidence, new observations separate from ones carried forward, and previously processed content separate from new context. Cached and uncached tokens are split using provider accounting. Outputs are tagged as final deliverables, exposed reasoning, tool arguments, plans, summaries, or verification results. The runtime also logs model, provider, snapshot, routing policy, cache state, timestamps, latency, tool calls, tool-output length, branch IDs, verification result, repair events, security disposition, acceptance state, and billed cost.

The target is a reconstruction property. Starting from the final signed record, an outside analyst should be able to account for essentially all the marginal cost of the task. That's the agent equivalent of reconciling a transaction.

11 Three figures

The hero figure is a Sankey. One dollar enters on the left and splits by function (orientation, coordination, production, verification, repair, carriage, settlement), then by where it ran (frontier model, commodity model, small model, local deterministic execution, tools, verification), then by what happened to it (verified accepted work, necessary control, repeated work, failed work, abandoned work). It's drawn twice, ungoverned and governed. The point isn't that the second bar is shorter but where the flows moved. Planned; requires experimental data.

The second figure is the snowball. Execution step on the x-axis, cumulative cost on the y-axis, context length annotated above each step: 5K, 8K, 13K, 20K, 31K, 44K. A naive trajectory should visibly fan out, showing that the seventeenth call carries the economic residue of the previous sixteen. Overlays for cache-aware execution, compressed state, and bounded repair after an induced failure put context growth, repeated computation, and failure amplification on one chart. Planned.

The third is the scatter. One task, run twenty or fifty times under identical configuration, cost on x and verified quality on y. If the Stanford result generalizes [1], it's a cloud, not a line: the expensive runs aren't reliably the good ones. Repeated across models, a higher-priced model could sit in the low-cost region by taking shorter paths while a cheaper one sits in the high-cost region because it explores more and repairs more. That's the task-level cost distribution of intelligence, and no price table shows it. Planned.

12 A hypothesis we're trying to break

The study starts from this:

For mature autonomous workloads, most marginal cost is not the minimum cognition needed to complete the task. It's the information acquisition, repeated context, coordination, verification, and recovery wrapped around that cognition.

There are several ways the data could prove that wrong. Frontier reasoning might dominate cost because output tokens stay expensive. Better models might shorten trajectories enough that amplification becomes a footnote. Verification might cost more than it saves. Task-aware routing might introduce errors that trigger expensive repair. Context pruning might cut tokens but degrade quality enough that the savings vanish per verified outcome. Deterministic bypass might only apply to a sliver of the work that matters. Short enterprise tasks might carry so little overhead that governance is net additive.

Any of those would be a useful result. The job of a research program isn't to make the data confirm the product. It's to find the architecture that survives the data.

Going in, the literature gives us four priors. Input will matter more than buyers expect; that shows up independently in Stanford [1], ChatDev [4], SWE-Pruner [3], OpenRouter [2], and OpenAI's own engineering [5]. Trajectory variance will be economically material [1], so budgets need to govern tails. The execution system will matter independently of model capability, given pruning alone changed both cost and success [3] and harness evolution alone produced 6x [6]. And the mechanisms will interact rather than add: compression changes cache shape, routing changes trajectory length, verification changes retry count, deterministic execution removes calls, and each one changes the opportunity left for the next [15, Section 8.6]. That last one matters most. The agent dollar behaves like a system, not a stack of discounts.

13 Statistical treatment

Agent cost distributions won't be well behaved, so a mean alone will hide the tails. The paper reports median, mean, standard deviation, interquartile range, and p90, p95, p99 where sample sizes allow. Comparisons are paired at the task level because task composition is the main confounder:

ΔC_j = C_{j,governed} - C_{j,baseline}

for identical task j. Bootstrap confidence intervals characterize the distribution of paired differences without assuming normality. For multivariate analysis, a mixed-effects model can include model, harness, task category, complexity grade, and architecture with task identity as a repeated factor.

Cost is also reported conditional on success. A configuration that's 50% cheaper and fails twice as often isn't cheaper. Cost per verified successful outcome stays the headline metric, with raw success rate published next to it. And run-to-run variance is a first-class result, not an error bar in an appendix [10].

14 What changes

14.1 For FinOps

Cloud FinOps asks where the compute spend went. Agent FinOps has to ask what the spend accomplished. Two million dollars of model invoices tells a CFO almost nothing about whether the company got two million dollars of useful inference.

There are at least four reasons spending might rise: more useful work is being automated, agents are getting more capable and tackling longer tasks, context and retry overhead are out of control, or the system is sending everything to the same expensive model because it has no idea what each task needs. All four produce the same invoice. They call for different responses, and the invoice can't tell them apart. The cost record needs to connect spend to task, quality bar, model assignment, execution path, verified result, and business outcome.

Two companies have already hit this. Canva slowed the biggest launch in its 13-year history, cut its growth forecast from 30% to 20%, and spent months plus a $320 million acquisition rebuilding around task-level routing. The result, per its August 2026 shareholder update, was a 90% cut in cost per AI task, with image generation 30x cheaper and video 17x cheaper than frontier alternatives [19]. Uber exhausted its full 2026 AI budget by April and imposed a $1,500 monthly per-employee cap on agentic coding tools, at a point where 99% of its engineers were on AI tools and more than 70% of pull requests came from agents [20, 21]. Both solved it. Both solutions were reactive, expensive, and specific to one company. Reported disclosures.

14.2 For engineering

The instinct is to ask which model is best. That's still a real question. But before changing the model, look at the trajectory. How much of the context is new? How much was already processed? Which tools are exposed but never called? How much tool output lands in the prompt? How many requests happen before the first useful action? How often does the agent reread the same evidence? Where do branches die? What does repair cost? How often does one failure force a full replay? How much verification happens after the answer instead of before a bad result spreads? How many calls actually need a frontier model?

Those questions sit one level above the model, and on current evidence that level has at least as much economic headroom as the model price [6, 7].

14.3 For procurement

Procurement starts from a price sheet: input price, output price, cached price, context window, rate limits, benchmarks. Those describe the commodity. They don't price the work. For each workload, the questions that matter are the probability of completion, the median cost, the p95, the number of requests, the context processed, the human intervention left over, the cost of failure, how fast another provider could take over, and what independent evidence proves the result.

A provider with the cheapest tokens can lose. So can the one with the smartest model. The winning configuration completes the required work at the lowest price inside the buyer's quality, security, latency, and reliability constraints. That's a clearing price.

The market is starting to price this. Stripe's acquisition of OpenRouter for more than $7 billion [22] treated routing infrastructure as a standalone asset class. But routing answers half the procurement question. It says which model got the call. It doesn't say what the call accomplished, whether anyone verified it, what the task cost, or whether the same result was available for less. Governance infrastructure above routing is where those get answered.

15 From a dollar of tokens to a dollar of intelligence

The Intelligence Exchange argued that falling inference prices won't shrink AI budgets, because cheaper cognition makes more workloads economical and consumption expands [15, Section 3.2]. It framed governance around how much intelligence a fixed budget can buy, not how much it can save. This paper gives that a unit.

Taylor's line, "paying for outcomes, not managing token consumption" [18], is the transition we're trying to make measurable. Give an enterprise $10 million for autonomous work. The question isn't how many tokens that buys. It's how many verified tasks it completes, and how much more work becomes affordable if the same $10 million produces twice as many verified outcomes.

Tokens go in, completed work comes out, and the governance between them decides how many of the first it takes to produce one of the second.

16 Conclusion

The model API made intelligence metered. Agents made it path dependent.

The public evidence already shows the shift. Agentic tasks consume orders of magnitude more tokens than direct interaction [1]. Context dominates consumption [2, 3, 4]. Reading dwarfs editing [3], review dwarfs first drafts [4], identical tasks take wildly different paths [1], more spending doesn't reliably buy more success [1], and the code around the model moves outcomes about as much as the model does [6, 7].

A model bill is becoming what a cloud bill was before FinOps existed: accurate as an invoice, useless as an explanation. An enterprise needs to know what fraction of the dollar found information, what fraction reasoned, what fraction acted, what fraction proved the action worked, what fraction fixed a failure, what fraction hauled old state forward, and what fraction went into a branch nobody used. Then, how much verified work the dollar bought.

The token says how much inference was consumed. The agent dollar says what it accomplished. That's the unit we think matters.

References

1. Stanford Digital Economy Lab. "The economics of AI agents." SWE-bench Verified multi-model agent cost analysis. 2026. [1,000x token consumption; 30x run variance; 0.39 cost-prediction correlation.]
2. OpenRouter (Peter Walker). "State of AI inference." Analysis of 100+ trillion tokens. 2026. [86% cached context in agentic volume; prompt length quadrupled; reasoning models above half of tokens.]
3. SWE-Pruner. "Task-aware context filtering for coding agents." SWE-Bench Verified, Claude Sonnet 4.5. 2026. [76.1% read tokens; 23 to 38% reduction from filtering.]
4. ChatDev GPT-5 study. Multi-agent software engineering token allocation across 30 tasks. 2026. [8.6% initial coding; 59.4% review; 53.9% input.]
5. OpenAI. Codex agent harness efficiency documentation. 2026. [Context growth, tool loading, repeated history as system-level problems; prefix stability for cache reuse.]
6. Lee et al. "Meta-Harness: automated harness optimization for LLM agents." Stanford / MIT, arXiv:2603.28052. 2026. [6x performance gap from harness alone; 4x compression; +7.7 points; zero-shot transfer to 5 held-out models.]
7. Composio. Agent harness benchmark, 26 coding tasks, six harnesses, Kimi K3 held constant. July 2026. [3.8x cost spread; 65 to 81% success; 61K to 340K tokens per task.]
8. Devin / Cognition. "Fusion architecture" production analysis. 2026. [Fable 5 cheaper per run than Opus 4.8; 11.5 vs 26.5 turns; zero code edits in 81% of runs.]
9. Factory. Production analysis of gateway-only routing economics. 2026. [2.12 to 2.37x overhead on long sessions.]
10. Web agent variance research under fixed token budgets. 2026.
11. Production builder reports of input-to-output ratios near 100:1. Cited in The Intelligence Exchange [15], Section 3.5.
12. TheAgentCompany. 175 workplace tasks; best frontier model completes 24% fully, 34.4% with partial credit. 2026.
13. OpenAI (Szymon Sidor, Jakub Pachocki). "Pacing model development to align with cyber capabilities." August 18, 2026. [Monitoring costs about 20% of inference compute; varies across workloads; applied inconsistently.]
14. LLMLingua. Prompt compression research. [Up to 20x compression at about 1.5 performance points.]
15. tiers. "The Intelligence Exchange: an empirical case for AI inference governance." tiers.dev/intelligence-exchange. August 12, 2026. [87% reduction; signed 14-day counterfactual; 100+ sources; seven destinations; CPII, CVO, repair tax, VWY.]
16. Chen et al. "FrugalGPT: how to use large language models while reducing cost and improving performance." 2023. [Up to 98% cost reduction via cascades.]
17. Ong et al. "RouteLLM: learning to route LLMs with preference data." 2024. [More than 2x cost reduction at maintained quality.]
18. Bret Taylor, Chairman of OpenAI. CNBC interview, July 20, 2026. ["Paying for outcomes, not managing token consumption."]
19. Canva (Melanie Perkins). Shareholder update reported by The Australian, August 4, 2026. [90% reduction in cost per AI task; image 30x cheaper; video 17x cheaper; growth forecast cut from 30% to 20%.]
20. Praveen Neppalli Naga, CTO of Uber. The Information, April 2026. [Full-year AI budget exhausted by April.]
21. Praveen Neppalli Naga, CTO of Uber. X post, July 2026. [99% of engineers on AI tools; 70%+ of PRs from agents; 2,500+ agent skills; $1,500/month cap.]
22. Stripe acquisition of OpenRouter. Axios, August 17, 2026. [More than $7 billion; prior round $113M Series B at $1.3B.]