Until last week, cost was the one thing a Copilot Automation had no setting for. An automation is a prompt plus a trigger plus a set of tools, and it runs whenever its trigger fires. It doesn't wait for a person to open a chat window.
On October 28, GitHub added a cost control. It also shipped a long list of new ways for automations to start, including other automations. Taken together those two changes decide what your agent spend looks like for the rest of the year, and the cost control is off unless someone turns it on.
What GitHub shipped on October 28
The changelog post covers three things: triggers, tools and cost controls (GitHub Changelog, October 2026).
Triggers. 24 new GitHub events can start an automation. They span issues (assigned, labeled, closed, reopened, status changed, sub-issue added), pull requests (ready for review, merge conflict, review submitted, converted to draft and more), discussions, and security alerts from code scanning, secret scanning and Dependabot. Automations can now also be triggered through the REST API from any external system, and GitHub's own examples are Jira tickets, Sentry issues and PagerDuty incidents.
Chaining. Every trigger now has a "Can be triggered by" setting. It defaults to Only users. Set it to Users and Copilot and events caused by other automations fire it too, such as a pull request opened by Copilot. There are also new Automation run succeeded and Automation run failed triggers, so one automation can start when another finishes.
Tools. 20 new GitHub tools, including retrying workflow runs and merging pull requests, plus tools from custom MCP servers.
Cost controls. You can set any combination of optional AI credit limits on an automation:
| Limit | What happens when it's hit |
|---|---|
| Per run | That run stops |
| Daily, weekly, monthly | New runs don't start until the period resets |
One sentence in the post does more work than the rest: "Automations without limits continue to run as they do today." So no limit is the default. Automations are available on Copilot Pro, Pro+, Max, Business and Enterprise, and you can create one in any repository where you have write access.
Why does an opt-in limit matter so much here?
Our read is that the default runs the wrong way for an org. Every automation an engineer creates ships with no ceiling. Adding one is something each author has to remember, on each automation. The changelog doesn't describe an org-wide or enterprise-wide default limit for automations, so as far as we can tell from the announcement, the number of uncapped automations in your org equals the number nobody went back and capped.
That matters because of how the credits are paid for. One AI credit is $0.01. Copilot Business includes 1,900 credits per user per month and Copilot Enterprise 3,900, and those allowances are pooled at the billing entity level. The pool resets on the first of the month at 00:00 UTC (GitHub Docs, Copilot billing for organizations and enterprises, retrieved 2026-11-03).
A pool is shared, so an uncapped automation in one repository spends the same credits as every developer's chat sessions in every other. Nothing in the bill says "this was the triage bot". We covered the mechanics in cost centers and AI credit pools.
The new GitHub Enterprise model makes this sharper. Copilot access included with GitHub Enterprise has no included allowance, and usage is metered from the first request. There's no pool to absorb an automation's spend before real money moves. Our breakdown of that change is in GitHub Enterprise now includes Copilot.
Which limit stops which failure?
The four limits look interchangeable, but they guard against different failures. Here's our analysis of the three ways an automation's spend gets away from you, and which limit actually bounds each one.
A per-run cap doesn't stop a loop
This is the part worth reading twice. A per-run limit stops one run. It does nothing about how many runs start.
Now combine the new pieces. Automation A opens a pull request. Automation B is set to Users and Copilot on "pull request opened", so A's pull request fires it. B retries a workflow run, the run fails, and Automation run failed starts C to investigate. If C's output can fire A again, you've built a cycle, and every lap is a fresh run with a fresh per-run budget.
We're not claiming GitHub lacks loop protection. The changelog just doesn't describe any, and the cost controls it does describe are per automation. On that evidence the only thing that bounds the total is a daily, weekly or monthly limit on each automation in the chain. Leave one of them uncapped and that one sets the ceiling, which is no ceiling.
A monthly limit is also an uptime setting
The period limits have a cost of their own. Hit a monthly limit on the 12th and that automation does nothing until the 1st. The changelog says new runs "won't start". It doesn't describe a notification to the author when that happens.
That's fine for a nice-to-have, like a weekly digest of stale issues. It isn't fine for anything someone has started to rely on, such as triaging incoming security alerts. Ask the question before you set the number. If this automation stops for two weeks, who notices, and what breaks? If the answer is "nobody" and "nothing important", a monthly limit is the right tool. Otherwise a daily or weekly limit fails sooner, smaller and more visibly, which is usually what you want.
Agentic Workflows went GA the same day, on two meters
GitHub Agentic Workflows, the open source project from GitHub Next, also became generally available on October 28 (GitHub Changelog, October 2026). You describe the task in natural-language Markdown and it compiles into standard GitHub Actions YAML. It runs on your existing runner groups under your existing policies, powered by Copilot or a coding agent you bring yourself.
Because these are Actions workflows, every run spends runner minutes as well as AI credits. That's the same two-meter shape we described for Copilot code review approvals, and it means a budget on one meter says nothing about the other. If Actions spend is already the line nobody reads, our piece on Actions costs hiding in plain sight covers where it tends to go.
The good news is in the GA notes. gh aw forecast is no longer experimental. It now includes threat-detection credits and monthly ranges, which matters because each workflow carries a dedicated threat-detection job that scans proposed changes before they're applied. That job spends credits too, and it'd be easy to leave it out of a back-of-envelope estimate. Workflows can also use a model router that picks by task type and difficulty.
Two availability details: Agentic Workflows run on GitHub Free, Team and Enterprise, and the default Copilot CLI engine needs a Copilot license.
Our finding: we can't tell an automation's credits apart from a person's in the data we read. FinOpsAid pulls the per-user AI credit figure GitHub exposes, which is a single daily number per person with no model or feature breakdown. An automation created by an engineer doesn't show up as its own line in that data. It shows up, as far as our data can tell, as that engineer having a heavier day. So a runaway automation can look exactly like one developer suddenly using Copilot a lot, and the only record that it's an automation is its configuration. That's a real limit of reading usage from outside, and it's the strongest argument we know for setting limits at the source rather than hoping to spot the problem afterwards.
What to do this week
- List every automation in your org and note which have no limit. No limit is the default, so assume each one is uncapped until you've checked.
- Give every automation a per-run limit and a daily or weekly limit. The per-run limit catches one run that won't stop. The period limit catches a chain of short ones.
- Audit every trigger set to "Users and Copilot". Each is a place where one automation can start another. Draw the chain on paper and look for a cycle.
- Be careful with "Automation run failed" triggers paired with retry tools. A failure that triggers a retry, which fails and triggers another, is the simplest loop to build by accident.
- Choose monthly limits per automation, not as a blanket rule. For anything that matters, a smaller daily or weekly limit fails sooner and is easier to notice.
- Run
gh aw forecastbefore you enable an agentic workflow. Then budget the Actions minutes separately, because they come off a different meter. - Pair automation limits with per-user budgets. User-level budgets always hard-stop, as we covered in GitHub budgets can now expire. Automation limits shape one automation. The user budget bounds the person behind all of them.
Where FinOpsAid fits
FinOpsAid reads your GitHub org read-only and shows AI credit consumption per user, per team and per cost center against your allowance, next to the rest of the GitHub bill. Three limits are worth stating plainly. First, as above, the per-user AI credit figure we read is a single daily number with no model or feature breakdown, so we can't separate an automation from its author. Second, we sync nightly, and GitHub's own Copilot metrics lag roughly two to three days, so nothing here is real-time. Third, we're read-only, so we can flag a jump in someone's daily credits but can't stop it. That's exactly why the automation's own limit matters. Related reading: what actually consumes GitHub AI credits and how to read the Copilot page.
Frequently asked questions
Do Copilot Automations have an AI credit limit by default?
No. GitHub's October 28, 2026 changelog says automations without limits "continue to run as they do today", so a limit applies only if someone sets one. You can set any combination of per-run, daily, weekly and monthly AI credit limits on each automation when you create or edit it.
What happens when a Copilot Automation hits its AI credit limit?
It depends on the limit. If a run reaches its per-run limit, that run stops. If the automation reaches a daily, weekly or monthly limit, new runs don't start until the period resets. A monthly limit reached early in the month can leave an automation idle for weeks.
Do GitHub Agentic Workflows use AI credits or Actions minutes?
Both. Agentic Workflows compile into standard GitHub Actions YAML and run on your runners, so each run spends runner minutes as well as AI credits for the coding agent. GitHub's gh aw forecast command, generally available since October 28, 2026, estimates the AI credit side, including threat-detection credits and monthly ranges.
Sources
- GitHub, "New tools, triggers, and cost controls for Copilot Automations", retrieved 2026-11-03, https://github.blog/changelog/2026-10-28-new-tools-triggers-and-cost-controls-for-copilot-automations
- GitHub, "GitHub Agentic Workflows generally available", retrieved 2026-11-03, https://github.blog/changelog/2026-10-28-github-agentic-workflows-generally-available
- GitHub Docs, "Copilot billing for organizations and enterprises", retrieved 2026-11-03, https://docs.github.com/copilot/concepts/billing-and-usage/organizations-and-enterprises/billing
- GitHub Docs, "Creating automations with Copilot cloud agent", retrieved 2026-11-03, https://docs.github.com/copilot/how-tos/use-copilot-agents/cloud-agent/create-automations
If you want to see per-user AI credit consumption against your allowance before you decide which automations need a ceiling, connect your GitHub org — read-only and free during beta — or explore the demo dashboard first.