Manu Shukla

Posted on Jul 18 • Originally published at ecorpit.com

GitHub Copilot cost control in 2026: cap agent bills with credit pools and budgets

#githubcopilot #aicredits #finops #developerproductivit

GitHub Copilot cost control in 2026: cap agent bills with credit pools and budgets

Summary. On June 1, 2026, GitHub Copilot stopped counting premium requests and started billing on GitHub AI Credits, charged by input, output and cached tokens at each model's published API rate. Base seat prices did not move: Copilot Pro stays $10/month, Pro+ $39/month, Business $19/user/month and Enterprise $39/user/month, and each seat now includes that same dollar value in monthly credits. Business and Enterprise seats also carry promotional included usage of $30 and $70 per month through June, July and August 2026. The risk is not the seat; it is what happens after the included pool runs out, because one autonomous agent session can burn credits at a rate a single chat never could. Between June 24 and July 2, 2026, GitHub shipped three controls that fix this: universal user budgets, per-user budgets scoped to a cost center, and AI credit pools that stop a cost center from spending credits another team paid for. This guide shows platform and FinOps teams how to combine them.

What actually changed on June 1, 2026

For three years, Copilot metered "premium requests." A quick question and a multi-hour agent run could cost the same. GitHub's Chief Product Officer, Mario Rodriguez, put the problem plainly in the April 2026 announcement: "Today, a quick chat question and a multi-hour autonomous coding session can cost the user the same amount." Agentic usage is now the default, and it carries much higher compute demand, so that flat model was retired.

Under usage-based billing, every Copilot plan includes a monthly allotment of GitHub AI Credits. Credits are denominated in US dollars: a $19 Business seat includes $19 of credits, a $39 Enterprise seat includes $39. Consumption is calculated on token usage, counting input, output and cached tokens, at the listed API rate for whichever model handled the request. Pick a heavier reasoning model and the same task drains more credits than a lightweight one would.

Two exemptions matter. Code completions and Next Edit suggestions stay included on every plan and never touch AI Credits, so day-to-day autocomplete is not what moves your bill. Copilot chat, agent mode and coding agents do consume credits. Separately, Copilot code review now also consumes GitHub Actions minutes on top of AI Credits, billed at the same per-minute rate as any other Actions workflow, so review automation shows up in two line items.

One safety net is gone. Before June 1, a user who exhausted premium requests could fall back to a lower-cost model and keep working. That fallback no longer exists. Usage is now governed by available credits and admin budget controls, which is exactly why the controls below are no longer optional.

How AI Credits burn, and where the bill comes from

The included pool is the first thing spent. Every seat's monthly credits go into a shared enterprise pool, and that pooled included usage is drained before anyone is charged a rupee or dollar of additional spend. Pooling removes stranded capacity: a light user's unused $19 helps fund a heavy user on the same business, instead of expiring seat by seat.

Once the pool is empty, additional usage is billed at published rates at the end of the month, but only if an admin has set an additional spending budget above zero. If no additional budget is allowed, work stops at the pool boundary rather than generating a surprise invoice. That single default is the difference between a predictable bill and an unbounded one.

The blast radius is the agent. An autonomous session that reads a repository, plans, edits across many files and iterates can issue thousands of tokens per step across dozens of steps. A developer running several such sessions a day on a premium model can consume many times a single seat's $19 or $39 of included credits. Multiply that across a 200-engineer platform org and the additional-usage tail, not the seat count, becomes the number your CFO asks about.

Copilot plan	Monthly seat price (2026)	Included AI Credits	Promotional credits, Jun–Aug 2026
Copilot Pro	$10/month	$10	Not applicable
Copilot Pro+	$39/month	$39	Not applicable
Copilot Business	$19/user/month	$19	$30/month
Copilot Enterprise	$39/user/month	$39	$70/month
Additional usage (all paid)	Metered	Published API token rates	Governed by budgets

The promotional $30 and $70 figures apply to existing Business and Enterprise customers automatically for June, July and August 2026. Plan for them to end: an Enterprise seat that comfortably fits inside $70 of included credits this quarter may cross into additional spend once the allowance returns to $39 in September 2026.

The three layers of Copilot spend control

GitHub's spend controls stack from broad to specific. Read them as three concentric rings, and set a default at each ring.

The outer ring is the enterprise budget. It caps total additional usage for the whole enterprise once the included pool is gone. Leave it, and additional usage either runs at published rates or is blocked, depending on how you configure it. This is your absolute ceiling.

The middle ring is the cost center. A cost center groups users or enterprise teams for chargeback. As of July 2, 2026, a cost center can carry two distinct controls. An AI credit pool caps how much of the enterprise's included credits that cost center can draw, so a group never spends more included credits than its own assigned Business and Enterprise licenses fund. A cost center budget is separate and governs the metered phase, capping charges after the included pool is exhausted. You can apply both to the same cost center at once.

The inner ring is the user. User-level budgets went generally available on June 1, 2026 and, for AI Credits, they cap a person's total usage, not only their additional spend, so a budget can stop someone before the shared pool is even empty. A universal budget covers everyone; a cost-center user-level budget, shipped June 30, 2026, applies one per-user figure to every member of a cost center; and an individual override targets a single person.

Precedence runs from most specific to least specific. An individual user-level budget overrides a cost-center user-level budget, which overrides the universal budget. Set the universal budget as your floor, then override upward only where a team genuinely needs more.

Control	Scope	What it caps	Availability (2026)
Enterprise budget	Whole enterprise	Total additional usage after pool	Live
AI credit pool	Cost center	Share of included credits drawn	REST API, Jul 2
Cost center budget	Cost center	Additional (metered) spend	Live
Universal user budget	Every user	Total AI Credit usage	GA, Jun 1
Cost-center user budget	Users in a cost center	Total usage per member	REST API, Jun 30
Individual override	One user	Total usage for that user	Live

A step-by-step setup for a platform org

Here is a sequence that a platform or FinOps team can run in an afternoon on GitHub Enterprise Cloud.

Start by turning off silent overspend. Set the enterprise additional-usage budget to a deliberate number, or to zero if you want a hard stop at the included pool while you learn your real consumption. With the pre-June fallback gone, an unset budget is the only thing standing between an agent loop and an open-ended invoice.

Next, set a universal user budget. Give every developer the same monthly AI Credit ceiling, for example a modest figure that covers normal agent use. Because a user-level budget counts total usage for AI Credits, this also protects the shared pool from a single runaway account. Admins receive email as users approach their budgets, so this doubles as an early-warning signal.

Then model your chargeback with cost centers. Create one cost center per team, department or product line that you need to bill separately, and assign enterprise teams to it so membership stays in sync automatically. Turn on the AI credit pool for each cost center that contains at least one user or enterprise team. GitHub calculates the pool limit from the licenses assigned to that cost center and adjusts it as you add or remove licenses, so you never hand-maintain a number. Decide the cap behaviour per cost center: block further included usage at the cap, or let it continue as additional spend if your enterprise allows overages.

Override where the work demands it. Give a heavy team its own per-user figure with a cost-center user-level budget. GitHub's own worked example is a platform engineering team at $250 per user while everyone else stays on a $40 universal budget, set without touching one user at a time. As people join or leave that cost center or its enterprise team, budget coverage updates on its own.

Finally, wire up reporting. Since June 19, 2026, AI credits consumed per user are exposed in the Copilot usage metrics API, and GitHub improved the accuracy and coverage of usage metrics reports on July 2, 2026. Pull that data into whatever FinOps dashboard you already run. One scheduling note: the standalone Copilot Billing Preview app is being retired on August 3, 2026, so build your reporting on the metrics API and billing pages rather than that app.

A caution on the newest controls: both AI credit pools and cost-center user-level budgets are, as of early July 2026, configured through the REST API only, with billing UI support "coming soon." A platform team comfortable with the API can adopt them today; teams that need a UI should track the changelog before promising a delivery date.

Cut the burn, not just the ceiling

Budgets cap spend; they do not reduce it. Two levers lower the underlying consumption.

The first is model choice. Because credits track each model's published token rate, routing routine work to a cheaper model meaningfully changes the bill. GitHub keeps widening the model menu for exactly this reason: Kimi K2.7 Code reached general availability in Copilot on July 1, 2026, alongside heavier options, and enterprises can now default to automatic model selection so the platform picks a fit-for-task model instead of always reaching for the most expensive one. Our note on the decision to enable open-weight coding models in Copilot walks through when a lighter model is the right call, and the same logic behind an LLM hybrid routing framework for API spend applies inside Copilot.

The second is workflow discipline. Scope agent tasks tightly, avoid re-running large-context sessions when a targeted edit would do, and treat code review automation as a budget line because it also spends Actions minutes. The real cost is usually the loosely scoped agent run, not the autocomplete. Teams that already track model spend with the kind of tooling in our guide to free tools that measure LLM costs adapt to credit budgets fastest, and a shared token counter helps engineers feel the cost of context before they spend it.

India-specific considerations

For India's global capability centres and product teams, the shift lands hardest where Copilot rollouts are largest. A GCC running Copilot Business across a few thousand engineers is now managing a metered service, not a fixed per-seat line item, so finance needs the additional-usage tail modelled before the quarter, not after. Seats remain priced in US dollars, so budgets and chargeback should be reconciled against a dollar figure rather than a rupee SKU, and currency movement becomes one more input to the forecast.

Cost centers map cleanly onto how Indian delivery organisations already bill: per client account, per pod or per business unit. Turning on an AI credit pool per cost center keeps one account's agent enthusiasm from quietly drawing down credits that another account's licenses funded, which matters when usage is cross-charged to different clients. Teams that have worked through cloud FinOps for Indian teams will recognise the pattern: pool, cap, attribute, then optimise.

Common mistakes to avoid

Leaving the enterprise additional-usage budget unset is the big one, because the old model's fallback safety net is gone. Setting a universal budget but forgetting cost-center pools is the second: without pools, the shared included credits are first-come-first-served, and a heavy team can exhaust the pool before a lighter team touches it. Treating code review as free is the third; it spends Actions minutes as well as credits. And assuming the promotional $30 and $70 credits are permanent is the fourth, because they are scheduled only for June through August 2026.

FAQ

What replaced premium requests in GitHub Copilot?

On June 1, 2026, GitHub replaced premium request units with GitHub AI Credits across every Copilot plan. Credits are denominated in US dollars and consumed by token usage, counting input, output and cached tokens at each model's published API rate. Code completions and Next Edit suggestions stay included and do not spend credits.

Did GitHub Copilot seat prices go up in 2026?

No. Base seat prices held: Copilot Pro is $10/month, Pro+ is $39/month, Business is $19/user/month and Enterprise is $39/user/month. Each seat includes that same dollar value in monthly AI Credits. What changed is that usage beyond the included pool is now metered and billed at published rates if an admin allows it.

What is an AI credit pool for a cost center?

Shipped July 2, 2026, an AI credit pool caps how much of the enterprise's monthly included credits one cost center can draw. GitHub sets the limit automatically from the licenses assigned to that cost center. It stops a team from spending included credits that another team's Business and Enterprise licenses funded, keeping chargeback boundaries intact.

How do per-user budgets differ from a cost center budget?

A user-level budget caps a person's total AI Credit usage, including the included pool, so it can stop them before the pool is empty. A cost center budget caps only additional, metered spend after the pool is exhausted. Precedence runs individual override, then cost-center user budget, then universal budget.

Does Copilot code review cost extra now?

Yes. Since June 1, 2026, Copilot code review consumes GitHub Actions minutes in addition to GitHub AI Credits. The minutes are billed at the same per-minute rate as any other GitHub Actions workflow. Budget for review automation as two line items, credits and Actions minutes, not one.

How do I stop a runaway Copilot bill?

Set the enterprise additional-usage budget deliberately, or to zero for a hard stop at the included pool, because the pre-June fallback to a cheaper model is gone. Add a universal user budget, then AI credit pools and per-user budgets on cost centers. Choose block-at-cap rather than automatic overage while you learn real consumption.

Are the new controls available in the GitHub UI?

Partly. Universal user budgets went generally available on June 1, 2026. AI credit pools (July 2) and cost-center user-level budgets (June 30) are configured through the REST API only as of early July 2026, with billing UI support described as coming soon. API-comfortable platform teams can adopt both now.

What happens to the promotional Copilot credits after August 2026?

The promotional included usage of $30 for Business and $70 for Enterprise applies automatically for June, July and August 2026 only. After that window, included credits return to the base seat value of $19 and $39. Model your additional-usage tail for September 2026 so the change does not surprise finance.

How eCorpIT can help

eCorpIT is a Gurugram-based, senior-led engineering organisation, founded in 2021 and assessed at CMMI Level 5, that helps teams adopt AI coding tools without losing control of the bill. We set up Copilot cost centers, credit pools and budget hierarchies, wire the usage metrics API into your existing FinOps reporting, and tune model routing so routine work runs on the right-sized model. If you are rolling Copilot out across a large India or global team, talk to us about a spend-control review before your next billing cycle.