Oct 21, 2026

GitHub Agentic Autofix Goes GA: Assign a Security Alert to Copilot, Get a Draft PR — What It Costs and Who Actually Gets It

By AICoderScope Team · 13 min read

github-copilotsecuritycode-scanningcodeqlpricingai-code-review

GitHub moved agentic autofix for code scanning alerts to general availability on October 15, 2026. The feature lets you assign a CodeQL security alert to Copilot the way you’d assign it to a teammate: an agent explores your codebase, writes a fix, reruns CodeQL to confirm the alert closes, and opens a draft pull request with a summary of what it did. You can batch up to 25 alerts into a single PR from the alerts list or a security campaign.

That’s the headline. The part the headline skips: this is an Enterprise Cloud feature stacked on top of two paid add-ons, it bills per fix through AI Credits plus GitHub Actions minutes, and a solo developer on Copilot Pro gets exactly nothing new from this release. Here is the full cost stack, where the validation step quietly stops working, and what to use instead at every budget level.

One transparency note before the numbers: github.blog and docs.github.com are cited below from GitHub’s own changelog entries (surfaced via search) cross-checked against four independent writeups, because this was researched from an environment that could not load GitHub’s pages directly. Every price is additionally cross-confirmed against at least two independent trackers. Verify against the official pages before signing a contract.

What did GitHub actually ship on October 15, 2026?

Agentic autofix is the “assign it to Copilot” workflow for code scanning alerts, and GA means it left the public preview that started July 10, 2026. The mechanics, per GitHub’s changelog:

You open a code scanning alert (CodeQL or a third-party scanner) on the default branch and assign it to Copilot.
The Copilot coding agent explores the relevant files across the repository — not just the flagged line — and writes a candidate fix.
It reruns CodeQL against the patched code to verify the original alert no longer fires, iterating if the first attempt doesn’t close it.
It opens a draft pull request with the fix, a summary, and the validation steps it took. A human still reviews and merges.

The GA release added batching: select up to 25 alerts from the alerts list or a security campaign and Copilot fixes them in one pull request. That’s the feature’s real pitch — security-debt burndown, not one-off fixes. A team sitting on 400 historical CodeQL alerts can now work through them in 16 batched PRs instead of 400 Jira tickets nobody picks up.

This is a different feature from the Copilot Autofix you may already have. The original Autofix — the one that suggests an inline fix inside a pull request when code scanning flags new code — went GA back on August 14, 2024, and has been free on public repositories since September 2024. Agentic autofix is the 2026 extension of that idea to existing alerts on the default branch, with codebase exploration and self-validation added. Several October writeups (the queue note that triggered this article included one) dated the GA October 20 and called it “code autofix” — the changelog entry is titled “Agentic autofix for code scanning alerts general availability” and is dated October 15, 2026.

How much does agentic autofix cost in practice?

For a 10-developer team starting from zero, roughly $700/month in fixed subscriptions before the first fix runs — and then AI Credits plus Actions minutes per fix on top. The feature itself has no sticker price, which is exactly why the stack underneath it needs to be written out:

Layer	Product	List price (verified Oct 21, 2026)	10-dev team
Base plan	GitHub Enterprise Cloud (required at GA)	$21/user/mo	$210
Scanner	GitHub Code Security (or legacy GHAS bundle at $49)	$30/active committer/mo	$300
Agent	Copilot Business (cloud agent enabled)	$19/user/mo	$190
Per fix	AI Credits + GitHub Actions minutes	metered	varies
	Fixed total		~$700/mo

Three things to know about that table:

Enterprise Cloud is the gate. The GA changelog scopes agentic autofix to “GitHub Code Security and GitHub Advanced Security customers on GitHub Enterprise Cloud” (data-residency regions included). GitHub Team at $4/user — where the Code Security add-on is also sold — does not get the agentic workflow. An enterprise admin must also flip on a new “Agentic autofix” policy before anyone can assign an alert; it is off by default.
“Active committer” billing cuts both ways. Code Security bills per unique committer to the repos where it’s enabled during the billing period, not per seat. A 10-dev team that enables it on only the two services handling untrusted input might pay for 6 committers, not 10. Licensing consultancies report orgs that enable it everywhere routinely carry 15–25% more billable committers than they need.
Per-fix metering lands on the June 2026 AI Credits system. Since GitHub’s June 1, 2026 billing change, agentic workloads draw down the org’s AI Credits pool; agentic autofix consumes credits only when a fix actually runs, and during preview the usage was not itemized separately from other Copilot activity — budget owners couldn’t see what autofix specifically cost. Each run also burns GitHub Actions minutes from the shared allowance. If your org already learned the hard way that agentic sessions cost 10–50x what tab completion does (we covered the backlash in the June billing change breakdown), apply the same caution here: 25-alert batch runs are exactly the shape of workload that drains a credit pool.

Where does the CodeQL validation step stop working?

The agent’s self-validation only proves the original query no longer fires — and it can’t even do that for every scanner that can trigger it. Two separate gaps, both documented:

Gap 1: validation coverage. Agentic autofix accepts alerts from CodeQL and third-party SARIF-uploading scanners, per the July preview notes. But the validation rerun executes CodeQL’s default query suite. Alerts from the security-extended suite, custom CodeQL queries, or third-party scanners get a proposed fix without the “reran the scanner, alert closed” confirmation — the draft PR’s validation claim is weaker there, and the PR doesn’t shout about it. If your org’s scanning policy leans on custom queries (most mature CodeQL shops do), a chunk of your alerts falls in the unvalidated bucket.

Gap 2: a closed alert is not a correct fix. A clean CodeQL rerun means the specific pattern the query matches is gone. It does not mean the behavior is right. The failure mode people hit in preview: Copilot fixes a SQL injection by parameterizing the query, CodeQL goes green, and a code path that depended on the old string-building behavior breaks — nothing in the autofix loop runs your test suite against the change. This is why the output is a draft PR: GitHub’s own design assumes a human review step, and your CI is the thing that actually catches the regression. Treat the agent’s “validated” label as “scanner-validated,” never “behavior-validated.”

The practical mitigation is cheap: require your normal CI (tests included) on autofix PRs like any other PR, and route the batched 25-alert PRs to whoever owns the affected services rather than merging them as a block. A 25-fix PR that breaks one service is much harder to bisect after merge than before.

Default branch only, one more time, because it shapes the workflow: alerts that exist only on a PR or a feature branch can’t be assigned to Copilot. In-PR fixes for new code remain the job of the older inline Copilot Autofix.

Agentic autofix vs Cursor Bugbot vs Claude Code /security-review

Three products now sell “AI finds-and-fixes security problems in your repo,” and they sit at completely different price points and trust models:

	GitHub agentic autofix	Cursor Bugbot	Claude Code /security-review
Trigger	Assign existing default-branch alert	Automatic on PRs	On demand, in terminal
Finds the bug itself?	No — fixes what CodeQL/scanners found	Yes — its own review	Yes — its own multi-agent scan
Validates its fix?	Reruns CodeQL (default suite only)	No	No (suggests patch, you apply)
Output	Draft PR, up to 25 fixes	PR comments	Terminal findings + patches
Price floor	~$70/dev/mo stack (Enterprise + Code Security + Copilot) + credits	$40/user/mo on top of Cursor ($40 verified Sep 2026)	Included in a $20/mo Claude plan’s usage
Best at	Burning down known CodeQL backlog at org scale	Catching logic bugs pre-merge	Pre-commit scans on any repo, no platform lock

The structural difference matters more than the prices. GitHub’s agent starts from a scanner finding, so it fixes a confirmed vulnerability class — narrow target, high hit rate, and the only one of the three that re-checks its own work with the scanner. Bugbot and Claude’s security plugin start from “review this code,” so they catch things CodeQL has no query for, and also produce more findings a human has to triage. They’re complements, not substitutes: we found the same split testing Claude’s security plugin last week — it’s an AI-native linter for code you’re about to ship, not a backlog tool.

If you want the scanner-driven pattern without GitHub’s price stack, the self-hosted version of this workflow exists: a local scanner plus a local model posting review comments, which we documented in the reviewdog + local LLM setup. It validates nothing automatically, but it costs $0/user and the code never leaves your machine.

Does a solo developer get anything from this release?

No. Read the gate list again from a solo dev’s chair: Enterprise Cloud plan, Code Security add-on, Copilot Business, an enterprise admin to enable a policy. None of that exists on a personal account, and GitHub shipped no change to individual plans on October 15.

What a solo developer does have, unchanged since 2024: Copilot Autofix on public repositories is free — if CodeQL flags an alert on your public repo’s PR, the inline fix suggestion appears at no cost, no Copilot subscription required. On private repos with no org budget, the realistic stack in October 2026 is Semgrep Community Edition or CodeQL’s free CLI for finding issues, plus whichever coding agent you already pay for to fix them — Claude Code’s /security-review at the $20/mo plan is the cheapest finds-and-fixes combination we’ve tested. The FOSS scanner side of that stack is covered in depth on our sister site: open-source SAST tools on aifoss.dev.

Checking whether you even have alerts to fix takes one command on any repo with code scanning enabled:

gh api repos/OWNER/REPO/code-scanning/alerts --jq '.[] | {number, rule: .rule.id, severity: .rule.security_severity_level, state}'

{"number": 42, "rule": "js/sql-injection", "severity": "high", "state": "open"}
{"number": 38, "rule": "js/incomplete-url-substring-sanitization", "severity": "medium", "state": "open"}

If that list is empty, no autofix product at any price does anything for you yet — turn on CodeQL first (free for public repos, part of Code Security for private ones).

Honest take: who should turn this on

Enable it if you’re already paying for the stack. For an org that has Enterprise Cloud, Code Security, and Copilot Business today, agentic autofix is the first feature that converts the CodeQL alert backlog — the thing every GHAS customer has and nobody staffs — into reviewable PRs at marginal cost. The 25-alert batching plus security campaigns is a genuinely new capability, not a repackaging. Flip the policy on, point it at your oldest high-severity alerts, and gate the PRs behind full CI.

Do not buy the stack to get this feature. ~$700/month fixed for a 10-dev team before the first fix, metered credits with (as of preview) no itemized autofix line on the bill, validation that silently thins out on custom queries and third-party scanners, and a hard Enterprise Cloud requirement — that math only works if Code Security was already justified on scanning alone. A team on GitHub Team plan or a Cursor-first shop gets most of the practical value from Bugbot or Claude Code at a tenth of the commitment.

What to actually use

Prices as of October 2026, all verified in the sections above:

Your situation	What to use	Price	Where
Org already on Enterprise Cloud + Code Security + Copilot	Enable the agentic autofix policy, batch old alerts	$0 new fixed cost; AI Credits + Actions per fix	github.com/security/advanced-security
Org evaluating the full stack from scratch	Price Code Security on scanning value alone; autofix is a bonus	~$70/dev/mo all-in (10-dev team)	github.com/pricing
Cursor team wanting AI review on every PR	Cursor Bugbot	$40/user/mo	cursor.com/pricing
Solo dev or small team, private repos, no GHAS budget	Claude Code `/security-review` + Semgrep CE	$20/mo (existing Claude plan) + $0	Claude security plugin review
Solo dev, public repos	Copilot Autofix inline suggestions — already free	$0	github.com/features/copilot
Zero-cloud requirement	reviewdog + local LLM + Semgrep	$0/user, your hardware	reviewdog + local LLM setup

FAQ

Is agentic autofix the same as Copilot Autofix? No. Copilot Autofix (GA August 2024) suggests inline fixes for alerts on new code inside pull requests, and is free on public repos. Agentic autofix (GA October 15, 2026) assigns existing default-branch alerts to the Copilot coding agent, which explores the codebase, self-validates with a CodeQL rerun, and opens a draft PR — Enterprise Cloud only.

Can it fix alerts from Semgrep or other third-party scanners? It accepts them (any scanner uploading SARIF to code scanning), but its validation rerun covers CodeQL’s default query suite — third-party and custom-query alerts get a proposed fix without the scanner-confirmed close.

Does it work on pull request alerts or feature branches? No. Only alerts present on the default branch can be assigned to Copilot. In-PR alerts remain the job of the older inline Autofix.

What does one fix cost? GitHub doesn’t publish a per-fix price. Each run draws on the org’s AI Credits pool (the post-June 2026 billing system) plus GitHub Actions minutes, and during the preview, autofix usage wasn’t itemized separately — assume agentic-session-scale costs and watch the credit pool after your first batch.

Does Copilot Business or Enterprise matter for this? You need a Copilot plan with the cloud coding agent enabled on an Enterprise Cloud org; Business ($19/user/mo) is the floor. The site’s verified Copilot plan table is in the Copilot Enterprise reboot piece.

Sources

Last verified October 21, 2026. Pricing and feature gates change frequently — GitHub’s changelog and pricing pages are the authority; verify before purchasing.

Was this article helpful?

Know which coding tool is worth paying for

Hands-on comparisons of AI coding assistants and what each one costs to run — including the local-model path. Sent only when something changes. Unsubscribe anytime.