Token budgets: what AI in software development really costs

Three numbers from one table show the problem well. According to the Ramp AI Index, in the week to October 23, 2026, the blended price of 1M OpenAI and Anthropic tokens for business customers fell 26.8% against the same week a month earlier, to $0.56. Over the same period token volume rose 37.1% and spend 8.9%.

These three numbers do not multiply out: the price drop and the volume growth alone would give about +0.4%. The sample is customers of Ramp's token-tracking product, and the company itself says it does not represent all of its customers' AI spend; both the model mix and the sample composition affect the total. But the direction is clear: a cheap token does not make the bill smaller.

The annual picture is the same. Menlo Ventures reports that in 2026 companies on average planned to raise AI spend 1.9-fold over 2025 but actually spent 4.7 times more. At the median the gap is more modest — 2.2 times against a planned 1.8, an overrun of about 22% for the median company (our calculation). The average shot up because of a small group of heavy spenders. The authors' explanation is agents: spend grows with the work, not with headcount.

In telemetry from more than 500 companies, DX found that the median price of 1M tokens stayed between $0.58 and $0.78 all year, while total spend grew 106–342% a quarter. The growth comes from volume. Epoch AI estimates that reaching a fixed quality level gets about 47% cheaper every quarter, but companies do not buy a fixed level: according to Menlo, frontier models' share of spend rose from 35 to 63% over the year.

Token demand barely depends on price. According to OpenRouter and a16z, a 10% price cut yields only 0.5–0.7% more usage; volume grows from new use cases, above all agentic ones. The vendor sees it differently. In its amended prospectus, Anthropic says price cuts reduced revenue growth from the second to the third quarter of 2026 by about $600 million out of $5,401 million, and argues that a lower price per task leads to more usage.

Prices can rise, too. From December 1, 2026, Gemini 4 Carbon and Argon double in price: the introductory $2 / $10 per 1M input and output tokens becomes $4 / $20. And Anthropic's price list says the new tokenizer in Claude 4.7 and later produces about 30% more tokens for the same text: the token price is unchanged, but the bill for the same work goes up.

A manager needs the price of work done, so the useful unit of a budget is the task. Ultimately we will have to count the cost per accepted task — we return to it in the section on the accepted change. Let us start with something simpler: the price of a single agent attempt.

The same token price yields very different task prices. In the Artificial Analysis index, Claude Opus 5.5 costs $0.98 per task at low reasoning effort and $10.04 at maximum. Sonnet 5.5, at an unchanged token price, costs about 50% more per task than Sonnet 5 because the model reasons more. And Muse Ember, with the same input and output prices as Claude Haiku 5.5, costs $0.14 against $0.41 per task.

At equal quality the gap reaches an order of magnitude. On the SWE-bench Verified leaderboard, in the mode where all models run in the same harness, Claude 4.5 Opus (high) solved 76.8% of tasks for $376.95 for the whole set, and MiniMax M2.5 (high) solved 75.8% for $36.65. That is $0.98 and $0.10 per solved task (our calculation). In a study of effort levels, on tasks the models solve at any effort, the maximum level cost up to 42 times as much as the minimum.

Task cost also varies from run to run. In the NeurIPS 2026 workshop version of the paper by Bai and co-authors, the most expensive run of a task typically costs twice the cheapest, and models with similar accuracy differ in spend by up to three times. An earlier preprint reported a spread of up to 30 times; we rely on the later version. The same paper found that the best models could predict their own spend before a run with a correlation of up to 0.77, although they underestimated input tokens: you can estimate a task's budget in advance, but leave headroom.

To turn this into a team's money, we took the task profile from an illustration on claude.dev: 40 turns, 2.8M input tokens, 90% of them read from cache, and 60K output tokens. At list price on Opus 5.5 such a task costs $2.82; without the cache it costs $12.40, or 4.4 times more. At three tasks per working day, that is $178 per developer and $17,791 per hundred developers a month.

The same hundred developers would cost $32,407 on Fable 5.2, $52,416 on GPT-6 Astra and $1,078 on DeepSeek V4.1 Flash at peak hours. A mix of 20% of tasks on Opus, 60% on Sonnet and 20% on Haiku comes to $9,420, almost half the all-Opus bill. Gemini 4's price increase on December 1 will double the bill for the same work.

An agent works in a loop: read files, call a tool, get the output, think, take the next step. On every turn the model receives the whole accumulated context again — the system prompt, tool descriptions, files read so far, the history. That is why input tokens grow faster than linearly, and they are what drives the bill.

What the agent has read takes up the most room. In a study of context management, tool output — file contents and command results — made up about 84% of the tokens in an average SWE-agent turn. In DX telemetry, cache reads rose over the year from 89.6 to 94.0% of all tokens. That is a share of tokens, not of money: a cache read costs a small fraction of the price of fresh input.

Failure costs more than success. In SWE-Effi, a failed SWE-agent attempt with GPT-4o-mini used more than 8.8M tokens on average, against 1.8M for a successful one: the agent goes in circles until it hits the limit. On the SWE-bench leaderboard, in all 39 published runs an unsolved task costs more on average than a solved one, and the 10% most expensive tasks account for 19 to 72% of a run's total.

Multiple agents multiply spend. In Anthropic's research system, an agent uses about four times as many tokens as a chat, and a multi-agent system about 15 times as many. That pays off only if the task is worth it: in a controlled comparison of architectures on a SWE-bench Verified subset, every multi-agent setup with an equal token budget solved fewer tasks than a single agent.

Finally, spend is uneven across people. According to Jellyfish data, in the first half of 2026 p90 weekly Claude Code tokens roughly tripled while the median barely changed. The average user spent $248 a month, and p99 spent $2,452.

Since rereading context is the main cost item, the main levers work on it. The simplest is prompt caching. In an experiment with a multi-turn agent, it cut session cost by 79.6% for GPT-5.2 and by 78.5% for Claude Sonnet 4.5. The condition is a stable prefix: the system prompt and tool descriptions must not change between turns. Caching the whole context together with volatile tool output, by contrast, made latency worse.

The second lever is removing from the context what is no longer needed. Simple masking of old observations — the agent sees the output of only the last ten turns — cut the cost per task by 51–57% in the same context-management study, while the solve rate moved between −22 and +10% in relative terms. Having a model summarize the history saved no more, but made trajectories about 15% longer. AgentDiet, where a cheap model prunes the trajectory, cut cost by 21–36%, and SWE-Pruner, which selects the relevant lines from files the agent has read, by 26.8%.

The third lever is stopping the agent in time. A hard turn limit at the 75th percentile of typical trajectory length cut cost by 24–68% with little effect on the solve rate. The effort ladder from the reasoning-level study works in a similar way: minimum effort first, maximum on failure; on SWE-Bench Pro this gave a median saving of 15.5%. The ladder works well where failure is cheap to detect, for example through tests.

There are also levers without research behind them: short instructions, disabling unused MCP servers, a new session for each new task — tips from the Claude Code documentation. Coinbase showed a practical result at company scale: according to a secondhand report of its executive's words, AI spend was cut almost in half while token volume grew, and the cache hit rate rose from 5 to 60%.

The price of an attempt does not yet tell you what a result costs. An accepted change — one that passed review, was merged and was not reverted — carries the cost of failed attempts, CI minutes, machine review and people's time on verification and rework. The diagram below shows how these items accumulate along the funnel.

The largest measurement comes from Jellyfish, across more than 1,300 companies: the fully loaded cost of a merged PR — engineer salaries plus estimated AI spend, divided by the number of PRs — fell over the year from $1,202 to $820 at the median company. The direct AI share is about $18 of a $799 average. For an engineering budget, tokens are still a small line: most of the cost is people.

At the same time, returns on tokens diminish. In Jellyfish's first-half report, the first million tokens per person per month yielded about 11 merged PRs per million, and beyond that, according to the authors, additional tokens added almost nothing. Spend varies widely: in the Larridin benchmark, among engineers who both spent on AI and merged code, the weekly bill is $86 at the 25th percentile, $213 at the median and $911 at the 90th.

Machine review costs money too. Over 30 days Cloudflare ran 131,246 AI review runs on 48,095 merge requests, at $1.19 per run on average: about 2.7 runs and $3.25 per request, or about $156,000 a month (our calculation).

A rejection does not always mean the agent got it wrong. Acceptance of agent PRs depends more on the task type than on the agent: documentation is merged in 82.1% of cases, new features in 66.1%. In a manual analysis of 717 PRs, only 35.7% of the rejected ones turned out to be clear agent errors, and 15.4% of the merged ones needed explicit reviewer involvement. So the denominator should be accepted changes by task class, not every PR indiscriminately.

The bottleneck shifts to verification. According to DX, in organizations where AI writes 80% of code or more, the median wait for first review is 82 minutes, and PRs grew 122% larger over the year. Why acceptance becomes the main cost item is covered in the longread on infrastructure for agentic development.

The payment model decides who bears the risk that the work will cost more than planned. With a capped subscription, the vendor bears it: the seat price is fixed, but the vendor can change the limit in its five-hour or weekly window. With pay-per-token, the company bears all of it. In between are seats with a credit pool.

Subscriptions are more generous than their price suggests. By a SemiAnalysis estimate, as reported secondhand, when used up to the weekly limit, Claude Max 20x delivered up to $8,000 a month at API prices and ChatGPT Pro up to $14,000, for a $200 subscription. But limits change: OpenAI announced a cut in Pro's included usage and reversed it a month later, while Anthropic raised Claude Code weekly limits by 50% in a promotion and from September 14 kept +25%, which is 17% below the promotional level.

Credits turn a subscription into money. Since June 1, 2026, GitHub Copilot has billed usage by tokens: a $19 Business seat comes with 1,900 credits at $0.01, the credits of all seats add up to a shared pool, and overage billing beyond the pool is on by default. With our task profile on Opus 5.5, a seat covers about seven tasks a month — after that you pay the same as through the API. In Codex, credits per 1M tokens follow the proportions of API prices. At JetBrains, a seat grants access and usage is drawn from the organization's shared pool — an empty pool stops everyone.

Moving from requests to dollars is painful. In 2025 Cursor switched its Pro plan from 500 requests to “$20 of included usage” at API rates, and three weeks later apologized and refunded unexpected charges. The vendor itself warns of the risk: Anthropic's prospectus says agentic products require more compute, and if pricing does not reflect that, the company's efficiency may suffer.

Running model inference yourself replaces paying for tokens with paying for machine time. A node of eight H100s costs about $23,000 a month at RunPod and about $27,000 at Lambda from November 16; eight H200s cost about $37,000 at CoreWeave and about $46,000 at AWS with Capacity Blocks reservations (our calculation: GPU-hour price × 8 × 730 hours).

To pay for itself against Opus 5.5 through the API, a RunPod node has to replace about 8,250 tasks of our profile a month. Against DeepSeek V4.1 Flash it is about 136,000 tasks: cheap open models through the API leave almost no room for your own hardware. The threshold counts rental only; people, networking, model updates and idle time are not included.

Companies run their own model for other reasons: data requirements, predictable latency, independence from a vendor. The SGLang team showed that in a large optimized DeepSeek-V3 deployment on 96 H100s, output costs about $0.20 per 1M tokens — roughly a fifth of the API price at the time. But that is the best case at full utilization; how to achieve it in practice is covered in the longread on operating inference.

Routing sends each task to the cheapest model that can handle it. The idea is not new: the FrugalGPT cascade matched the best model at “up to 98%” lower cost, and RouteLLM was in some cases more than twice as cheap with no loss of quality. But that was chat and single questions; an agent task is harder — the model is chosen before it is clear how hard the task is.

For agents the gap is especially wide. In the SWE-Router paper, in the same harness gpt-5-mini solved 55.6% of SWE-bench Verified tasks for $16.6 and gemini-3-pro-preview solved 70.4% for $391.3: a solved task costs about 19 times more with the strong model (our calculation). An interesting twist is SuperScout: a 7B-parameter model first explores the repository and passes a summary to a frontier model. It solves as many tasks as the best single model at about a fifth of the cost, but according to the authors' ablation the gain comes from passing the summary, not from choosing the model.

Products already route. Copilot Fusion switches between Anthropic and OpenAI models and costs $5.59 per index task versus $11.42 for Claude Code with Opus 5.5, scoring 2 points lower. Coinbase makes open models the default in its internal model gateway; an engineer can pick another, and a conversation stays on one model while its cache is alive, because switching mid-session resets the cache. In its 35th Technology Radar, Thoughtworks placed using the strongest model for every task in the Caution ring.

The practical conclusion: route at natural boundaries — by task class, by stage (exploration, planning, execution, review), by reasoning level — not per request. The model mix in our example cuts the team's bill from $17,791 to $9,420, provided that Sonnet and Haiku can handle their share of the tasks; check that on your own tasks.

A limit can be set at different levels: per person or key, per team or project, in the model gateway, per organization at the provider and, finally, in the finance budget. Each level can do different things: warn, switch to a cheaper model or stop.

A good example of a soft limit is Jamf on Amazon Bedrock. Each engineer has a daily budget: at 80% Claude Opus is switched off, at 100% Sonnet, and Haiku always stays available. The check runs every 15 minutes, a Slack message goes out at each threshold, and temporary exceptions are granted by a command with an audit trail. Work never stops: the limit only takes away the expensive models.

Limits leak. Without a database, LiteLLM does not enforce budgets and lets requests through. In Cloudflare AI Gateway, counters reconcile with a delay, so overspend is possible. Kong lets a request that crosses the limit complete. In Copilot, overage billing beyond the pool is on by default. Provisioned capacity in Azure and Vertex AI spills over to pay-as-you-go beyond the reserved volume. And in Claude Console, a per-person limit exists only in the Claude Code workspace.

The biggest leak bypasses every level. According to a Sonar survey, 35% of developers use their main AI tools through personal rather than work accounts. A hard limit on the work account pushes people exactly there. And mistakes surface late: according to a secondhand report of an FT story, an 860% project overrun at Amazon was discovered only five months later.

In early 2026 many companies encouraged token spend: leaderboards, usage targets, credit in performance reviews. Within six months the same companies moved to budgets. It is Goodhart's law in its classic form: a counter that becomes a target stops measuring anything.

At Meta, AI usage became part of employee performance reviews in 2026, and the internal “Claudeonomics” leaderboard counted 73.7 trillion tokens in just over 30 days. Around September 2–3, according to The Information and WIRED as reported secondhand, token counts were removed from reviews. At Amazon, with a target of more than 80% of developers using AI every week, employees built a KiroRank leaderboard and gamed it with agents; the leaderboard was shut down. At Microsoft, divisions have had target token budgets since July, and an executive wrote that tokenmaxxing is not what the company is optimizing for.

Uber went through the whole cycle in three months. In May, according to a secondhand report, the company used up its annual AI budget in four months. In June a company representative told Bloomberg about a limit of $1,500 a month per person in each agentic tool (secondhand report by Willison). In August the CTO declared the end of the tokenmaxxing era, and the company blog described a shared tier for all interactive tools instead of a budget for each one, plus real-time spend tracking so as to avoid strict limits. From July 6, Tesla capped AI spend at $200 a week per employee, with more only on a manager's approval.

A LeadDev survey shows that the habit persists: 58% of respondents say their organization measures AI's impact by token consumption. DORA advises otherwise: measure tokens by team, application or use case, and the outcome with existing delivery metrics; company-wide totals are meaningless and individual scores are harmful. In Radar 35, Thoughtworks put the share of AI-generated code and tokens consumed as productivity measures in the Caution ring, and its chief architect Chris Ford advises managing the cost of a completed task rather than the cost of a token.

To manage a budget, you need to break spend down by team, use case and model. There is no common format for this yet. The current standard for cloud billing exports, FOCUS 1.4, was ratified in June 2026, but tokens in it are just a consumed quantity. The FOCUS 1.5 draft adds recommended properties — model, token direction, cache action — and columns for who made the request; ratification is planned for December 3. Reasoning tokens and batch processing are not in the draft.

Telemetry is in a similar state. The OpenTelemetry GenAI conventions describe input, output and cache tokens, but have no cost metric, and their status is “development”: names were changing as late as November 5. Claude Code exports cost in dollars and tokens by type under its own names. Since April, Amazon Bedrock allocates cost by user or role if you enable the export option. In practice the data has to be brought together in your own gateway.

Forecasting is hard. According to a CloudZero survey, only 20% of companies forecast AI spend within ±10%, and roughly one in five misses by 50% or more. Meanwhile, 64% already run chargeback to teams. According to State of Tokenomics, the main problem is proving value (43%), spend visibility is named by 27%, and only 4% ask for lower prices. According to DX, almost half of engineering budget holders set aside 1–3% of the engineering budget for AI tools in 2026.

The FinOps Foundation suggests what to do with experiments: treat as an experiment any work that has an end date, no production SLA and no customers at scale, and give it a separate key and budget. Then an experiment does not dissolve into overall spend and does not turn into a permanent line item without anyone deciding so.

A token budget needs an owner: a leader responsible for both the spend and the outcome. If the spend lives in the IT bill and the outcome lives in the teams, nobody can decide whether to spend more. The CFO needs not a token counter but an answer to the question of what the company got for the money.

The site's author measures AI's effect in three layers (DotNext talk). The first is usage: who works with assistants and agents, where and how often; this is an input, not proof. The second is flow and time saved: time from task to production, review wait, rework, change size, incidents, and time saved on specific engineering jobs. The third is economic effect: the gain against the cost, which includes tokens, infrastructure, the platform team and verification time.

Tokens are only one item in the third layer. So the conversation with finance is best built on the ratio of value to cost by task class: what an accepted change costs and what it delivered in the flow. The strong counterargument — that tokens are still a small share of development cost (about $18 of roughly $800 in Jellyfish data) — holds only if spend is not concentrated in the tail. In the Larridin benchmark the p90 engineer spends four times the median, and in Anthropic's prospectus the top 5% of Claude Enterprise users with Claude Code spent about 20 times as much as users without Claude Code.

Finance also cares about predictability. AI spend forecasts are still imprecise — in CloudZero's data only one company in five lands within ±10% — and prices move in both directions. So a budget should come with scenarios: a model price increase like Gemini 4's on December 1, a change in a subscription plan, growth in the share of agentic tasks.

In Russia three things shape the bill: access to foreign models, data requirements and the intermediary's price. Through Yandex AI Studio, Yandex's cloud platform for AI models, you can run DeepSeek V4.1 Flash at ₽0.3 / ₽0.075 / ₽0.5 per 1,000 input, cached and output tokens, including VAT. In dollars excluding VAT, input costs $2.46 per 1M — 8–16 times more than from DeepSeek directly (our calculation). In return, the company gets data storage in Russia and a contract with a Russian legal entity.

With our profile, a task on DeepSeek in Yandex AI Studio costs about ₽303, and a hundred developers about ₽1.91 million a month, if the cache works; the price list says caching is not guaranteed. GigaChat Max, the top model in Sber's GigaChat family, has no separate cache price, so the same task costs about ₽1,859 and a hundred developers ₽11.7 million a month: six times more. A node of eight H100s at cloud.ru, Sber's cloud provider, costs about ₽4.99 million a month including VAT, without people or a model. How to build your own stack is covered in the longread on the local AI stack in Russia.

Usage is growing fast. According to a report by the FinTech Association, an industry body of Russian banks and fintech firms set up on the Bank of Russia's initiative, token consumption in GigaCode, Sber's coding assistant, grew from 60 billion for the whole of 2025 to 1.6 trillion in 30 days in June 2026, and SourceCraft, Yandex's development platform with an AI assistant, processed 435.5 billion in the first half of the year. Sber reported that compute for code generation grew 30-fold in five months, to 1.5 trillion tokens, and Yandex set a “75/75/75” goal: by the end of 2026 at least 75% of developers use AI regularly.

But budget is not the main barrier. In the same association survey, 43% of participants named budget constraints, the last of six barriers; the top places went to information security requirements (65%) and restrictions on transferring data to external services (53%). Russian companies have not disclosed ruble budgets or token limits publicly.

Everything above adds up to a sequence of steps for one quarter. Visibility first, then defaults, then the budget. Hard per-person limits are a last resort, not a first one.

Month one: see the spend. All model traffic goes through a gateway or the tool's own metering, keys are issued per team and use case, and the first report is showback. Separately, look at the tail: which people and use cases sit in p90 and p99, and whether the five most expensive sessions are valuable work or an agent going in circles.

Month two: cheap defaults. Default models and reasoning levels by task class, a stable prefix for caching, short context, a turn limit for background agents. Soft thresholds: alerts at 50 and 80% of the budget, switching to a cheaper model, temporary exceptions with an audit trail. The signal of success: cost per task falls while the share of rejected PRs does not grow.

Month three: the budget. Cost per accepted change for two or three task classes, linked to flow metrics. A quarterly budget broken down by team × use case, with a reserve for experiments that have an end date, and price scenarios. Chargeback to teams comes only once the teams trust the data.