GitHub's Agentic Autofix Goes GA: The Free One-Click Fix Is Replaced, AI Credits Billing Begins

One boundary to draw up front: our cycle52 piece on Chainguard Harness (AI vulnerability hunting, first blood: a real vLLM bug, slug: chainguard-harness-ai-vulnerability-hunting-october-2026) covered a third-party AI product on the finding side — discovering real vulnerabilities. This piece covers the other half: GitHub's own platform turning fixing vulnerabilities into a standard, metered workflow. One is the finding side, one is the fixing side; together, the agent completes the "point at the problem → open the PR" loop.

On October 15, 2026, GitHub published a new entry in its official changelog: Agentic autofix for code scanning alerts general availability (Additional Details on the page show Published: 2026-10-15T06:49:20-07:00 — the evening of October 15 in Beijing). In one sentence: GitHub's agentic vulnerability autofix is now GA — security alerts can be assigned straight to Copilot, which explores across the codebase, generates fixes, re-runs CodeQL to verify, and opens a draft PR. At the same time, the free one-click "Generate Fix" button is gone, replaced by per-AI-Credit billing.

The real weight of this story isn't "fixing vulnerabilities" itself — Copilot helping fix code is no longer a new concept. The weight is in two things: first, agent-driven vulnerability fixing graduated from "experiment" to "standard workflow" (GA); second, the security agent officially became a SKU-level line item — a new row on the enterprise bill. "AI reviewing code for humans" just walked out of the demo and into the billing system for the first time.

The workflow: a complete loop from "assign alert" to "open draft PR"

The changelog describes a six-step flow — a complete agent workflow worth unpacking step by step:

• 1. Assign the alert to Copilot. In the security alert list, alerts get assigned to Copilot (the old free "Generate Fix" button is replaced by "Assign to Copilot").
• 2. Explore related files across the codebase. Copilot doesn't just stare at the flagged lines — it goes looking through the repo for related files and call chains. That "exploration" step is the fundamental difference between agentic and template-based fixing.
• 3. Generate the fix. Code fix generated from what exploration found.
• 4. Re-run CodeQL to verify the alert is closed. The most important step in the whole flow: after fixing, the scanner runs again to confirm the alert is genuinely gone before proceeding. Verification isn't "looks fixed" — it's "the scanner says closed".
• 5. Iterate. If the alert survives, keep fixing and re-verifying until it passes.
• 6. Open a draft PR. The PR carries three things: a fix summary, an explanation of why this fix closes the alert, and the verification steps. Once the PR is ready, you can keep iterating in comments or the Agents tab.

Steps 4 and 6 are the soul of this design. Step 4 (re-run verification) binds "fix" and "verify" together: the agent can't generate and walk away — the delivery bar is "the scanner nods". Step 6 (PR with explanation and verification steps) keeps the human-in-the-loop in the right place: humans don't need to watch the agent's every move; they only need to judge at the "review the PR" checkpoint — and the PR already explains "why this fix works" and "how it was verified", so reviewers judge "is the fix right", not "did the agent slack off".

On "explore": the real difference between agentic and template-based

Step 2, "explore related files across the codebase", deserves its own section — it's where the word "agentic" earns its keep. Traditional autofix (like an IDE quick-fix) is template-based: the alert says "SQL injection here", the template stamps a parameterized-query pattern onto that spot. It doesn't care about the call chain, where the parameter comes from, or whether the fix breaks something else.

Agentic fixing works in reverse: explore first, then touch. Copilot maps the vulnerability's related files and data flow — where data enters, where it exits — then fixes, then re-scans to confirm. The quality floor changes: template-based fixing is only as good as the template; agentic fixing is only as good as the exploration. The more complete the exploration, the more accurate the fix — which is why the changelog stresses "explore across the codebase" rather than "generate a patch at the alert location".

For vibe developers: when you have an agent change code, the first thing to ask isn't "how will you fix it" but "go find every related file first". Exploration up front is the first insurance against agent-caused chaos. GitHub's official flow puts exploration at step 2, before generating the fix — that ordering is the answer.

The three things in the PR: "exam materials" for the reviewer

Step 6's required trio — fix summary, why-it-closes-the-alert, verification steps — is essentially exam material for the reviewer. Agent PRs used to get roasted for "nobody knows what it did": a wall of diff, no explanation, reviewers guessing line by line. Now GitHub mandates three things in the PR:

• Fix summary: what changed, one-sentence version.
• Why it closes the alert: the argument, not a description. Reviewers check "is its reasoning right".
• Verification steps: how "fixed" was proven — which scan re-ran, what it said. Reviewers can re-run it themselves.

Together they cut review's cognitive load from "read the diff and guess intent" to "check the argument and the verification". Agent-era PR conventions are evolving from "write clear code" to "write clear arguments". Vibe developers can demand the same trio in PR descriptions from their agents — reviewers (you, or your colleagues) will have a much easier time.

For vibe developers, this is the template for "what an agent workflow looks like" — a reference design. Explore → fix → verify → open PR → keep iterating: five stages. Any "have the agent change code" task you run can reuse it: explore first (don't rush to write), then fix, then a mandatory independent verification step (tests, scans, lint — anything), and keep the output at a reviewable grain.

Real product screenshot: Copilot Autofix suggesting a fix for a CodeQL path-traversal alert

The billing switch: the free one-click fix is replaced; the security agent becomes a SKU

The most commercially telling change in this GA is billing:

• The free "Generate Fix" button is replaced by "Assign to Copilot". One click used to fix for free; assigning to Copilot now meters. An era ends: the free-trial period for AI code fixing is over.
• It consumes two things: AI Credits from the Code Security budget, plus GitHub Actions minutes. Note the "two": model inference burns AI Credits, running verification (the CodeQL re-run) burns Actions minutes — verification has a cost too.
• A new "Advanced Security" product line appears under "AI usage" on the enterprise bill. The security agent gets its own name on the invoice for the first time instead of hiding inside some "AI usage" bucket.
• SKU-level budgets are supported. Enterprises can cap Advanced Security separately — spending governance at SKU granularity.

Read together: GitHub is turning the "security agent" from a feature into a priced, budgeted, auditable SKU. It's the standard move of agent commercialization — free first to build the habit (the Generate Fix era), then GA with metering (the Assign to Copilot era), then full budget controls for enterprises (SKU-level budgets). In 2026, billing models are maturing as fast as capabilities.

The dual cost structure: AI Credits + Actions minutes

The billing detail most worth chewing on is "consumes two things": AI Credits (model inference) and Actions minutes (running verification). The two map onto two workflow stages: step 3's fix generation burns Credits; step 4's CodeQL re-run burns Actions minutes.

That dual structure reveals a truth: an agent workflow's cost isn't just "model inference" — it's "verification" too. And verification cost is rigid — you can't skip step 4 to save money; skip it and the whole fix-verify loop breaks. So budget agent workflows on both lines separately. GitHub billing the two apart is market education: verification isn't a free garnish; it's a first-class citizen of the workflow.

For vibe developers: your own agent workflows work the same way — tests, lint, scans, the "verification" steps burn CI minutes/time, not tokens. When costing things out, don't count only tokens; verification overhead is chronically underestimated. GitHub's billing design is a ready-made textbook on "agent workflow cost structure".

Set against our earlier Simon Willison piece on hard budget caps: Willison covers "how individuals/teams cap agent spending" (user-side discipline); GitHub covers "how the platform productizes spending" (supply-side). One is self-restraint, the other is the meter — both maturing in October 2026. Not a coincidence: it's the sign that the agent economy has entered its list-price era.

Real product screenshot: Copilot Autofix suggesting a fix for a CodeQL path-traversal alert

Batch mode: 25 alerts in, one PR out

GA also ships an official "use the agent as a batch repair crew" pattern:

• From the security alert list or a security campaign, select up to 25 alerts at once, assign to Copilot, and get one draft PR back.
• Scripted assignment via REST API: assignees=["copilot-swe-agent[bot]"] — dispatch work in scripts.

"25 alerts → 1 PR" is a carefully chosen design. Not "25 alerts → 25 PRs" (reviewers would riot), not "unlimited batching" (the agent would drift). 25 is a "still reviewable" batch ceiling: one PR fixing 25 similar issues lets reviewers pattern-match — "these 25 are the same SQL injection class, same fix shape". Agent batch capacity and human review capacity meet at a balance point here.

Scripted REST assignment means security teams can wire "fix vulnerabilities" into a pipeline — scan weekly, auto-dispatch 25 to Copilot weekly, review the PR Monday morning. Vulnerability fixing goes from "human-scheduled" to "cron job". That's what workflows look like once agents land inside enterprise security flows: the workflow itself gets reshaped.

What indie developers can copy: a homegrown fix-verify loop

Agentic autofix needs Enterprise Cloud plus an admin-enabled policy — out of reach for personal projects. But its five-stage shape (explore → fix → verify → open PR → keep iterating) can be copied today with three free ingredients:

• 1. Explore before touching. With whatever agent you have (Copilot, Claude Code, anything), make it "find every related file and explain the call chain" before changing code. That's the homegrown step 2.
• 2. Independent, automatic verification. After fixing, run your tests/lint/scans — the homegrown step 4. The key word is "independent": verification can't be the agent saying "looks good to me"; it must be an external check the agent can't edit.
• 3. The PR-description trio. Have the agent write "what changed, why this fix, how it was verified" in the PR description — the homegrown step 6. Future-you will thank present-you when revisiting why it was done that way.

GitHub's GA version is the platform-grade implementation; yours is the workflow-grade one — same skeleton. When your project grows into Enterprise territory, migration is seamless, because you've been working in that shape all along.

Limits: not everyone can use it, and it can't fix everything

GA doesn't mean no gates. The changelog and cross-coverage list a string of limits:

• Only default-branch alerts can be assigned. Alerts from PRs or other branches are out — the agent only fixes what's on main, i.e., "the code that's live".
• Enterprise admins must enable the "Agentic autofix" policy first and define Copilot billing. Personal projects need not apply; this is Enterprise Cloud fare. No policy, no button.
• Verification has a boundary (via dev.to's independent technical writeup, relaying changelog/docs details): the re-run covers the default CodeQL query set; fixes for custom queries, security-extended, or third-party tool alerts can't be auto-confirmed. Translation: "a green PR proves the alert closed, not that the fix is right" — outside the standard queries the verification loop is broken, and reviewers should look harder.

The last one is the most worth remembering. It draws an honesty line for every "agent autofix" product: auto-verification is only as good as the verifier's coverage. Within CodeQL's default queries the agent may claim "fixed"; beyond them it can only say "I changed it, you look". Vibe developers using any autofix tool should first ask: what does its "verify" verify? The verifier's scope is the scope of its guarantee.

Judgment calls: the agent graduates from "pointing at problems" to "opening PRs"

Judgment zone below; facts and opinions marked separately.

Call one: the "find vs. fix" loop is now closed. Our cycle52 Chainguard Harness piece was the finding side: a third-party AI hunter drawing first blood on a real vLLM bug. This piece is the fixing side: GitHub turning fixing into a standard platform flow. Together, the agent's security chain reads: find (hunters like Harness) → fix (fixers like agentic autofix) → verify (CodeQL re-run) → human review (PR). Before October 2026 that chain was scattered; after GA it's connected inside GitHub's platform. Security work's "last mile" (the fix) has an official answer for the first time.

Call two: the security agent becoming a SKU means "AI security spend" is officially an enterprise budget line. The "Advanced Security" product row on the invoice matters more than the feature. Enterprise budgeting logic: no line item, no budget; no budget, no purchase. With a SKU, security teams can legitimately budget an "AI vulnerability fixing" line next year. This GA looks like a feature launch; functionally it's GitHub establishing the category's budget line. Every agent-security vendor owes GitHub a drink — it widened the road.

One more knock-on effect of "establishing the line item": once the line exists, comparison shopping follows. This year GitHub's Advanced Security lists its price; next year customers will ask "how does your per-vulnerability fix cost compare to the competitor's". Agent security moves from "storytelling" to "unit-price wars", and the metering model (per vulnerability? per PR? per Credit?) becomes a competitive dimension. GitHub picked the dual track of "AI Credits + Actions minutes" first — that pricing anchor will likely be copied industry-wide, the way cloud "pay-as-you-go" was.

Call three: the end of free is a maturity marker, not bad news. "The free Generate Fix button is replaced" reads like a price hike; it's actually the product's coming-of-age from "experiment" to "serious". Free things enterprises won't depend on (could be cut anytime); paid things enterprises will build into process (SLA, budget, owner). Metering by AI Credits + Actions minutes lays the cost structure open: inference costs X, verification costs Y. That's healthier than "free but might vanish". For vibe developers: stop waiting for free agent-security tooling — after October 2026, the free lunch in this category is officially over.

Call four: October 15 was GitHub's "agent double-release day" — read them together. 6:49 AM: agentic autofix GA (the write surface: fixing, PRs, metering, enterprise gates). 7:16 PM: Copilot multi-repo chat (the read surface: cross-repo Q&A in Slack/Teams). Our two companion pieces in this batch (this one plus github-copilot-multi-repo-slack-teams-chats-october-2026) are best read as a pair: GitHub pushed Copilot's "mouth" (asking) and "hand" (fixing) one step each in a single day, with mirrored commercial strategy — the mouth goes wide (collaboration tools, cross-repo), the hand stays tight (single repo, single PR, per-Credit billing). Widen reads, narrow writes; the meter lands on the hand.

What's unsaid

What the changelog doesn't say: what 25-alerts-into-one-PR actually costs in AI Credits (the number enterprises care about most, ungiven); whether there's a published quality metric (what share of PRs merge first-try vs. get bounced — GitHub surely has the data, unpublished); when verification for custom CodeQL queries lands (the boundary dev.to flagged, no official roadmap).

One bigger question mark: agentic autofix currently only recognizes the default CodeQL query set — what about enterprises running heterogeneous SAST (Semgrep plus Snyk, say)? GitHub's answer is "get our own loop working first", but enterprise security reality is "tool sprawl". If third-party alert verification stays unfilled, agentic autofix's ceiling is "GitHub Advanced Security full-stack customers". That boundary decides whether it's "platform default" or "ecosystem option".

One last thought experiment for vibe developers: does your project have a fix-verify loop? Most personal projects look like this: the agent changes code, a human glances at the diff, it looks fine, merge — the "verify" step is missing. This GA's biggest lesson isn't "enterprise feature" but "workflow shape": every agent change deserves an external verification the agent can't edit. Tests, lint, a scanner — pick one; there's always one available. Starting today, add a "verify" to your agent workflow: near-zero cost, and the payoff is sleeping well.

Related reading: Chainguard Harness: AI vulnerability hunting, first blood on a real vLLM bug (the finding side); our companion piece in this batch, GitHub Copilot brings cross-repo chat to Slack and Teams (the other half of October 15's double release: the read surface); Linus on AI and kernel bugs (adjacent AI-reviews-code theme).

One-line summary: GitHub's agentic autofix GA marks "AI fixing code for humans" walking out of the demo and into billing — the free one-click fix is replaced, the security agent becomes an invoice SKU; the five-stage "explore → fix → verify → open PR" flow is the reference design for every agent code-changing workflow; but remember dev.to's line: a green PR proves the alert closed, not that the fix is right.