Copilot Goes Usage-Billed: Set AI Budgets Before Agents Scale

At GitHub Universe on October 28, GitHub changed how large organizations pay for Copilot. Enterprises working with a GitHub or Microsoft account team can now get Copilot included with GitHub Enterprise for every licensed user, and pay for the AI credits they actually use. In GitHub's words, "usage against your enterprise budget is the primary thing to manage." The same day, GitHub expanded Copilot automations, which run its cloud agent on schedules and repository events, and made GitHub Agentic Workflows generally available.

Put together, these changes move the cost and control questions for AI-assisted development away from "how many seats do we buy?" and toward "how much agent work do we allow, who triggers it, and who pays for it?" This post covers what changed, what GitHub's documentation says about budgets and defaults, and what platform and engineering leaders should set up before usage grows.

What changed in Copilot pricing

Under the new "Copilot access" model, users with a GitHub Enterprise Cloud license pay no Copilot seat charge. Users in the enterprise without that license can get the same access through Copilot Standalone at $10 per user per month. Both have the same features and models as Copilot Enterprise, but neither includes the monthly AI credits that Copilot Enterprise seats carry. GitHub's documentation is direct about it: there is "no included usage allowance," so metered billing starts with the first use.

Some details matter for planning:

• Availability is limited for now. The model is available to account-team customers on GitHub Enterprise Cloud from October 28. Self-serve customers can't use it yet; GitHub says it is "coming in stages."
• It's all or nothing per enterprise. An enterprise can't combine Copilot access with Copilot Business or Enterprise seats, even in separate organizations, because "the billing model applies to the whole enterprise." Switching is voluntary, and transitions take effect on the first day of a month.
• Access is not automatic. Enterprise owners still have to assign Copilot seats to members, teams or organizations, including users who already hold GitHub Enterprise Cloud licenses.
• Network allowlists may need an update. Copilot access uses the Enterprise endpoint, so organizations that only allow *.business.githubcopilot.com need to add *.enterprise.githubcopilot.com.

How AI credits and budgets work

GitHub's billing documentation sets one AI credit at $0.01, with usage based on tokens consumed and the model used. A $10 budget covers 1,000 credits. For comparison, existing Copilot Business seats include 1,900 credits per user per month and Copilot Enterprise seats include 3,900, pooled across the organization or enterprise and reset at 00:00 UTC on the first of each month. Unused credits don't carry over.

Not everything draws on credits. Inline code completions and next edit suggestions are not billed in AI credits and keep working even with a $0 budget. Copilot Chat, Copilot CLI, the cloud agent, code review and third-party coding agents do consume credits. GitHub also says "an exhausted budget never removes access": seats and non-metered features remain when the money runs out.

Spending can be controlled at several levels: user-level budgets, cost-center budgets, organization budgets and enterprise-wide spending limits. Two settings deserve attention:

• A spending limit is only enforced if "Stop usage when budget limit is reached" is enabled on it.
• The "AI credits paid usage" policy is on by default. Under Copilot access it must stay on for credit-consuming features to work at all, so budgets, not that policy, are your control.

Agents that run on their own add a new cost driver

Credit-based billing matters more because more Copilot work now happens without a developer at the keyboard. Copilot automations run the cloud agent on a schedule, on repository events such as an issue being created or a pull request being opened, or through an API call. On October 28 GitHub added 24 more event triggers, including security alerts, plus API triggers that let outside systems start runs, and the option to chain automations together.

According to GitHub's documentation, each automation run uses AI credits and GitHub Actions minutes. Personal automations bill credits to their creator; shared automations bill the organization that owns the repository. Optional credit limits can be set per run (minimum 30 credits) or per day, week or month. Two caveats are easy to miss: period limits don't stop a run already in progress, and, per the changelog, "automations without limits continue to run as they do today."

Governance details matter too. Anyone with write access to a repository can create an automation there. Shared automations act as Copilot's identity, while personal ones act as their creator. Automations aren't stored in Git, so they aren't versioned or reviewed through pull requests. GitHub's tools are scoped to a single repository, but tools from custom MCP servers can reach whatever that server's credentials allow. Some defaults help: events from users without write access are ignored, which reduces prompt-injection risk, and workflows on automation-opened pull requests don't run until someone with write access approves them. Chained triggers default to firing only on user activity unless you change that setting.

Agentic Workflows: the reviewable option

For teams that want agent automation under change control, GitHub Agentic Workflows, now generally available, takes a different approach. Each workflow is written in Markdown and compiled into standard GitHub Actions YAML, so it lives in the repository, goes through normal review, and runs on your existing runner groups and policies. Agents run with read-only permissions by default, in a sandboxed container behind a firewall, and proposed changes pass through a "safe outputs" process and a threat detection job before they're applied. The gh aw forecast command now reports monthly spend ranges. Using the default Copilot CLI engine requires a Copilot license.

A reasonable rule of thumb: use automations for quick, personal or low-risk tasks, and move anything that writes code, touches several repositories or runs on a schedule at scale into Agentic Workflows, where it is versioned, reviewed and constrained.

Checklist: what to do before you scale up

1. Estimate before you switch. GitHub's guidance is to compare current license and metered charges against what your usage would cost with no included allowance, plus $10 per Standalone user. Use current usage metrics, not seat counts.
2. Set budgets with enforcement on. Configure enterprise spending limits and cost-center budgets, and confirm "Stop usage when budget limit is reached" is enabled where you need a hard stop.
3. Map cost centers to teams. Attribute AI spend to the groups that generate it, so engineering leaders own their consumption.
4. Inventory automations. List shared and personal automations, require per-run and monthly credit limits, and review any with API triggers or chaining enabled.
5. Review MCP server credentials. Anything an automation can call through an MCP server is limited only by that server's access. Scope those credentials tightly.
6. Move durable agent work into code. Put recurring, write-capable agent tasks into Agentic Workflows so they go through pull request review.
7. Update network allowlists and seat assignments before any transition date, so developers aren't locked out on day one.

The bottom line

GitHub's October changes make Copilot easier to roll out across an enterprise and harder to budget by headcount. The organizations that benefit will be the ones that treat AI usage like cloud spend: metered, attributed, capped and reviewed. Baygramm's DevOps practice helps teams set up CI/CD governance, cost controls and review processes for agent-driven automation, and our AI automation team helps decide which work belongs with agents in the first place. If you're weighing a move to usage-based Copilot, talk to us.