GitHub Copilot switched to token billing on June 1 — here's what changed and what it costs

GitHub Copilot's billing model changed on June 1, 2026. The flat-rate premium request allowance that Copilot Business and Enterprise subscribers received monthly has been replaced by "GitHub AI Credits" — a usage-based system that charges by token consumption across all agentic features. The base subscription prices haven't changed ($19/user/month for Business, $39/user/month for Enterprise), but what those prices buy has fundamentally shifted in how it's tracked and exhausted.

This matters because agentic coding sessions — where Copilot autonomously writes, edits, tests, and iterates across multiple files — consume tokens at rates that are orders of magnitude higher than simple autocomplete. The economics that made sense under the old model don't automatically transfer.

What the new billing structure actually says

Under the GitHub AI Credits system, usage is measured in tokens — the basic unit of text that language models process, roughly three to four characters each. Input tokens (what you send to the model), output tokens (what it generates), and cached tokens (repeated context) are all counted at published API rates for each underlying model.

The critical distinction: inline code completions in the local editor do not consume credits. This was a deliberate choice by GitHub to ensure that the most common and frequent Copilot interaction — the autocomplete suggestion you get as you type — has no variable cost. The credit system applies to agentic features: Copilot coding agent, Copilot Spaces and Spark, third-party coding agents using the Copilot API, and extended chat and code review sessions.

Each plan includes a monthly credit allotment. Once that allotment is exhausted, additional credits can be purchased, or agentic features stop working until the next billing cycle. Organizations can set caps to prevent overages.

Why the shift and what it signals about where Copilot is going

GitHub's stated rationale is that Copilot has evolved from a smart autocomplete into a full agentic platform, and the old pricing reflected the former rather than the latter. A Copilot session that autonomously refactors a codebase across dozens of files, runs tests, interprets failures, and proposes fixes is consuming compute resources that aren't comparable to a single chat message. Token-based billing aligns cost with actual resource consumption.

The subtext is that GitHub is positioning Copilot to compete differently than it did in 2024. As of 2026, Copilot's agentic mode can run up to eight autonomous agents in parallel, execute terminal commands, and maintain context across an entire project. That capability competes less with autocomplete tools and more with agent orchestration platforms — a different cost tier is appropriate.

The practical cost impact

For teams that use Copilot primarily for inline completions and occasional chat, the change is largely invisible. Completions don't count against credits, and light chat usage is unlikely to exhaust monthly allotments.

The impact concentrates on teams running extended agentic sessions. A Copilot agent session that handles a complex feature implementation — planning, writing code across multiple files, running tests, debugging — can consume thousands of tokens per operation. Some developers running intensive agentic workflows reported bill increases shortly after the transition took effect. GitHub's published credit allotments are not public by default; teams need to check their organization billing dashboards to understand where their baseline sits.

The practical advice is to audit which Copilot features your team actually uses and map those against the new credit consumption model before assuming your usage pattern is credit-neutral.

How Cursor is handling the same problem differently

Cursor's pricing model offers a useful contrast. Cursor Pro at $20/month includes unlimited completions and a monthly allowance of premium model requests. Usage-heavy Cursor users can hit the premium request ceiling, at which point they either pay for more or drop to slower models. But Cursor's model-switching approach — where it routes to faster, cheaper models when premium quotas are exhausted — keeps agentic workflows functional rather than stopping them cold.

Cursor's agentic mode supports up to eight parallel agents, multi-file editing via Composer, and autonomous terminal execution — a feature set comparable to Copilot's agent capabilities. As of mid-2026, Cursor had approximately 4 million monthly active users, up from roughly 500,000 a year prior. The growth has been driven partly by teams migrating from Copilot after experiencing the new billing structure.

What productivity research actually says

JetBrains published research in April 2026 covering developer workflows across 30,000 developers using AI coding tools. The findings show a 20–55% increase in task completion speed on well-defined coding tasks, with senior developers seeing larger gains than junior ones — the opposite of the intuition that junior developers benefit more from AI assistance. The reasoning: senior developers have more context to leverage in their prompts and spend a higher fraction of their time on tasks (architecture, refactoring, documentation) where AI assistance is most effective.

The JetBrains research also identified what it called the "AI Paradox" — individual developer velocity increases significantly, but team-level delivery metrics don't always reflect this proportionally. The bottlenecks shift from writing code to reviewing AI-generated code, managing context across longer sessions, and maintaining architectural coherence when AI generates code at higher volume. Neither Copilot nor Cursor resolves the review bottleneck — they move it.

What to do now

If you're running Copilot Business or Enterprise, check your organization's AI Credit consumption in GitHub's billing dashboard. Establish a baseline before the end of June — the first full billing cycle under the new model. If your team runs significant agentic sessions, model out expected monthly credit consumption and compare it to your allotment. The new pricing is rational if your usage matches the patterns GitHub designed it for; it's expensive if your team adopted agentic features aggressively under the old model's pricing.

If you haven't evaluated Cursor for your team, the pricing comparison is worth doing. The two tools have comparable agentic capabilities and different cost structures that favor different usage patterns.