Playbooks · Small-team tasks
Share a Copilot Automation and cap its credits
Written November 2, 2026
Shared automations bill the repository owner and survive their creator leaving. Share the workflow, cap its credits, and check the admin policy first.
What changed
On 28 October 2026, GitHub started rolling out shared Copilot Automations. Until then, automations were personal: only their creator could see and edit them, and they used that person's identity and AI credits. That works for automating your own work, like drafting standup updates, but not for workflows a whole team relies on. A shared automation belongs to the repository instead: everyone with read access can see it, anyone with write access can edit it, AI credits are billed to the organization or user that owns the repository, actions on GitHub are attributed to Copilot rather than to any one user, and the automation keeps running if the person who created it leaves the team. Change history lets the team see how the tools, triggers, and prompt have evolved. Shared automations are rolling out to Copilot Pro, Pro+, Max, Business, and Enterprise plans, and availability may vary as the rollout progresses — "rolling out" is the status, not general availability for everyone on day one.
The same day brought the controls that make a shared automation safe to run: AI credit limits per run, day, week, or month, 24 more event triggers, a REST API trigger, automation chaining, 20 new GitHub tools, and tools from custom MCP servers. This page covers the sharing decision and the credit limits. The trigger and tool surface is covered only as far as the sharing decision needs it — a trigger list is not the subject.
Check the admin policy before you share
For a shared automation to run in an organization-owned repository, an administrator must enable the "Allow use of Copilot cloud agent billed to the organization" policy. That is a precondition, not a setting you can work around from inside the automation: without it, the shared automation does not run in that repository, however well it is written. Check it first, with the administrator, before promising the team a shared workflow. In a repository owned by an individual user, the same billing question applies in miniature — the credits bill the owner — but the organization policy does not arise.
Steps
- Pick one workflow the team already relies on. The sharing change is for workflows the whole team depends on — reproducing a bug as soon as an issue opens, investigating a production incident from a monitoring alert, capturing screenshots when a pull request is marked ready. A personal routine that only you use stays personal; sharing it adds editors and a shared bill for no gain.
- Create it as Shared — the type cannot change later. When you create an automation on github.com, in the GitHub Copilot app, or in Visual Studio Code, choose Shared under Type. You cannot change an automation's type after you create it. A personal automation that grew into a team workflow must be recreated as Shared; there is no convert button to find later, so the decision belongs at creation time.
- Set the credit limits before the first run. When you create or edit an automation, you can set any combination of optional limits. A per-run limit stops that run when it reaches the limit. Daily, weekly, and monthly limits stop new runs starting once the automation reaches one of them, until the period resets. Set both kinds: the per-run limit bounds one bad run, and the per-period limit bounds a runaway trigger firing all day. Automations without limits continue to run as they do today — no limit is applied by default, so an unlimited shared automation bills the repository owner without a ceiling. GitHub publishes no default limit figure in the changelog entries; the numbers are yours to set from what one run of this workflow should cost.
- Give it only the tools the workflow needs. Choose exactly which tools the automation can use, from the GitHub tools — including the 20 new ones, such as merging pull requests, retrying workflow runs, and hiding comments — and from custom MCP servers added in the repository's settings. A shared automation acts as Copilot, not as its creator, so a tool you would hesitate to give a colleague is a tool to leave off. The tool allowlist is the boundary; the prompt is not.
- Wire one trigger, then chain deliberately. Triggers define when the automation runs: a schedule, a GitHub event, or a REST API call from an external system. The October additions cover 24 more events across issues, pull requests, discussions, and security alerts — including merge conflicts, dismissed reviews, and code scanning alerts — and the API trigger lets outside systems such as Sentry or PagerDuty start one. Automations can also trigger other automations: each trigger has a "Can be triggered by" setting that defaults to users only, and automation run succeeded/failed triggers let one automation follow another. Set "Users and Copilot" only where a chained run is intended — the default exists so one automation's pull request does not silently fire the next.
- Hand it over in the open. Because everyone with read access can see a shared automation and anyone with write access can edit it, the handover is the change history, not a document: the team can see how the tools, triggers, and prompt evolved. Tell the team the billing owner changed — credits now bill the repository owner, not the creator — and where the limits sit, so nobody is surprised by a run that stops at its limit or a day when new runs wait for the reset.
Mistakes
- Creating it personal and planning to convert it. The type cannot change after creation. Recreate it as Shared or live with a personal workflow.
- Sharing without the admin policy. In an organization-owned repository the automation will not run until the administrator enables the billing policy. The failure looks like the automation is broken; the cause is the policy.
- Setting only a per-run limit. A per-run limit stops one run. A trigger firing repeatedly needs the daily, weekly, or monthly limit to stop new runs starting.
- Setting only a per-period limit. A per-period limit does nothing to a single run that burns credits until the period cap is hit. Both kinds exist because they bound different failures.
- Assuming sharing is available everywhere already. Shared automations are rolling out and availability varies. Check that you can choose Shared in your account before building the team's workflow around it.
- Confusing Automations with Projects or autofix. Copilot Projects gather multi-repo work in the Copilot app; agentic autofix proposes code fixes for alerts. Automations are scheduled or event-triggered workflows with prompts, triggers, and tools. The sharing and limit mechanics here belong to Automations only.
Limits
- No automation was created or run for this page: every mechanic is from the two GitHub changelog entries of 28 October 2026, read on 2 November 2026. What the creation screens show in your account, and whether sharing has reached it, is yours to check.
- No default or recommended limit figure is stated, because the changelog entries publish none. Set limits from the measured cost of one run of your workflow, not from a figure quoted elsewhere.
- The plan list is the changelog's: Pro, Pro+, Max, Business, and Enterprise. What each plan includes beyond Automations availability is outside this page.
Related playbooks
- Copilot Agent Merge: watch a PR and fix its blockers
- The Copilot app now takes GHES accounts
- Copilot Automations learn from real outcomes
- Copilot CLI signs in with Microsoft Entra
Sources
- https://github.blog/changelog/2026-10-28-build-shared-workflows-for-your-team-with-copilot-automations/
- https://github.blog/changelog/2026-10-28-new-tools-triggers-and-cost-controls-for-copilot-automations/
Back to: Small-team playbooks hub · Also: Budget agentic autofix before you enable it · Run work that spans several repos in one Copilot Project · Triage a backlog of issues with an agent