On this page · 11 sections
- What actually shipped on 3 August 2026
- The credit model, in the numbers GitHub publishes
- The number GitHub does not publish
- Comment triggers are a spend surface, not just a convenience
- Code review bills twice, and hides the model
- A configuration and guardrail checklist
- Choosing a reasoning level by task class
- India-specific considerations
- FAQ
- How eCorpIT can help
- References
Summary. GitHub shipped two changes to Copilot cloud agent on 3 August 2026. You can now pick a reasoning level alongside the model when you delegate a task, and you can create automations that fire when an issue comment or pull request comment is created. GitHub's own wording on the first one is the important part: "A higher level can improve answers to complex problems, but it consumes more tokens, and therefore more credits." Both features are live on all paid plans that include Copilot cloud agent, which GitHub lists as Copilot Pro, Pro+, Business, Enterprise and Max. The cost side is where teams will get caught. Since 1 June 2026 Copilot bills token consumption in GitHub AI Credits, and GitHub's models and pricing reference states plainly that 1 AI credit = $0.01 USD. Reasoning shows up almost entirely in output tokens, and output is the expensive column: GPT-5.6 Sol is $5.00 per 1M input and $30.00 per 1M output, GPT-5.6 Terra is $2.00 and $12.00, and GPT-5.6 Luna is $0.20 and $1.20, all per 1 million tokens. Claude Opus 5 sits at $5.00 input and $25.00 output. Yet GitHub's billing reference contains no reasoning section at all, no reasoning-token line and no multiplier, so there is no published number for what raising the level costs. Copilot Business includes $19 in monthly AI Credits per user and Copilot Enterprise $39, pooled across the billing entity, so an unbudgeted reasoning default drains a shared pool rather than one engineer's allowance. Code review is worse: it bills AI Credits and GitHub Actions minutes, and the model it picks is not disclosed.
What actually shipped on 3 August 2026
Two separate changelog entries, one day, and they interact.
Reasoning level per task. When you delegate a task to Copilot cloud agent you can now set the reasoning level for models that support it. You pick it alongside the model when you start the task, and the agent uses it for that run. GitHub describes the trade directly: a higher level can improve answers to complex problems, and it consumes more tokens and therefore more credits. Availability is all paid Copilot plans that include Copilot cloud agent, listed as Pro, Pro+, Business, Enterprise and Max.
Comment-triggered automations. You can create Copilot cloud agent automations that run when an issue comment or a pull request comment is created. You specify the comment text that triggers the automation, and you configure it from the Agents tab in a repository, then Automations in the sidebar. GitHub lists three use cases: generating or updating documentation from a pull request's code changes, investigating stack traces or error logs from an issue comment, and creating follow-up issues for refactoring or technical debt. Automations are available for existing Copilot Pro, Pro+, Max, Business and Enterprise users, and Copilot Business and Copilot Enterprise users need the Copilot cloud agent policy enabled by an administrator.
Put the two together and you have a spend surface that anyone with comment access can trigger, running at a reasoning level someone chose once.
The credit model, in the numbers GitHub publishes
GitHub replaced premium request units with AI Credits on 1 June 2026. The billing reference sets out the mechanics without ambiguity.
Interactions consume input tokens, output tokens and cached tokens. Each token is priced by model, and the total converts to AI credits, "where 1 AI credit = $0.01 USD". When usage exceeds the included allowance, additional usage is billed at the per-token rates in the same tables. Code completions and next edit suggestions are excluded: they "are not billed in AI credits" and "remain unlimited for all paid Copilot plans".
Seat pricing did not change when the model did. Copilot Business remains $19 per user per month including $19 in monthly AI Credits, and Copilot Enterprise $39 per user per month including $39 in credits, with included usage pooled across a business rather than stranded per user, and budgets settable at enterprise, cost centre and user levels.
Here are the rates that matter for an agent run, all per 1 million tokens, from GitHub's published tables as of 6 August 2026.
| Model | Category | Input | Cached input | Output | Output as a multiple of input |
|---|---|---|---|---|---|
| GPT-5.6 Luna | Lightweight | $0.20 | $0.02 | $1.20 | 6x |
| GPT-5.6 Terra | Versatile | $2.00 | $0.20 | $12.00 | 6x |
| GPT-5.6 Sol | Powerful | $5.00 | $0.50 | $30.00 | 6x |
| Claude Sonnet 5 | Versatile | $2.00 | $0.20 | $10.00 | 5x |
| Claude Opus 5 | Powerful | $5.00 | $0.50 | $25.00 | 5x |
| Claude Fable 5 | Powerful | $10.00 | $1.00 | $50.00 | 5x |
| Gemini 3.6 Flash | Versatile | $1.50 | $0.15 | $7.50 | 5x |
| Grok 4.5 | Versatile | $2.00 | $0.50 | $6.00 | 3x |
| Kimi K2.7 Code | Versatile | $0.95 | $0.19 | $4.00 | 4.2x |
The last column is the whole point. Output costs five or six times input on every frontier model in that table, and reasoning tokens are output tokens. A reasoning level is therefore a multiplier on the most expensive part of the bill, not a uniform increase.
Two footnotes worth carrying into a budget. Claude Sonnet 5 is at promotional pricing of $2.00 input, $0.20 cached input, $2.50 cache write and $10.00 output per 1M tokens only through 31 August 2026. And GPT-5.6 Sol, Terra and Luna each carry a cache write cost on top of cached input, which earlier OpenAI models do not: $6.25, $2.50 and $0.25 per 1M tokens respectively.
Long-context tiers are a second cliff. GPT-5.6 Sol above 272K input tokens moves to $10.00 input and $45.00 output; GPT-5.6 Luna above 200K moves to $0.40 and $1.80. An agent that reads a large repository can cross that threshold without anyone choosing to.
The number GitHub does not publish
Search GitHub's models and pricing reference for "reasoning" and you find nothing. There is no reasoning section, no reasoning-token line item, and no multiplier table. Billing is described purely as input, cached input, cache write and output tokens.
So the changelog tells you a higher reasoning level costs more, and the billing documentation gives you no way to say how much more before you run it. That gap is the practical problem, and it is why the control needs a policy rather than a preference.
The workable approach is to model it yourself from the output rate, then measure. Take a task profile your team actually runs, hold the model constant, and run the same task at two reasoning levels while watching the credit consumption in billing. The delta is your local multiplier. It will differ by task type, which is exactly why a published average would not have helped much anyway.
As an illustration of the sensitivity, assume a single agent run that reads 250,000 input tokens and produces 40,000 output tokens. On GPT-5.6 Terra that is $0.50 of input and $0.48 of output, roughly 98 AI credits. On GPT-5.6 Sol the same profile is $1.25 and $1.20, roughly 245 credits. If a higher reasoning level doubles output tokens to 80,000, the Terra run goes to about 146 credits and the Sol run to about 365. The token volumes there are an assumed profile, not measured data; the per-token rates are GitHub's published ones. Substitute your own volumes and the shape holds: doubling output moves the bill far more than doubling input would.
Against a $19 monthly Business allowance, which is 1,900 credits at $0.01 each, that Sol run at the higher reasoning level would consume roughly a fifth of one seat's included credits. Pooling across the business softens that, and it also means one team's default becomes everyone's problem.
Comment triggers are a spend surface, not just a convenience
The automation feature is genuinely useful. Comment on a pull request and get documentation regenerated from the diff. Comment on an issue and have an agent chew through a stack trace. Comment on a pull request and have follow-up refactoring issues created.
It is also the first Copilot surface where an ordinary comment starts an agent run that costs money. Three consequences follow.
The trigger string is your authorisation model. You specify the comment text that fires the automation, so the string is effectively a command name with no permission attached beyond the ability to comment. Pick something explicit and unlikely to appear in normal discussion. A trigger of /docs will fire on a sentence that happens to contain it; a trigger like /copilot-generate-docs will not.
Public and widely shared repositories change the risk. If a repository accepts comments from people outside the team, every one of them can start a run. GitHub requires an administrator to enable the Copilot cloud agent policy for Business and Enterprise users, which is the gate to use before the trigger exists, not after.
Loops are the third. An automation that comments on a pull request, combined with a trigger that matches its own output, is a self-sustaining spend loop. Check that no automation's output can match another automation's trigger text.
Code review bills twice, and hides the model
This is the cost detail most teams discover from an invoice.
GitHub states that each Copilot code review is billed in two ways: token consumption in AI credits, and the agentic infrastructure that powers the review in GitHub Actions minutes. Attribution splits across the two. Actions minutes are attributed to the repository, and from there to the enterprise or cost centre where applicable. AI credits are charged to the person who requests the review, or to the author of a pull request where a policy automatically triggers a review; if neither has a Copilot seat, usage is billed to the enterprise or cost centre.
The estimation problem is explicit in the documentation: "For most Copilot features, the model used for each interaction is visible to you, so you can reference the pricing tables above to estimate costs. Copilot code review is an exception - the model is selected automatically and is not disclosed, so per-token costs may vary between reviews."
You can still track it. GitHub points at Actions metrics filtered by the copilot-pull-request-reviewer workflow, and the billing usage report filtered on the workflow_path value dynamic/agents/copilot-pull-request-reviewer. Build both filters into your monthly review before you turn automatic review on across every repository.
A configuration and guardrail checklist
| Control | Where it lives | What it prevents |
|---|---|---|
| Copilot cloud agent policy | Administrator setting for Business and Enterprise | Automations existing before anyone has approved agent runs |
| Explicit trigger strings | Automation configuration, Agents tab then Automations | Accidental runs from ordinary discussion text |
| Default model per team | model key in enterprise managed settings, or team model policy |
A powerful model becoming the default for everyone |
| Reasoning level convention | Team runbook, chosen per task class | A high level applied to trivial tasks |
| Budgets at enterprise, cost centre and user level | Copilot billing settings | Pooled credits draining without a cap |
Actions metrics filter on copilot-pull-request-reviewer |
GitHub Actions metrics | Code review minutes going unattributed |
Billing report filter on dynamic/agents/copilot-pull-request-reviewer |
Billing usage report | Losing the second half of the review bill |
| Long-context awareness above 272K or 200K input tokens | Task scoping and repository size | Silently crossing into the higher rate tier |
Two of those are policy, not configuration. A reasoning level is a per-task choice with no enterprise key behind it in the published settings reference, so the only durable control is a written convention: low or default reasoning for routine work, higher levels reserved for a named class of hard problems, reviewed monthly against actual credit consumption.
If you are also setting Copilot policy at the team level, the mechanics are in our guide to GitHub Copilot enterprise team managed settings and model policy, and the broader control surface is covered in enterprise AI agent governance layers.
Choosing a reasoning level by task class
There is no published guidance mapping reasoning levels to task types, so this is a judgement framework rather than a rule, and it should be recalibrated against your own measured delta.
| Task class | Suggested level | Reasoning |
|---|---|---|
| Dependency bumps, lint fixes, formatting | Lowest available | Deterministic work; extra deliberation buys nothing |
| Documentation generation from a diff | Low to default | The diff already constrains the answer |
| Test authoring for existing behaviour | Default | Needs comprehension, not exploration |
| Stack trace and log investigation | Higher | Genuinely multi-hypothesis work, where GitHub's own use case lands |
| Cross-module refactoring | Higher | Long dependency chains reward deliberation |
| Anything triggered automatically by a comment | Lowest that works | Volume is unpredictable, so cap the unit cost |
That last row is the one to enforce. A manual delegation is a person deciding to spend; an automation is a spend decision made once and executed indefinitely.
India-specific considerations
For Indian engineering teams and global capability centres, three points change the arithmetic.
Pooled credits cross time zones. Included usage is pooled across the business, so an offshore pod running comment-triggered automations overnight draws from the same pool an onshore team will use the next morning. Budgets at the cost-centre level are the mechanism that keeps that visible, and they should be set before automations go live, not after the first overage.
Model selection is a currency decision. Rates are published in US dollars per million tokens, so the difference between a $1.20 and a $30.00 output rate is a foreign-exchange exposed line in a rupee budget. Teams that route routine automation work to a lightweight model and reserve powerful models for hard problems get most of the saving from one policy change.
Prompt content leaves your estate. An agent run sends repository context to a model provider. Where that context can contain personal data, the processing and transfer decisions sit under the Digital Personal Data Protection Act 2023; the engineering controls are set out in our DPDP Act engineering playbook for Indian startups. Teams measuring whether any of this is paying for itself should read our note on measuring AI coding agent productivity, and the wider view sits in enterprise AI agents in production.
FAQ
How eCorpIT can help
eCorpIT sets up and governs AI coding agent programmes for engineering organisations from Gurugram as a senior-led team, CMMI Level 5 assessed and ISO 27001:2022 certified. On this specific problem the work is measurement and control: running a controlled comparison so you know your own reasoning-level delta instead of guessing at it, writing the trigger and automation conventions that keep an ordinary comment from becoming an unbounded spend, mapping model defaults to task classes, and wiring the Actions and billing filters that make Copilot code review visible on both lines. If you want the agent rollout costed and capped before it scales, talk to our team.
References
- GitHub Changelog, Customize the reasoning level for Copilot cloud agent, 3 August 2026.
- GitHub Changelog, Trigger Copilot automations with comments, 3 August 2026.
- GitHub Docs, Models and pricing for GitHub Copilot, accessed 6 August 2026.
- Mario Rodriguez, GitHub Blog, GitHub Copilot is moving to usage-based billing, 27 April 2026.
- GitHub Docs, About Copilot automations, accessed 6 August 2026.
- GitHub Docs, Choosing the right AI model for your task, accessed 6 August 2026.
- GitHub Docs, About billing for GitHub Copilot in organizations and enterprises, accessed 6 August 2026.
- GitHub Docs, Usage-based billing for organizations and enterprises, accessed 6 August 2026.
- GitHub Changelog, Enterprise team specialization for managed settings, 3 August 2026.
- GitHub Changelog, Enterprise teams model policy targeting in public preview, 31 July 2026.
- GitHub Changelog, Upcoming August 2026 model deprecations in GitHub Copilot, 31 July 2026.
- GitHub Docs, Enterprise managed settings reference, accessed 6 August 2026.
- GitHub Changelog, Retiring the Copilot Billing Preview app, 4 August 2026.
- GitHub Changelog, Enterprise managed-settings.json is generally available, 1 July 2026.
Last updated: 6 August 2026.
