One developer on the GitHub community forum reported burning through roughly 360 AI Credits in a single normal workday - and that was while deliberately throttling certain workflows to stay within budget. At the old flat-rate model, that same day cost nothing extra.
On June 1, 2026, GitHub moved all Copilot plans to usage-based billing. Every plan now includes a monthly allotment of GitHub AI Credits, with the option to purchase more. The change sounds administrative. For engineering teams that have built agentic coding into their daily workflow, it is not.
What actually changed on June 1
GitHub's explanation is direct: Copilot is not the same product it was a year ago. It has evolved from an in-editor assistant into an agentic platform capable of running long, multi-step coding sessions. Agentic usage is becoming the default, and it brings significantly higher compute and inference demands. Today, a quick chat question and a multi-hour autonomous coding session can cost the user the same amount - and GitHub has been absorbing the escalating inference cost behind that usage.
The old model counted requests and applied multipliers per model. Under the new model, every Copilot interaction consumes tokens: input tokens, output tokens, and cached tokens. Each token is priced based on the model used.
The total is converted into AI Credits, where one AI Credit equals $0.01 USD.
A quick chat question, a PR review, and a repository-level refactor do not put the same load on the system. GitHub now ties those interactions to model usage instead of treating them as equal requests.
The concrete consequence: a long Copilot cloud agent session using a frontier model across multiple files will cost more AI Credits, because it's doing more work. And Copilot code review recently moved to an agentic architecture that runs on GitHub Actions - so reviewing a pull request with Copilot now counts against your included Actions minutes at the same per-minute rates as any other Actions workflow. That is two meters, not one.
The bill now reflects what the work actually costs. That is honest. It is also the moment where "using Copilot" becomes a line item engineering managers have to explain.
The session that costs more than you think
Copilot now powers far more complex, agentic workflows
- and the benchmark numbers show why that matters. On Terminal-Bench 2.1, Codex CLI on GPT-5.5 leads at 83.4%, with Claude Code following at 83.1%. On SWE-bench Verified, Fable 5 leads at 95.0%. Models capable of those scores can hold large amounts of context, run tests, read files across a repo, and iterate - all of which consume tokens continuously.
Agents now execute decisions autonomously rather than merely suggesting them, operating over long-running execution loops measured in minutes to hours. In one documented session, Claude Code autonomously refactored a production-scale React/TypeScript codebase - searching files, creating components, running 831 tests across 95 files - all without human intervention. That kind of session, priced at token rates against a frontier model, is not the same as a tab of autocomplete suggestions.
Autocomplete still feels like a feature in the editor. Agents behave more like compute. That distinction is what the billing change forces teams to confront.
What this means for teams running agents daily
This reflects the growing divide between assistive autocomplete and delegated engineering work. Teams that train developers to reserve expensive models for complex tasks may stretch their credits further. Teams that treat agentic AI as an unlimited intern may encounter budget ceilings quickly.
A few things to sort out before the promotional credits expire on September 1:
An enterprise with 100 Copilot Business users gets a shared pool of 190,000 AI Credits rather than 100 individual buckets - so power users can draw more when they need it, while lighter users offset that consumption. That pooling is actually useful. But a team experimenting with autonomous code review or repo-wide modernization can consume shared allowance quickly.
Code completions and next edit suggestions are not billed in AI Credits and remain unlimited for all paid plans. More complex interactions consume more of your usage allowance. The main factors: conversation length and complexity, and agentic features - agent mode and Copilot cloud agent can involve multiple model calls within a single task.
The practical split: use lightweight models for exploration and fast completions. Reserve frontier models for the sessions where the agent is actually doing the work - running tests, reading multiple files, opening PRs. A teammate like Beagle, routing context summaries into Slack instead of re-running large agentic sessions to reconstruct state, reduces unnecessary token burn at the handoff layer.
The winning organizations will not simply cap everything. They will connect AI spend to engineering outcomes: faster pull requests, fewer defects, improved test coverage. Cost governance without productivity measurement risks killing the very workflows that justify Copilot in the first place.
The broader signal for agentic coding tools
The Copilot billing shift is not an isolated decision. It is the first large-scale signal that agentic coding - tools that plan, write, test, and open PRs autonomously - has acquired cloud-infrastructure economics. For Microsoft and GitHub, usage-based billing is an admission that developer AI is becoming infrastructure. Infrastructure can be packaged beautifully, but at scale it tends to revert to meters.
Mid-way through 2026, developer consensus has largely settled on one point: there is no single best AI coding agent in isolation. Developers evaluate tools based on where they want leverage - speed and flow inside the editor, control and reliability on large codebases, or greater autonomy higher up the stack. That framing now has a cost axis attached to it.
The question is not whether your team uses agentic coding. Adoption is pervasive: 84-85% of developers either use or plan to use AI coding tools, and 57% of organizations have agents in production. The question is whether your team has the instrumentation to know what those sessions actually cost, and whether you can point to the engineering outcomes that justify them.
The flat-rate era for agentic coding had a good run. It normalized behavior that teams now depend on. What comes next is the harder part: keeping those workflows alive when every autonomous session shows up on a line in the budget.