What are you counting?

GitHub Copilot changed its billing unit twice in a year, from seats to premium requests to tokens converted into credits. Each change moved the meter closer to what the vendor pays for, and each one means deciding again what a unit of usage is.

On June 1, 2026, the day every GitHub Copilot plan moved to usage-based billing, one developer posted to GitHub's own billing FAQ thread: "How in the hell can 1 prompt which last month would barly cost a cent, now take up $4.51." Another reported that "two short sessions in the VS Code extension, with maybe 2–4 prompts total" had "already consumed 210.5 AI Credits/Tokens/Whatever", and the FAQ post itself was sitting on 629 thumbs-down against 12 up when I last read it. Nobody in that thread was arguing about the price per credit. They were arguing about what had been counted, because the thing GitHub was counting had changed underneath them, for the second time in a year.

GitHub gave its reason in plain terms when it announced the change on April 27: "Agentic usage is becoming the default, and it brings significantly higher compute and inference demands," and "today, a quick chat question and a multi-hour autonomous coding session can cost the user the same amount." That second sentence is the whole of this series in one line. A seat assumes that what one user costs to serve sits in a narrow band, so a flat monthly price can absorb the variance, and an agent that runs for hours on one instruction breaks that assumption in a way no seat price can cover. So the cost has to be metered, and the first problem in metering it is the one the FAQ thread was really about: deciding what a unit is.

Three units in a year

Copilot's history makes the problem unusually easy to see, because the unit moved twice and GitHub documented each version.

Until mid-2025 the unit was the seat. On June 18, 2025, billing for premium requests began: Pro got 300 a month, Pro+ got 1,500, and further requests cost $0.04 each. A premium request is a user action, but not every action is worth the same, so "each model has a premium request multiplier, based on its complexity and resource usage", which is how a single Copilot code review comes to count as 13 requests from June 2026. The meter counted something the user could see (I asked a question, I asked for a review) and weighted it by something the user couldn't (what that model costs to run).

From June 1, 2026 the unit is the token. "Each token is priced based on the model used, and the total is converted into AI credits, where 1 AI credit = $0.01 USD," according to GitHub's models and pricing reference, which lists separate rates for input, cached input, cache write and output tokens, per model, with a long-context tier above 272K input tokens on some of them. GPT-5.6 Terra is $2.00 per million input tokens and $12.00 per million output; Claude Sonnet 4.6 is $3.00 and $15.00; and "earlier OpenAI models have no cache write cost", so even the list of things being metered varies by model.

Each change moved the meter away from what the user does and towards what GitHub pays for. A request is legible to the person making it, and a token mostly isn't, since nobody at the keyboard knows how many cached-input tokens an agent loop will reread on its fourth pass through a repository. That's the trade the thread is complaining about, and it's the trade every AI product in this series makes in some form: the closer the unit sits to the vendor's cost, the further it sits from anything the customer can predict.

The seat didn't go away

It would be easy to read this as seats being replaced by a meter, and that isn't what happened. Copilot Business still sells per seat, and each seat brings 1,900 credits a month (Enterprise brings 3,900), but those credits "are pooled at the billing entity level", so 100 Business users share one balance of 190,000. "Adding licenses mid-cycle increases the pool immediately," while removing them "doesn't shrink the pool: the decrease is reflected at the start of the next billing cycle." The pool resets at midnight UTC on the first of each month and unused credits are forfeited. Paid usage beyond the pool is on by default, and an administrator has to switch off a policy called "AI credits paid usage" to stop it.

For individuals, the plan table splits the allowance in two: Pro at $10 a month includes 1,000 base credits and a further 500 "flex allotment", and the flex allotment "is a variable part of your included usage; it is designed to adapt as the economics of AI evolve, including model pricing, new models, and improvements in efficiency." So part of what the customer is buying is an allowance the vendor has said it may resize. GitHub's own pages also disagree about its size: the April announcement says Pro includes "$10 in monthly AI Credits", while the current docs total it at 1,500 credits, which is $15. Annual subscribers, meanwhile, stay on premium requests until their term ends, so two meters are running at once, split by contract term.

Modelling it, on paper

Here's how that published structure would map onto Revenue Cloud Usage Management, as its data model is described in the public revenue-cloud-foundations repository. This is a thought experiment about the shape of the problem, not a claim about GitHub's own billing stack, and nothing below is a configuration guide.

The first object you'd create is a UsageResource, the thing being counted, and Copilot shows straight away why that's a decision rather than a form field. One option is a single resource called AI credit, with the per-model token arithmetic done upstream before the usage event is recorded. That keeps the billing side simple, but it means each TransactionJournal row (the usage event record) arrives with the price already baked in, so if GitHub re-rates a model or the flex allotment moves, the history in the billing system can't be recalculated from what it holds. The other option is to meter tokens directly, as a resource per model and token type, and let rating convert them to credits. The billing system then holds the actual quantities and can re-rate, but the number of resources grows with every model GitHub adds, and the cache-write column exists for some models and not others.

Two ways to meter Copilot's AI credits. A, record credits: an agent session's tokens are priced per model on the product side, and the usage event arrives as a credit amount, which billing rates at $0.01. B, record tokens: the usage event carries tokens by model and token type, and billing's rate card converts them to credits at $0.01. A keeps billing simple but fixes the price into each event; B can re-rate but needs a resource per model and token type.

Neither option is wrong, and the choice decides which team owns the price: the people building the product, or the people running billing. The other parts of the structure pose their own questions. The pooled seat allowance becomes a grant derived from seat quantity, and its asymmetry, where an added seat counts now but a removed one counts next month, is a commercial rule that has to be specified explicitly, since nothing about a pooled grant implies it. Code completions and Next Edit suggestions "do not consume AI Credits", which is a decision about what isn't metered, and it has to be enforced somewhere before the event is recorded. And Copilot code review now also consumes GitHub Actions minutes, so one action produces events on two meters, which have to be rated and invoiced without the customer being charged twice for one thing.

What the rest of the series counts

Defining the unit is only the first problem. Once usage arrives as a stream of events rather than a seat count on a contract, quote-to-cash has to deal with events that turn up after the period they belong to, which is where MongoDB Atlas comes in next. It has to decide when a period is closed and what happens to usage that lands after the close, which HubSpot's per-resolution pricing makes unusually concrete. It has to draw down commitments and allowances in an order the customer agreed to, which Datadog publishes as arithmetic. And at the end of the series, with Zendesk, it has to bill for an outcome that a model decided had happened.

Copilot's meter is at least a count of something physical, since a token was either processed or it wasn't. The question the developers in that FAQ thread were asking, which is how they're supposed to check the number, gets harder at each step from here.

No comments yet