Series: The Copilot Stack, Part 2 of 9
On September 1, 2026, every Copilot Business and Enterprise credit pool shrinks by more than a third. The setting that decides whether anyone notices is switched off by default.
If you only have a minute:
This is the easiest Copilot to defend to a CFO, because the output is checkable. Code either compiles and passes tests or it doesn't. No other product in this portfolio gets that.
The 2023 mental model is wrong. Most executives still picture line-by-line autocomplete. The current product researches a repository, writes a plan, makes the changes on a branch, and opens a pull request on its own.
A pooled credit system now sits underneath the whole thing, and most organizations haven't looked at it. AI credits are shared across every licensed user in the org, not metered per person.
The included pool is about to shrink. Business and Enterprise customers are on a promotional credit amount through August 31, 2026. On September 1, both plans drop back to their standard, smaller allowance.
Spending limits don't actually stop spending by default. GitHub ships four budget controls, and the one that turns an alert into a hard stop has to be switched on manually, one limit at a time.
Don't judge this product from the free tier. The free plan has no cloud agent and no ability to connect outside tools, so a free-tier trial only ever tests the least differentiated third of what you'd actually be buying.
Part 0 mapped the portfolio. Part 1 spent its length on Microsoft 365 Copilot and the permissions work that decides whether it earns its keep. This post covers the developer layer: GitHub Copilot, the oldest product in the stack and the one where "what does it actually do now" has drifted furthest from what most executives picture.
GitHub Copilot produces the most observable, checkable output of anything in this portfolio. It also now runs on a shared, pooled billing system that behaves nothing like a per-seat subscription.
What it actually is
GitHub Copilot splits into two categories, and only one of them is metered.
Unmetered, unlimited on every paid plan: code completions as you type, plus next-edit suggestions that predict where you'll edit next. Neither is billed by usage at all.
Metered, billed in GitHub AI credits: Copilot Chat, the command-line tool, and the cloud agent (formerly called the coding agent), which is what the rest of this post is about.
One AI credit equals one cent. Every interaction with Chat, the CLI, or the agent sends text to a model and gets text back, and GitHub prices that exchange by the model used and converts the result into credits. A quick chat question on a lightweight model can cost a fraction of a credit. A long cloud agent session running a frontier model across several files costs many, because it's doing more work on a more expensive model.
Give the cloud agent a task and it works through it without anyone sitting with it in an editor:
Researches the relevant part of the repository
Writes an implementation plan
Makes changes on a new branch
Opens a pull request when it's done
Every step lands as a commit, visible in the log and reviewable by anyone on the team. This is where the real precondition in this post lives, and it isn't limited to the agent: any time spent in Copilot Chat or the CLI draws from the same pool.
Completions make typing faster and never touch the credit pool. Chat, the CLI, and the cloud agent all draw from it, and the agent draws the most. A budget or an evaluation built only around typing speed misses both the actual argument for buying this product and where the spend goes.
What job it does on an ordinary Tuesday
The 2023 picture
A developer writes a comment or starts a line, Copilot suggests the rest, the developer accepts or edits it, and the loop repeats. Useful, measurable in a rough way, but every step after the suggestion, the branch, the commit, the pull request description, the review request, still belongs to a human.
The 2026 picture
A developer, a product manager, or an automation triggered by a new issue can assign a task to the cloud agent:
Fix a bug
Add a small feature
Raise test coverage on a module
Resolve a merge conflict
Update documentation
The agent works in the background. It can be started from the agents panel on GitHub.com, from a comment that mentions @copilot on an existing pull request, from Visual Studio Code, or on a schedule that fires automatically when an issue is opened.
What comes back is a pull request with a real diff, a description, and a commit history a reviewer can actually read. The workflow around the model moved from a local, synchronous pairing session to something that runs on GitHub itself, visible to the whole team as it happens.
That shift comes with real limits. Each cloud agent session has a hard cap of fifty-nine minutes, with no way to extend it. It works on one repository and one branch at a time, and opens exactly one pull request per task. It only reaches repositories hosted on GitHub itself. Assign it work sized for an afternoon, not a quarter.
What it inherits
Every product in this series inherits something the demo doesn't show. For GitHub Copilot, codebase quality is one precondition, and it shows up in how good the agent's suggestions are. The bigger precondition is the billing model behind the agent, which the per-seat price doesn't show.
The pool is shared, not personal
Copilot Business and Copilot Enterprise no longer meter each person's usage against their own private allowance. Every licensed user's included AI credits, the ones that fund Chat, the CLI, and the cloud agent, get pooled at the organization or enterprise level instead. A hundred Business seats don't produce a hundred separate buckets. They produce one shared pool that any of the hundred people can draw from. Someone running long cloud agent sessions against a large codebase, or someone who lives in Copilot Chat all day, can pull far more than their individual share, while a light user effectively subsidizes them without knowing it. That's a deliberate design choice.
The pool can run dry three weeks into the month before anyone checks the usage dashboard.
The pool is about to get smaller
Business and Enterprise customers already using Copilot are on a promotional credit allowance through August 31, 2026. On September 1, the pool drops to its standard size automatically, no action required to trigger it:
Copilot Business: 3,000 AI credits per seat now, dropping to 1,900, a cut of roughly a third
Copilot Enterprise: 7,000 AI credits per seat now, dropping to 3,900, a cut of closer to half
Both are pooled at the org or enterprise level, not held per person. An organization that sized its usage against the promotional pool is about to find out what the standard number looks like.
The safety net is off unless someone turns it on
GitHub gives administrators four budget controls:
A universal per-user limit that applies to everyone automatically
Individual overrides for known heavy users
An enterprise-wide spending cap for whatever runs past the pool on pay-as-you-go pricing
A hard-stop toggle that turns any of those limits from a notification into an actual stop
The fourth one is off by default. Without it, hitting a spending limit sends an email. It doesn't stop the spending: charges keep accruing on metered usage until someone manually intervenes. The first three controls exist to keep one heavy user or one long agent run from draining the shared pool before the rest of the team gets to use it. None of that protection works until the fourth one gets switched on.
What it takes to run
The technical lift here is genuinely small. The organizational lift is four settings changes, and the most important one takes five minutes.
Set the universal per-user budget above the per-seat price, not at it. Setting it at exactly $19 or $39 defeats the pooling: it recreates a hundred separate personal buckets instead of one shared pool that flexes to where the work actually is.
Turn on "stop usage when budget limit is reached" on every limit you create. This is the one step that converts a spending alert into an actual guardrail, and GitHub's own documentation is explicit that skipping it leaves you with alerts only.
Enable the cloud agent policy if you're on Business or Enterprise. Unlike completions, it doesn't turn on for licensed users automatically; an admin has to flip it on, and individual repository owners can opt specific repos out.
Don't evaluate the product from the free tier. Copilot Free caps completions at 2,000 a month and has no cloud agent and no ability to connect outside tools to it at all. It's a legitimate way to see whether developers like the suggestions. It cannot show you a pull request the product opened on its own, which is the actual argument for buying it.
What it costs, and is it worth it
Pricing by seat:
Copilot Pro: $10/month, individual
Copilot Pro+: $39/month, individual
Copilot Max: $100/month, individual
Copilot Business: $19/user/month, organizations
Copilot Enterprise: priced per organization, higher than Business
Completions are unlimited on every paid tier. The cloud agent and other AI-model features draw from the pooled credits described above.
The verdict, in fit terms:
Buy now if your engineers already want this and someone is willing to own the four budget settings before the September 1 reset. The capability is real, the checkable output is real, and the governance tools that make it safe at scale already ship with the license.
Wait only if you have no one who can own budget configuration. A pool with no hard stop just means the rollout needs an owner before it needs more seats.
Skip is rarely right here. This is the layer in the whole portfolio where the value is easiest to point to and the output is easiest to check. If anything in this series is worth the seat price on capability alone, it's this one.
The Monday checklist
Four things an engineering or platform lead can do this week, before the September 1 credit reset.
Set a universal per-user budget above your per-seat price, so pooling still works instead of quietly recreating individual buckets.
Turn on "stop usage when budget limit is reached" on every limit you create. This is the step that makes any of it a real guardrail.
Pull your current AI credit usage and compare it to the standard, post-September allowance, not the promotional one you've been running against.
Confirm the cloud agent policy is deliberately on or off, not just left at whatever the default happened to be when your org enrolled.
What comes next
Part 3 covers Security Copilot, the best teaching example in the series so far: an unusual precondition in what it can see, an unusual meter in what it costs, and a default access grant that arrives automatically the day your license upgrades, whether your security team asked for it or not.
References
GitHub Docs, "About GitHub Copilot cloud agent," workflow, entry points, limitations (59-minute session cap, one repository/branch/PR per task, GitHub-hosted repositories only).
GitHub Docs, "GitHub Copilot licenses," per-plan pricing (Pro $10, Pro+ $39, Max $100, Business $19/seat), completions unlimited on paid plans, Free plan scope, 1 AI credit = $0.01 USD.
GitHub Docs, "Usage-based billing for organizations and enterprises," pooled AI credits, what's billed (Chat, CLI, cloud agent, Spaces, Spark) versus what isn't (completions, next-edit suggestions), token-and-model pricing behind each credit, standard amounts (1,900 Business / 3,900 Enterprise per seat), promotional amounts (3,000 / 7,000) through August 31, 2026, no rollover.
GitHub Docs, "Getting started with budget controls," the four budget controls, universal user-level budget guidance, "Stop usage when budget limit is reached" default-off behavior.
GitHub Docs, "Plans for GitHub Copilot," Free plan feature table: 2,000 completions/month, no cloud agent, no MCP, auto model selection only.
Product capabilities, licensing terms, and pricing in this post were verified against GitHub's own documentation on 19 August 2026. The AI-credit billing model described here is mid-transition through a promotional period ending September 1, 2026. Check before you sign anything.* --- *Matthew Kruczek is Managing Director at EY, leading Microsoft domain initiatives within Digital Engineering. Connect with Matthew on LinkedIn to discuss how your organization should approach the Copilot portfolio.