In June 2025, Cursor replaced its individual plan’s “500 requests per month” cap with a token ledger backed by a pool of API credits. Less than a year later, on June 1, 2026, GitHub announced that Copilot would move its entire product line to the same accounting model. Two products, two different positions in the market—yet the same billing language: charge by token consumption, settle at published model rates.
The instinctive reaction is: Is GitHub following Cursor’s lead and raising prices? The official line says otherwise: monthly subscription fees stay the same; only the meter changes. Under the same sticker price, an engineer who mostly uses inline completion and one who runs agents across a monorepo every day will face radically different cost curves. This piece is not about whether it’s “expensive.” It’s about what rules are being rewritten, and what signal that sends to developers and enterprises worldwide.
I. What Actually Changed: From “All-You-Can-Eat Requests” to a Token Ledger
On April 27, 2026, GitHub announced that starting June 1, 2026, all Copilot plans would move from Premium Request Units (PRUs) to GitHub AI Credits, billed by input / output / cached tokens at each model’s published API price. From early May, users can use preview billing in Billing Overview to see estimated usage before the switch.
The shift in a nutshell:
| Dimension | Old model (PRU) | New model (AI Credits) |
|---|---|---|
| Unit of measure | “Premium requests” (count) | Tokens + model unit price |
| Monthly fee | Pro $10, Pro+ $39, etc. (unchanged) | Unchanged; includes a credit allowance |
| Included allowance | PRU quota | Pro: $10 credits; Pro+: $39; Business $19/seat; Enterprise $39/seat |
| Inline completion / Next Edit | Included in plan | Still do not consume credits |
| Agent, multi-model chat, etc. | Consume PRUs | Consume credits |
| When allowance runs out | Could fall back to a cheaper model | No fallback—credits and budget controls only |
| Code Review | — | Consumes credits and GitHub Actions minutes |
| Enterprise | Per-seat licensing | Promotional extra credits Jun–Aug; pooled credits; budgets by enterprise / cost center / user |
The easiest misread: unchanged list price ≠ unchanged bill. Light users may never exhaust included credits; heavy agent users will face a clear, predictable overage curve on top of a fixed monthly fee—much like cloud’s reserved capacity + pay-as-you-go.
II. This Isn’t GitHub Acting Alone: A Pricing Convergence
Cursor took the same path in June 2025: Pro includes $20 of frontier-model API allowance; the hardest requests can cost roughly 10× a simple one (per Cursor’s own wording). Copilot’s move isn’t mere “copycat” marketing—it’s convergence forced by upstream economics and the category itself.
OpenAI, Anthropic, Google, and others all bill platforms by the token; if a platform keeps selling flat monthly + per-request to end users, it locks in wildly variable inference cost behind a fixed price. Whether Cursor or Copilot, the business is essentially API resale plus engineering wrapper—so the meter must align on input, output, cache, and spread between models.
Competition is shifting too: from “whose subscription is cheaper” to “who helps you finish agent work reliably within the same budget.” Effective delivery means changes merged to main, not lines generated. Accounting itself is becoming part of product competitiveness.
III. The Real Why: Why Token Billing Had to Happen Now
GitHub’s blog is blunt: Copilot is no longer “completion in the editor” but an agent platform that spans repos and multi-step loops. A 30-second Q&A and a multi-hour autonomous coding run cost the user the same under PRUs, while the platform bears orders-of-magnitude different inference cost—the old model was no longer sustainable.
Three layers:
Product. As agents become the default, sessions lengthen, tool calls multiply, and context is re-injected repeatedly—token use grows almost exponentially. Completion and Next Edit stay free; Agent and Code Review run on credits—a deliberate two-track design: subsidize mechanical “typing,” price thinking and delegation explicitly.
Economics. Usage follows a power law: a small share of heavy users consume most compute. Fixed monthly fee plus an “unlimited” mental model means the platform subsidizes the long tail indefinitely. Credits make who uses, pays; who uses more, pays more—so unit economics can close.
Ecosystem. With many models in play, expensive tiers need multipliers and other price signals; otherwise platforms can’t balance “best model by default” with sustainable margin. Removing post-quota fallback moves the safety net from platform to user and org—you must manage budget, not assume you can always limp along on a weaker model. Coldly: token billing also transparentizes the chain from model vendor → platform → user. When people say “it’s expensive,” they’re often paying for the priciest inference tier upstream; if the platform keeps hiding that behind flat monthly fees, the bill still gets collected—via throttling, downgrades, or shutdown.
Cursor’s apology and refunds in July 2025 show: correct metering ≠ correct experience. Developers resist not only paying more but unpredictable bills; Copilot’s emphasis on preview billing in May is learning that lesson.
IV. What Signal Is Being Sent?
Three subtexts, briefly:
Compute is commoditized. AI coding assistants are no longer a “feature toggle” but metered inference, like EC2; “whether you can use it” upgrades to “whether you can use it within budget.”
Seats + inference quota. Enterprise buying shifts from “Copilot seats” to “seats + org-level credit pool”; the cost center moves from GitHub subsidy to the customer CFO’s FinOps line items.
The subsidy-for-acquisition era is ending. The category is maturing commercially: platforms must be sustainable on heavy agent users, not mask power-law bills with flat monthly fees.
When signals land, individual workflows and org procurement and governance deform first—treated separately below.
V. Where Things May Go (Inference)
Judgments based on current product direction—for later validation:
- Two-track products harden: completion / Tab stays high-quota or “included”; Agent / Review become metered + budgeted category defaults.
- Org governance tooling surges: cost attribution by person / team / repo, model routing, session caps, pre-approval—aligned with Copilot’s pooled credits and budget controls.
- Request-based plans exit the mainstream: products still selling “N premium requests” will lose money or throttle on heavy agent users.
- Competition moves: at the same monthly fee, the fight is how much mergeable delivery the same credits buy.
- Toolchain splits: token-sensitive users add local / self-hosted share; enterprises still favor compliant, single-bill hosted agents.
- Trust as differentiation: transparent metering, hard caps, preview bills—directly affect retention; Cursor already paid for getting this wrong.
- “Effective delivery” becomes an internal KPI: rough but useful metrics—PRs merged per thousand credits, production issues fixed—replace “lines generated.”
VI. Impact on Developers and Enterprises
Global software already lives with seats + cloud usage; Copilot imports that logic into the daily coding surface. The rules are horizontal: same GitHub ecosystem, same rule set. Below: felt daily change for people and orgs—not country-specific policy lists.
1. Individual and Team Developers
Employed engineers (company pays). Usage becomes attributable: whoever keeps the priciest model on a full-repo agent is a high-burn node. Picture a distributed team: a Staff engineer in Silicon Valley kicks off a long architecture session Friday afternoon; European colleagues log in Monday to an org pool near cap—time zones and habits make “who burned credits” a real management issue. Under PRUs, quota exhaustion had fallback; now peaks depend on whether admins raise caps or budgets. Performance talks risk putting output and inference cost on the same slide—even if companies don’t publish per-person bills, FinOps will ask.
Self-serve Pro / Pro+. Monthly fee maps to included credits ($10 / $39); light users often under-use, paying for agent capacity they rarely touch. Freelancers pricing by day while leaning on agents eat margin on inference—same logic as outsourcers, smaller scale. Side projects and OSS maintainers treating agent as default face steeper overage than old “out of requests.” Treat Billing Overview like a cloud bill; use preview before June.
Tech leads and Staff. A new line item: inference cost curve—what gets completion vs agent, default model tier, per-session caps. In a release crunch, “Copilot Review on every PR” stacks Actions minutes and credits in one sprint; leads must trade review coverage vs bill slope. Code Review binds AI and CI cost for the first time—platform and engineering leadership must talk together.
Junior growth. If culture is “agent first, think later,” who pays for trial-and-error depends on budget policy. Over-reliance on costly agent exploration makes cheap practice (small modules, verifiable slices) scarcer—a structural issue everywhere.
OSS maintainers and multi-tool users. Many contributors run personal Copilot: completion stays cheap; cross-repo agent on an issue can burn credits in minutes. Copilot + Cursor / CLI / other agents turns TCO from fixed subs into subs + variable inference—without unified awareness, multiple surprise bills at month-end.
Workflow migration (summary). Premium shifts from “writing code” to “defining boundaries, acceptance, context control, model choice, session length.” Whole-repo paste, unvalidated mega-prompts, default expensive model long runs are burning money in the token era. Completion for mechanical typing; agent only for sliced tasks with acceptance criteria—operational discipline, not sermonizing. Most practical start for individuals: a personal usage weekly (even two weeks post-switch)—learn whether cost is agent vs review, wrong model, or long sessions—or you’ll only say vaguely “Copilot got expensive.”
2. Enterprises
Large software orgs. Pooled credits ease “idle seats vs spikes”: per-seat allowance can be shared org-wide. Before, $19/seat with $19 credits wasted unused capacity; after pooling, platform teams can steer credits to high-output work. Side effect: internal politics over which cost center gets quota—like fighting over reserved instances or GPU quota.
Finance and procurement. AI coding moves from fixed seat Opex to seats + variable inference Opex. Quarterly forecasts can’t be seats × price only; they need an inference elasticity factor or budgets systematically miss. Jun–Aug promotional credits on Business/Enterprise are transition; long-term modeling must use published rates and p95/p99 usage. Showback/chargeback, alerts, dedicated line items become standard, not optional. Annual individual users get special rules in transition—enterprise negotiators should demand clear switch windows and cap policies, not contract language from the “unlimited premium requests” era.
Engineering management. Enterprise / cost center / user budgets, and hard cap vs paid overage when the pool empties, are governance, not personal habit. Regulated industries (finance, health, government contractors) globally care about data residency, model routing, audit logs; token billing makes who used what, which model, how much more auditable—and more likely to trigger approval flows, aligned with shadow AI controls. Security may welcome metering; engineering fears approval drag—orgs that tier “allowed to use” vs “allowed to use this much” beat blanket shutdown.
Startups vs large enterprises. Startups: few seats, high agent intensity, volatile per-capita burn. Large enterprises: many seats, extreme power law—few power users eat the pool—same shape as cloud. Outsourcing and consulting on fixed SOW without agent cost in the model erodes margin.
DevOps intersection. Review consumes Actions minutes; FinOps dashboards must show CI minutes + AI credits together—or “automated review” blows up on two bills.
Enterprise playbook:
- Before switch: 30-day baseline from May preview (p50 / p95 / p99).
- Default completion for all; agent budgets by role/project; no default most expensive model, full-repo agent.
- Model tiers (routine / complex / forbidden) and PR checks (must Review agent run?).
- For power users: quota + retrospective (was the task poorly sliced?)—not only cutoff.
3. Tension Between Developers and the Enterprise
Enterprises want cost control and auditability; developers want fewer interrupts and caps. Token billing moves that negotiation from platform backstop to inside the org—every global team faces the same trade: FinOps vs developer experience. No universal answer; a standard question: how much inference are we willing to pay for how much mergeable delivery?
Closing: From Magic to Engineered Resource
GitHub Copilot charging by token is not simply “getting more expensive.” It reframes AI-assisted coding as an engineered resource: metered, budgeted, and negotiable—like electricity. Programmer advantage keeps migrating from “producing code” to “designing verifiable delivery under hard constraints”—and one constraint is the inference bill.
When platforms sell tokens like cloud vendors, individuals and orgs should ask: how much thinking do you still reserve that isn’t priced by the meter? The completion track stays relatively generous; the agent track is explicitly priced. How you use both tracks is a contract every developer and every engineering org will renegotiate in the years ahead.
References
- GitHub Blog, GitHub Copilot is moving to usage-based billing (2026-04-27).
- GitHub Docs, Usage-based billing for individuals.
- GitHub Docs, Usage-based billing for organizations and enterprises.
- Cursor Blog, Clarifying our pricing (2025-07).
Note on fidelity: Dates, dollar amounts, and product names follow your source (including the June 2026 Copilot announcement framing). If any detail is still in flux on GitHub’s side, align figures with the linked docs before publication.
Leave a Reply