The token free lunch is ending.

On April 27, 2026, GitHub announced that Copilot would switch to usage-based billing on June 1, 2026. Its own blog post calls the current model "no longer sustainable." GitHub had been absorbing inference cost. Now it's putting more of that cost on the usage meter.

This article records provider announcements and rate cards as they stood on April 28, 2026. The linked provider pages are the source for current terms.

Flat rates hid the meter

Flat-rate AI coding subscriptions worked like early ride-share pricing: charge less than the service costs, build the habit, then reprice it. AI makes the running cost easy to meter. Every token, model call, and retry has a price. The open question was how long vendors would absorb it.

For most major coding tools, the answer has been: until now. GitHub has put a date on its answer.

Coding agents are useful, and the tools have improved fast. Frontier model access at a flat price is still moving toward actual consumption. Teams that plan around the old packaging will eventually run into the accounting.

Coding agents changed what one request costs

Old-style code completion was predictable: a short prompt, a short output, and a small token footprint. Flat-rate billing worked because requests stayed manageable. The median user wasn't expensive. Even heavy tab-completion users weren't spending orders of magnitude more than light users.

A coding agent breaks that pattern. It doesn't just complete a line. It works through a plan across a repo. One user prompt might expand into this:

const agentRun = {
  input: ["repo context", "tool output", "test failures", "previous attempts"],
  output: ["patches", "summaries", "commands", "follow-up plans"],
  hiddenCostDrivers: ["retries", "reasoning", "long context", "model choice"],
};

That loop can use more tokens than a hundred short completions. Retries alone can double the context. Add reasoning, tool calls, test output, and a large codebase, and "one message" barely describes what ran through the model.

GitHub said it plainly: Copilot "evolved from a simple in-editor code completion tool to an agentic platform capable of handling long, multi-step coding tasks across entire repositories." The workload changed. The flat-rate model wasn't built for it.

Copilot put the accounting on the page

GitHub's announcement says plainly what other vendors had only implied. Starting June 1, 2026, GitHub AI Credits replace premium request units. One AI Credit equals $0.01. Usage is calculated from input, output, and cached tokens at listed API rates. Code completion stays included in paid plans. Agentic work and model-choice premiums come out of the credit pool.

The monthly credit allocations by plan:

• Free: 50 AI Credits per month.
• Pro: 1,000 AI Credits per month.
• Pro+: 3,900 AI Credits per month.
• Business: 1,900 AI Credits per user per month (pooled across the org).
• Enterprise: 3,900 AI Credits per user per month (pooled across the org).

Business and Enterprise pooling helps because light users offset heavy ones. You don't have to predict each person's usage perfectly. But credits don't trigger an automatic fallback to a cheaper model. Usage continues as overage, if the organization allows it, or stops. A few engineers running long, multi-file debugging sessions on the most expensive models can hit the ceiling quickly.

The model pricing table shows how far the rates move. GitHub's examples put Claude Sonnet 4.6 at 9x instead of the old 1x premium request rate. Claude Opus 4.6 moves from 3x to 27x. GPT-5.4 mini moves from 0.33x to 6x. GPT-5.3-Codex and GPT-5.4 both move from 1x to 6x.

Those multipliers track the move closer to API rates. Copilot had been absorbing the gap between its price and inference cost. The new system exposes more of that gap. The cost was already there; users just didn't see it in this form.

Codex is moving toward token math too

OpenAI moved Codex pricing to API token-based rates for some plan types on April 2, 2026. Credits remain the purchased unit, but what you spend is driven by actual token consumption: that replaces what OpenAI calls "average per-message estimates" with a direct mapping between what the model processed and what you owe.

Larger codebases, longer conversations, extended reasoning, and multi-step tool use cost much more per session than a clean short prompt. The infrastructure bill already worked that way. The pricing statement now reflects it.

At publication, the Codex rate card for plan types already on token pricing listed these credits per million tokens:

• GPT-5.5: 125 input, 12.50 cached input, 750 output.
• GPT-5.4: 62.50 input, 6.25 cached input, 375 output.
• GPT-5.4 mini: 18.75 input, 1.875 cached input, 113 output.
• GPT-5.3-Codex: 43.75 input, 4.375 cached input, 350 output.

GPT-5.5 is more expensive per token than GPT-5.4, and OpenAI says it uses significantly fewer tokens to achieve comparable results. Whether that efficiency actually wins on a per-task basis depends on the task. If GPT-5.5 finishes in one pass where GPT-5.4 requires three retries, the cost math shifts in its favor. If the tasks are already short and well-specified, you pay the unit price premium without a corresponding reduction in volume.

Prompt caching is one direct response to token pricing. The OpenAI model documentation says to put stable context at the start of the prompt and dynamic context near the end so the cache prefix matches across calls. Long-running agents also need compaction. Carrying the full conversation through every turn is expensive. A well-designed agent summarizes state instead of restating it. That choice shapes the architecture, not just the prompt.

Cursor and Windsurf moved earlier

Both tools sell subscriptions over the same kind of infrastructure bill. Their changes over the previous year made the pattern visible before GitHub put Copilot's accounting on the page.

Cursor's June 2025 pricing change introduced Ultra at $200/month and moved Pro away from fixed request limits toward compute limits. Cursor said Pro would include at least $20 of model inference at API prices, while also introducing unlimited Auto model access. That wording matters. Unlimited Auto is not the same thing as unlimited manual access to every frontier model. It is a routing strategy wrapped in a subscription.

The July clarification made the mechanism plainer: Cursor acknowledged that the communication had been confusing, offered refunds for unexpected charges, and explained why request counts were breaking down. Hard requests can cost an order of magnitude more than simple ones. A syntax question and a multi-file agent task are not the same unit, even if both show up as "a request" in the UI. By August, Cursor was saying the quiet part directly: it was adapting pricing to an agentic world.

Windsurf's March 2026 quota change is the same story with different product language. Windsurf replaced prompt credits with daily and weekly usage allowances based on model token usage. It says short requests with a few files in context use fewer tokens than long requests across larger codebases, and that the new system better reflects underlying costs. If a paid user exceeds the included allowance, extra usage is billed at API list prices for the model used.

During 2025, Cursor forum and Reddit threads tried to decode what "unlimited" meant once Auto, frontier models, usage pools, and overages all lived in the same product. Windsurf users did the same as the product moved from separate flow-action credits to simpler prompt packaging, then from credits to daily and weekly quotas. The details varied, but the complaint stayed the same: people could feel the subsidy turning into accounting.

This is a routing lesson. Even tools sold as subscriptions reward users who know which tasks need an expensive model. Treat every task the same and the allowance disappears faster.

Claude has the same cost problem

Anthropic offers Claude through plans with usage limits and through direct API access. GitHub's April multiplier table made the same cost visible inside Copilot: the more expensive Claude models consumed more of the shared credit pool. The wrapper changed. Long context, tool output, retries, and frontier reasoning still had to be paid for.

Open-weight models change the routing, not the bill

Open-weight models matter here. DeepSeek, Llama, Qwen, and newer entrants can handle a large share of routine coding work. Windsurf already surfaces options like Kimi K2.5 as cheaper alternatives for users watching their allowance. As these models improve, more traffic can move away from frontier labs.

That weakens the pricing power of frontier labs. It does not repeal the hardware bill. Someone still pays for GPUs, memory bandwidth, power, and the operations team keeping inference stable, whether that cost lands at a frontier provider, an open-source hosting provider, or an engineering team running local inference. The hardware does not care about the model license.

Open source can weaken the pricing power of frontier labs. It does not repeal the hardware bill.

The likely near-term answer is routing: use different models for different tasks and decide when the expensive model is worth its price.

routine_edits:
  model: smaller
  reason: predictable, low ambiguity
hard_debugging:
  model: frontier
  reason: multi-file reasoning and failure analysis
generated_tests:
  model: midrange
  reason: high volume, easy to verify

SemiAnalysis breaks down the economics of coding assistants at the infrastructure level. Routing, user behavior, model quality, and vendor subsidy all change the unit economics. The subsidy was the part that could never last.

What businesses should do now

Don't panic-switch tools. Measure the cost of model access, then structure the work around what you find.

Map your actual usage against what it would cost at metered rates. Most teams do not know this number. Business and Enterprise Copilot plans pool credits across users, which helps, but a few engineers running heavy agentic sessions can drain a shared pool faster than most teams expect. Know who the heavy users are and what they are doing.

Separate frontier-model tasks from routine tasks deliberately. Long-context planning, hard debugging across multiple files, ambiguous product decisions: these deserve the expensive model. First-pass test generation, docstring updates, boilerplate, simple renaming: they do not. This is a workflow decision as much as a cost decision. Smaller models on well-specified tasks often produce results that are as good as or better than frontier models on the same task with a lazy prompt.

Build prompt caching into any long-running agent setup. Stable context goes early and stays stable. Dynamic context, like test output and tool results, goes late. This shapes agent memory, context windows, and session management from the start.

Watch overage signals before you hit them. Decide whether work stops, falls back to a cheaper route, or buys more usage. Pooled organization credits can keep one heavy user from stopping the team, but they also make usage harder to attribute. Set up billing reports and cost-center attribution before the first surprise invoice.

My bet

I think subscriptions survive as the package while the cost underneath becomes metered, whether users see it or not. Major coding AI products are moving at different speeds, and I don't think that direction reverses. Frontier inference still has a marginal cost, so flat-rate access at scale has to ration model quality or charge customers more.

Open-source models keep improving and will push more routine work out of frontier pricing. That's good for developers and cost control. It shifts the routing cutoff, but it doesn't end the pricing problem.

Teams now need to know which work deserves the expensive model, which context shouldn't be sent again, and which tasks can move to something cheaper without changing the result. That routing belongs in the product and the engineering plan.

The invoice does not care how efficient the token curve looked in the demo.