May 21, 2026

GitHub Copilot Agent Mode deep dive 2026: Coding Agent, Code Review, and the June credit billing switch

By AICoderScope Team · 16 min read

copilotreviewagentpricingworkflowvscursor

Something significant happened to GitHub Copilot between January and May 2026 that most developers missed because they were heads-down in their editors. Copilot shipped three separate agentic features — in-IDE Agent Mode, a cloud Coding Agent that converts issues into pull requests without you touching the keyboard, and an automated Code Review that left 60 million reviews by March 2026. And on June 1, the pricing model under all of it flips from flat-rate premium requests to token-based AI Credits, where 1 credit = $0.01.

If you use Copilot casually for completions, you will not notice. If you lean on Agent Mode or the Coding Agent for heavy multi-file work, you might open your June bill and have a bad morning.

This article breaks down what each agent feature actually does, where the new billing math bites, and how to stay on the right side of it.

Three different things called “agent”

GitHub’s marketing uses “agent” to describe three distinct modes of operation. Conflating them is the fastest way to misunderstand the billing change.

Feature	Where it runs	Who triggers it	Output
Agent Mode	Inside your IDE	You, interactively	Multi-file edits + terminal commands in your local editor session
Coding Agent (cloud agent)	GitHub Actions (ephemeral VM)	You assign an issue to @copilot	A pull request, ready for review
Code Review	GitHub.com	Auto on PRs, or manual request	Inline review comments on a pull request

Each has different costs, different strengths, and different failure modes.

Agent Mode: what actually changes when you turn it on

Agent Mode became generally available in VS Code in early 2026, and reached GA in JetBrains in March 2026 — a meaningful milestone because JetBrains is the dominant IDE for Java, Kotlin, and Python enterprise shops.

In standard Copilot Chat, you describe a problem and Copilot replies with suggested code that you manually apply. Agent Mode changes the loop: Copilot decides which files need to change, applies the edits, runs terminal commands (npm test, pytest, cargo build), reads the output, and iterates. You set the task and watch; you do not need to manually apply each suggestion.

VS Code ships the full agent experience: multi-file edits, terminal invocations, tool use (file search, symbol lookup, web fetch). The model selection defaults to “Auto,” which routes to whatever model GitHub judges most suitable at that moment, but you can pin to a specific model — Claude Sonnet 4.6, GPT-5 mini, Gemini 2.5 Pro, and others depending on your plan.

JetBrains caught up significantly in 2026. March brought custom agents, sub-agents, and a plan agent (which generates a step-by-step implementation plan before touching code). April 2026 added inline agent mode in preview — invoked directly in the editor gutter rather than through the side panel. May 13 added a CLI agent and unified sessions view. The gap with VS Code has closed from “fundamentally different product” to “a few features behind.”

Where Agent Mode works well: self-contained feature additions in a familiar codebase, migration tasks where the pattern is clear (convert all var to const, update a deprecated API across N files), and debugging loops where you need terminal feedback to iterate. Where it breaks down: large cross-repository changes (it cannot span repos), tasks that require external context the agent cannot access, and anything requiring production credential access (it runs inside your local session with your permissions — treat it accordingly).

The Coding Agent: assigning issues to Copilot

The Coding Agent (GitHub calls it the “cloud agent” in docs) reached general availability in March 2026. The workflow: open a GitHub issue, describe the change clearly, assign it to @copilot. A 👀 reaction appears on the issue confirming the agent has started, and minutes to hours later, a pull request appears.

The agent works inside an ephemeral GitHub Actions environment — it has its own compute, can run your test suite, run linters, and iterate on failures before surfacing anything to you. It is not generating code and hoping; it is running your CI in a sandboxed loop.

Before you even see the PR, three automated checks fire: CodeQL static analysis, secret scanning, and dependency review. A PR that fails any of these is flagged before a human reviews it. That security pipeline is a meaningful differentiator — most standalone AI coding agents produce code you must run through your CI yourself.

Practical limitations you should know before assigning your first issue:

Works on a single repository per task. Cross-repo changes require breaking the work into separate issues.
One branch, one PR per assignment. It will not open parallel branches or stack PRs.
It cannot comply with certain branch protection rules — if your repo requires signed commits or specific required status checks that it cannot fulfill, the PR will fail those checks.
It does not respect content exclusions configured by administrators (files marked off-limits in Copilot settings).
It only works with GitHub-hosted repositories. Self-hosted GitLab or Bitbucket: not supported.

The Coding Agent is available on all paid Copilot plans (Pro, Pro+, Business, Enterprise). Business and Enterprise admins must explicitly enable it in repository settings.

For well-scoped, clearly-described tasks — “add a 404 handler for the /api/users/:id route when the user does not exist” rather than “refactor the auth system” — the Coding Agent produces genuinely useful first drafts. The issue description quality is the bottleneck. Vague issues produce vague PRs.

Code Review: the sleeper feature

Copilot Code Review is the feature most developers are sleeping on. It hit 60 million reviews by March 2026 and ships in two modes:

Manual review request: On any pull request on GitHub.com, request a review from Copilot the same way you’d request one from a teammate. It responds in under 30 seconds in most cases.

Automatic review: Admins can enable automatic Copilot review on all PRs in a repository. Every PR gets a review before a human opens it.

What it actually looks at: The 2026 version moved to an agentic architecture that gathers full repository context before commenting — it is not limited to the diff. If your change in auth.ts breaks an implicit contract that only shows up in tests/integration/auth.test.ts, it has context to catch that. GitHub reports 71% of reviews surface actionable feedback, with an average of 5.1 comments per review, focused on correctness and architectural issues rather than nitpicks.

Important constraint: Copilot always leaves a “Comment” review — never “Approve” or “Request Changes.” Its reviews do not count toward required approvals and will not block merging. This is a policy choice, not a technical limitation. For teams with required human review counts, Copilot review is additive, not a shortcut around your review gates.

Billing from June 1, 2026: Code review will consume both AI Credits and GitHub Actions minutes. That is two billing dimensions, not one — factor both into your estimate if you are enabling auto-review across busy repositories.

You can also trigger code review from the GitHub CLI: gh pr review --copilot, added in March 2026, which lets you request a Copilot review without leaving the terminal.

The June 1 billing switch: the math

Starting June 1, 2026, every Copilot plan switches from counting “premium requests” to counting tokens, billed in AI Credits. One AI Credit = $0.01. Here is what each plan includes monthly:

Plan	Monthly cost	Monthly AI credits	Effective credit value
Free	$0	50 premium requests (pre-June model)	Transitioning; check docs
Pro	$10/user	1,000 credits	$10 worth
Pro+	$39/user	3,900 credits	$39 worth
Business	$19/user	1,900 credits (+ $30 promo Jun–Aug)	~$49 during transition
Enterprise	$39/user	3,900 credits (+ $70 promo Jun–Aug)	~$109 during transition

Code completions and Next Edit Suggestions remain free. They do not consume AI Credits under the new model. If you use Copilot purely for inline completions, your cost does not change.

Everything else — chat, agent mode, cloud agent, code review — is metered. The token rate depends on which model you use:

Model	Input (per M tokens)	Output (per M tokens)
GPT-5 mini	$0.25	$2.00
Claude Haiku 4.5	$1.00	$5.00
Gemini 2.5 Pro	$1.25	$10.00
GPT-4.1	$2.00	$8.00
Claude Sonnet	$3.00	$15.00
Claude Opus	$5.00	$25.00

A quick Claude Sonnet chat exchange — say, 2,000 input tokens and 500 output tokens — costs roughly ($0.006 + $0.0075) = $0.0135, or about 1.35 AI Credits. At 1,000 credits/month on Pro, that is around 740 such exchanges before your included allocation runs out.

Agent Mode sessions cost more. A multi-file refactor across a 50-file TypeScript codebase might send 40,000 input tokens (file context) and generate 8,000 output tokens. On Claude Sonnet: $0.12 + $0.12 = $0.24, or 24 credits per session. Pro’s 1,000 credits covers roughly 40 such sessions before hitting your included allocation.

The heavy-user problem is real. One developer’s April 2026 usage showed their monthly cost jumping from $39.07 under the premium request model to $902.72 under token-based billing — a 23x increase — driven entirely by extended agent sessions using premium models across large codebases. This is not a scare story: it is what happens when you run 4-hour agent sessions on Opus with a 200k-token context. GitHub’s preview billing tool, available in early May, lets you project your June bill before it hits.

What to do before June 1:

Visit your Copilot settings and run the billing preview tool.
Set a monthly spending limit. There is no default cap — usage beyond your included credits is billed at credit rate. To hard-cap at your included allocation with zero overage: set the overage budget to $0 in your personal or organization billing settings. Usage stops when the monthly pool runs out; you are not charged beyond that. Admins on Business and Enterprise plans can set budgets at four levels — enterprise, organization, cost center, and per-user — which is useful for controlling costs across large teams.
If you are using Auto model selection in Agent Mode, pin to GPT-5 mini or Claude Haiku 4.5 for routine tasks; save Sonnet/Opus for genuinely complex multi-file work. The model routing strategy makes the biggest single difference in monthly spend: switching from Claude Sonnet to GPT-5 mini for standard chat reduces per-query cost by roughly 12×.
For the Coding Agent, prefer well-scoped issues. A 90-minute agent session on a vague issue costs the same compute as one that produces a clean PR.
Use custom instructions to keep Agent Mode on task. In VS Code, add a .github/copilot-instructions.md file (or configure via the Copilot settings panel) to specify your testing framework, branch naming conventions, and guardrails. GitHub uses these internally to enforce specific testing patterns across their repos — they constrain what the agent generates without requiring you to repeat yourself in every prompt.

Plan availability: who gets what

Feature	Free	Pro	Pro+	Business	Enterprise
Code completions	2,000/mo	Unlimited	Unlimited	Unlimited	Unlimited
Agent Mode (IDE)	50 requests/mo	Unlimited	Unlimited	Admin-enabled	Admin-enabled
Coding Agent (cloud)	—	Yes	Yes	Admin-enabled	Admin-enabled
Code Review	—	Yes	Yes	Admin-enabled	Admin-enabled
Claude Opus 4.7 access	—	—	Yes	Depends	Yes
GitHub Spark (app builder)	—	—	Preview	—	—
IP indemnity	—	—	—	Yes	Yes

Note: As of April 20, 2026, new sign-ups for Pro, Pro+, and Student plans are temporarily paused while GitHub rolls out the new billing infrastructure. Existing subscribers retain their current plan.

How this compares to Cursor Agent Mode

If you are evaluating Copilot Agent Mode against Cursor’s agent, the honest comparison is:

Copilot’s advantage: Deep GitHub integration — the Coding Agent has native access to your issue tracker, PRs, Actions, CodeQL, and the full GitHub security toolchain. No other coding agent runs your CI natively as part of its iteration loop. Code Review’s 60 million reviews and agentic context-gathering is also something standalone tools cannot match.

Cursor’s advantage: The in-IDE agent is faster and more responsive for interactive development, and the context window handling (Cursor’s .cursorrules, BYOB model routing, shadow workspace) is more sophisticated for large codebases. Cursor’s April 2026 SWE-bench Verified score of 65.7% also leads Copilot’s agent in benchmark terms.

The practical verdict: Copilot Agent Mode and the Coding Agent are strongest for developers who live in the GitHub ecosystem — open source contributors, teams with mature CI/CD, and orgs that need the security scan pipeline baked in. Cursor is the better daily-driver for interactive agentic coding sessions, especially in large monorepos. Plenty of teams run both. See our Cursor IDE Review 2026 for a direct assessment.

Honest take

Three things are true simultaneously about GitHub Copilot in May 2026:

The agentic feature set is genuinely impressive. Agent Mode is GA in both VS Code and JetBrains, the Coding Agent runs CI in an ephemeral environment and ships PRs with a security scan attached, and Code Review at 60 million reviews with 71% actionable feedback rate is not a novelty anymore.

The June 1 billing change is the right long-term move. Flat-rate pricing for agent sessions was a gift that GitHub could not sustain as agent context windows grew. Token-based billing aligns incentives correctly: quick completions stay free, heavy agentic workloads pay for what they consume.

And the transition math will surprise heavy Agent Mode users who have not run the preview tool. A 23x billing increase for the developer quoted above is an outlier, but 3-5x increases for moderately heavy agent users are plausible if they are not pinning to cheaper models for routine work. Run the preview tool before June 1. Set a spending cap. Route casual queries to GPT-5 mini and reserve Opus-tier models for the tasks that genuinely need them.

The Coding Agent earns its place for teams with clean, issue-tracked workflows. Code Review earns its place for any team that wants a first-pass reviewer that never skips a PR. Agent Mode in the IDE is a capable but not class-leading interactive agent — it is competitive with Cursor on GitHub-integrated tasks and behind Cursor on raw agentic throughput.

If you are already a Pro subscriber and your usage is moderate (chat + occasional agent sessions, not hour-long runs), your June bill will look similar to May’s. If you are a heavy user who runs the Coding Agent on complex multi-file features regularly, pull up that preview tool now.

FAQ

Q: What is the difference between Agent Mode and the Coding Agent?

A: Agent Mode runs inside your IDE — it is an interactive loop where you set a task and Copilot edits files, runs terminal commands, and iterates in your local editor session. The Coding Agent (GitHub’s “cloud agent”) runs on GitHub Actions — you assign a GitHub issue to @copilot, and minutes to hours later a pull request appears, produced by a sandboxed VM that ran your CI. Agent Mode is for interactive development; the Coding Agent is for delegating discrete, well-specified tasks without touching your keyboard. You can also stack them: use Agent Mode to prototype locally, then hand the follow-up ticket to the Coding Agent.

Q: How do I stop getting surprise charges after June 1?

A: Set your overage budget to $0 in billing settings (Settings → Billing → GitHub Copilot → Spending limit). This hard-caps usage at your plan’s monthly credit allotment. Once the pool is exhausted, agent features stop working for that billing period — but you will not be charged beyond the plan rate. If you need more, you can top up manually or raise the cap. The alternative is setting a dollar-denominated soft limit (e.g., $20 overage allowed) — usage stops at that threshold regardless of where you are in the billing cycle.

Q: Does Copilot Agent Mode work on private repositories?

A: Yes. Agent Mode runs in your local IDE session with your existing credentials and filesystem access, so private repos work exactly the same as public ones. The Coding Agent (cloud agent) also supports private repos, but requires explicit admin enablement in repository settings under Business and Enterprise plans. One constraint: the Coding Agent cannot access files in repos that are private to other organizations — each task is scoped to a single repository.

Q: Is there a free alternative to GitHub Copilot for local, private codebases?

A: Yes. Cline is a VS Code extension under Apache 2.0 that connects to any LLM — including locally-run models via Ollama — and provides Plan/Act agentic workflows similar to Copilot Agent Mode, with zero subscription cost. The tradeoff is that you manage model hosting yourself and do not get the GitHub-native CI integration. For teams that run private code that can’t leave the network, Cline with a local model (or Aider for terminal-centric workflows) is the standard private alternative. See the Continue.dev vs Cline vs Aider comparison for a structured breakdown.

1V1 STARTER KIT · CURSOR

Skip the week of trial-and-error setting up Cursor.

12 production-tested .cursorrules templates, 3 workflow configs, the cost-control checklist. Everything I wish I had on day one.

Get it for $19 (early bird) →

Sources

Last updated May 21, 2026. Pricing and features change frequently; verify current state before purchasing.

Was this article helpful?