GitHub Copilot Automations: the AI that works on your repo by itself and what it costs
GitHub Copilot Automations run tasks in the cloud when an event happens in your repo. The cost per run, the limits, and Agent Merge.
GitHub Copilot Automations are tasks you write once and Copilot runs in the cloud when an event happens in your repository, visible to your whole team. GitHub started rolling them out on October 28, 2026, at GitHub Universe. On my own assumption, each run costs about $0.43 (43 credits); here is the math, how to set them up, and where they break.
What changed with GitHub Copilot Automations
Until now, Copilot waited for you to ask it for something. Now an automation runs by itself when an event happens. Alongside them came 24 new triggers, 20 new tools, connections to your own MCP servers, spending limits, and Agent Merge, which watches a pull request until it's ready to merge.
The problem they're attacking is an old one: a Chainguard survey of 1,200 people (from a vendor, mind you) says engineers spend only 16% of their week writing new code; the rest is maintenance.

How it works inside
An automation has three pieces: a prompt, a trigger (a GitHub event, a schedule, or an API call from Jira, Sentry, or PagerDuty), and a list of tools you approve one by one. Copilot works in the cloud even when your computer is off.
The piece almost nobody mentions: usage is billed to the repository owner, not to whoever created the automation. And when you create one, you choose between personal and shared, and that choice can't be changed later.
How to set up an automation step by step
This comes from GitHub's documentation; it wasn't run on your repository.
- You need a paid Copilot plan and write access to the repo.
- Go to github.com, the Copilot app, or Visual Studio Code (version 1.44 and the cloud automations setting).
- Pick the type: shared, knowing there's no going back.
- Define when it runs and write the prompt: what to do, when to stop, and what to hand back.
- Approve only the tools you need.
- Set credit limits per run, per day, and per month.
If the repo belongs to an organization, an admin has to turn on the policy that lets the agent bill the organization; without it, it won't run. Run it ten times before you share it.
The math: how much a Copilot Automations run costs
My assumption: a run reads 100,000 fresh tokens, 300,000 cached ones, and writes 20,000. At the Claude Sonnet 5.5 rate GitHub publishes, that's $0.20 for input, $0.03 for cache, and $0.20 for output: $0.43, or 43 credits (one credit is worth one cent).

For a team with 80 issues a month that need reproducing: 80 × $0.43 = $34.40. By hand, at 15 minutes each, that's 20 hours; with the hour at $50 (another assumption), $1,000: almost 30 times more. The break-even point is 31 seconds: if a run doesn't save you that, it's not worth it.
| Plan | Included credits | $0.43 runs | | --- | --- | --- | | Pro | 1,500 | 34 | | Business | 1,900 per seat | 44 | | Enterprise | n/a | 90 | | Pro Plus | n/a | 162 | | Max | n/a | 465 |
The 43 is an assumption, not a measurement from GitHub: the docs don't give a typical cost.
Three uses for your team
Reproducing bugs. You label an issue "needs repro" (one of the 24 new triggers); the automation reads the report, tries to reproduce the error in its sandbox, and comments the steps that worked or what data is missing.
Visual tests on pull requests. When someone marks a PR ready for review, it starts the app, captures the screens that changed, and uploads them to the pull request with one of the new tools. With one line in the prompt to compare against the previous version, the screenshot becomes evidence.
Agent Merge (not an automation). For that approved pull request stuck on a failed workflow or a merge conflict, you choose "watch and fix" in the merge box; Copilot works in the cloud when the blocker appears, and you can combine it with auto-merge.
Who it's not for
- The free Copilot plan: automations start at Pro.
- Code that isn't on GitHub: Copilot only works with repositories hosted there.
- Public projects: the docs say they run on eligible private and internal repositories; check before you plan.
The objection and what they don't tell you
"An agent that fires itself is a bottomless bill and an open door." Without limits, it is. But GitHub has credit limits per run, per day, per week, and per month: when a run hits its limit, it stops. The objection wins if the trigger is text from strangers (public issues, which go in as instructions; no filters GitHub applies were found) or if anyone with write permission can edit a shared automation. Advice: a per-run limit first, and no triggers open to the public.
On "they learn from their results and improve themselves": GitHub says so in its changelog. It reads signals (whether its labels were changed, whether its comments were accepted, whether its PRs were merged) and proposes changes to its own prompt, tools, or triggers; you accept or reject each one. But there isn't a single published number for how many proposals it gets right. The page also doesn't say whether shared automations are in preview or generally available. Treat it as a promise and measure the acceptance of its comments yourself for a month.
What breaks in practice
- Sessions that run on Actions last 59 minutes at most, open one pull request per task, and work in a single repository per run.
- Sandbox and Actions compute burns a separate monthly allowance, and sandbox billing starts in November.
- Included credits don't roll over: on the 1st of every month they go back to their cap.
- A run stopped because it hit its limit isn't a failure: it's the limit working.
How to apply it in your business?
Five steps: 1) start with a single automation; 2) set a per-run limit of 60 credits (40% above what you expect); 3) a monthly limit of 3,500 credits ($35); 4) measure ten real runs and swap my 43 for your average; 5) if a run doesn't save you 31 seconds, turn it off. To see how cost per task works for another Copilot feature, read the full breakdown of GitHub Copilot Fusion.
Frequently asked questions
What is GitHub Copilot Automations?
Tasks with a prompt, a trigger, and approved tools that Copilot runs in the cloud when an event happens, visible to the whole team.
How much does a run cost?
With my own token assumption and the Claude Sonnet 5.5 rate GitHub publishes, about $0.43 (43 credits). GitHub doesn't give a typical cost.
Who pays?
The repository owner, not whoever created the automation.
Which plan do I need?
A paid Copilot plan (Pro and up) and write access to the repo.
Conclusion
The news with GitHub Copilot Automations isn't that Copilot does more, it's that it no longer needs you to ask. The real question is which task in your week already has a trigger. Start with one, with limits, and measure before scaling.