GitHub has made agentic autofix for code scanning alerts generally available, allowing GitHub Copilot to investigate security issues, generate code changes, validate proposed fixes and open draft pull requests for developers to review. Announced on October 15, 2026, the feature moves beyond generating a suggested patch for an individual vulnerability by allowing an AI coding agent to explore relevant files across a codebase and attempt an end-to-end remediation workflow.
The release targets organisations that want to reduce the time developers spend resolving security alerts while keeping humans involved in approving code changes. Teams can assign individual alerts to Copilot or select up to 25 eligible alerts for remediation in one pull request. However, the feature does not guarantee that every vulnerability will be fixed correctly. It requires appropriate security settings, consumes AI credits and GitHub Actions minutes, and still depends on developer review before changes are merged.
Key Takeaways
- General availability: GitHub announced the release of agentic autofix for code scanning alerts on October 15, 2026.
- Automated investigation: Copilot explores relevant files across a codebase instead of limiting itself to a single suggested code change.
- Validation: The agent reruns CodeQL to check whether the proposed change resolves the alert.
- Pull requests: Successful workflows produce a draft pull request with a fix summary and validation details.
- Bulk remediation: Teams can select up to 25 eligible alerts for a single pull request.
- Enterprise controls: Administrators must enable the feature through the applicable security policies and repository settings.
- Usage costs: Agentic autofix consumes Code Security AI credits and GitHub Actions minutes.
- Human review remains essential: Validation is best-effort, and generated fixes must be reviewed and tested before merging.
What Is GitHub Agentic Autofix?
Agentic autofix is an AI-powered workflow designed to help developers resolve security vulnerabilities identified through GitHub code scanning.
Code scanning tools examine source code for potential weaknesses, such as insecure data handling, injection risks and other patterns that could expose an application to attack. These tools can generate alerts when they identify code that may violate security rules.
Finding a vulnerability is only the first step. Developers must understand the underlying cause, identify the relevant code, make a change, test the result and confirm that the security issue has been addressed. In large projects, a vulnerability may depend on how multiple files, functions or components interact.
Traditional autofix tools often provide a suggested code change for a particular alert. GitHub’s agentic approach gives Copilot a broader task: investigate the codebase, determine a potential fix, validate the result and prepare the changes for review.
This makes the feature particularly relevant to teams managing large repositories with many security alerts. Instead of treating each alert as an isolated editing task, developers can delegate the initial investigation and remediation work to an AI agent.
However, agentic autofix is not the same as granting an AI system unrestricted authority to change production software. The workflow produces a draft pull request, leaving developers responsible for reviewing the changes and deciding whether to merge them.
How Agentic Autofix Works
GitHub’s workflow combines code analysis, AI-assisted investigation and validation. Once a developer assigns an eligible alert to Copilot, the agent follows several steps.
1. Investigates the relevant code
Copilot explores files associated with the alert and examines the surrounding code to understand the potential vulnerability. This broader investigation can help identify the source of a problem that is not obvious from the flagged line alone.
2. Generates a proposed fix
After investigating the code, the agent prepares a potential correction. Depending on the issue, that may involve changing the affected code or adjusting related files needed to address the underlying problem.
The proposed change is generated from the repository’s context and the security analysis. It is not a universal patch that can be applied identically to every project.
3. Reruns CodeQL
The agent reruns CodeQL to check whether the proposed change resolves the original code-scanning alert. If the validation indicates that the issue remains, Copilot can attempt further changes.
This step is important because code that appears correct to a developer or AI model may not actually remove the vulnerability detected by the scanner.
4. Opens a draft pull request
When the workflow reaches the pull-request stage, Copilot opens a draft pull request containing the proposed changes. The pull request includes a summary explaining the fix, why it is expected to resolve the alert and the validation steps performed.
Developers can inspect the changes, review the agent session and request further modifications through pull-request comments or the repository’s Agents tab.
The process aims to shorten the path from discovering a security issue to preparing a reviewable fix, while preserving the existing code-review process.
Developers Can Fix Up to 25 Alerts in One Pull Request
One of the release’s practical features is bulk remediation. GitHub allows teams to select up to 25 eligible code-scanning alerts and assign them to Copilot together.
Instead of creating a separate remediation workflow for every selected alert, the agent can work on the group and prepare a single pull request containing the proposed fixes.
This may be useful for security campaigns that identify multiple related vulnerabilities or for teams working through a backlog of alerts across a repository.
| Capability | How it works |
|---|---|
| Individual remediation | Assign a code-scanning alert to Copilot |
| Bulk remediation | Select up to 25 eligible alerts |
| Code investigation | Explore relevant files across the codebase |
| Validation | Rerun CodeQL and iterate where needed |
| Output | Draft pull request with fix summary and validation details |
| Follow-up | Request further changes through comments or the Agents tab |
Bulk processing can reduce administrative overhead, but it does not remove the need to assess each change. A pull request that contains multiple fixes may require careful review to ensure that the changes do not introduce regressions or interfere with one another.
The feature also has scope limitations. According to GitHub’s announcement, agentic autofix supports alerts on a repository’s default branch. Alerts detected only on pull requests or other branches cannot be assigned through this workflow.
How It Differs From GitHub Copilot Autofix
GitHub already offers Copilot Autofix, which generates suggested code changes for supported code-scanning alerts. Agentic autofix adds a more autonomous, multi-step workflow.
The difference is primarily in how the work is performed and delivered.
| Feature | Copilot Autofix | Agentic autofix |
|---|---|---|
| Main approach | Generates a suggested fix | Investigates and attempts to resolve alerts end to end |
| Codebase exploration | More limited, suggestion-focused workflow | Explores relevant files across the codebase |
| Validation | Depends on the supported suggestion workflow | Reruns CodeQL as part of the agent workflow |
| Output | Suggested change that developers can apply | Draft pull request prepared by Copilot |
| Bulk processing | Depends on the available workflow | Up to 25 selected alerts per pull request |
| Usage model | Does not consume agentic autofix AI credits | Consumes Code Security AI credits and GitHub Actions minutes |
The distinction matters for teams choosing how to manage security backlogs. A simple, well-understood issue may be suitable for a one-step suggested fix. A more complicated alert may benefit from an agent that investigates surrounding files and iterates on a proposed correction.
Agentic autofix also introduces additional usage costs. Organisations should therefore consider the complexity and value of each remediation task when deciding how to use the feature.
Who Can Access Agentic Autofix?
GitHub’s October 15 announcement identifies GitHub Code Security and GitHub Advanced Security customers on GitHub Enterprise Cloud, including GitHub Enterprise Cloud with data residency, as eligible customers for the general-availability release.
Access is controlled through administrative policies and repository settings. An enterprise administrator must enable the new Agentic autofix policy in Advanced Security policies. An organisation or repository administrator can then enable the feature in the relevant Code Security settings, subject to the higher-level policy.
A Copilot billing method must also be configured for the announced enterprise workflow.
Access arrangements can differ across repository types and account configurations. GitHub’s documentation also describes availability for eligible public repositories owned by personal accounts, so developers should check the current documentation and their repository’s settings rather than assume every repository has identical requirements.
The rollout does not mean the feature is automatically enabled for every GitHub user or every repository. Administrators retain control over whether the workflow is available to their development teams.
What Does It Cost?
Agentic autofix consumes AI credits from the organisation’s Code Security budget and uses GitHub Actions minutes. GitHub says the resulting AI-credit usage appears in the enterprise billing and licensing interface under the Advanced Security product.
Organisations can also set budgets for Code Security AI credits at the SKU level, helping administrators manage spending as teams use the feature.
These costs matter because autonomous remediation can involve several steps: investigating files, generating code, rerunning analysis and iterating when a proposed change does not resolve the alert.
The cost of a particular remediation session will depend on actual usage. Teams should not assume that every alert consumes the same amount of AI credits or that every attempt will succeed.
For security teams, the relevant calculation is whether the time saved by automating initial investigation and fix preparation justifies the usage costs, particularly when hundreds or thousands of alerts need attention.
Why AI-Powered Security Remediation Matters
Software teams face a persistent challenge: security tools can identify weaknesses faster than developers can always fix them.
A large organisation may maintain many repositories, each with its own dependencies, development priorities and release schedule. Security teams must identify vulnerabilities, assess their severity, assign responsibility and ensure that fixes are completed without disrupting software delivery.
When developers have limited time, lower-priority alerts can remain unresolved for extended periods. That creates a gap between discovering a security weakness and addressing it.
Agentic autofix attempts to narrow that gap by automating parts of the remediation process. Developers can delegate investigation and initial correction work while retaining responsibility for review and release decisions.
The technology may be particularly helpful for repetitive vulnerabilities, straightforward code changes and backlogs where the main obstacle is the time required to investigate each alert. More complex security issues may still require substantial human analysis, architectural changes or additional testing.
The feature is therefore best understood as a tool for increasing remediation capacity, rather than a replacement for secure development practices or experienced security engineers.
Why Validation Does Not Eliminate Security Risk
Although GitHub’s workflow reruns CodeQL, the validation is best-effort. Passing the relevant scan does not prove that a change is free from every security problem or that the software behaves correctly in all circumstances.
A fix might close the original alert while introducing a different defect. A change may also affect performance, compatibility or application behaviour in ways that a targeted security scan does not detect.
GitHub’s documentation specifically advises developers to review and test generated changes before merging. It also notes that the agent cannot confirm fixes for certain categories of alerts, including alerts from custom CodeQL queries, the security-extended CodeQL query suite and third-party code-scanning tools.
This is an important boundary. Automated validation can provide evidence that a specific security alert has been addressed, but it is not a substitute for broader testing, threat modelling or human judgement.
Organisations adopting the feature should continue to apply their normal review requirements, testing standards and release controls.
The Bigger Picture
GitHub’s move to general availability reflects the growing role of AI agents in software maintenance. Coding assistants are expanding beyond writing new functions to investigating bugs, modifying existing projects and handling multi-step engineering tasks. Security remediation is a natural extension because it involves identifying a problem, understanding the surrounding code, making a change and validating the result.
The value of agentic autofix will depend on whether it consistently produces useful fixes at a manageable cost. It could help teams reduce backlogs and direct experienced developers toward more complex issues, but it also introduces new requirements for usage management, code review and validation. Organisations will need to measure success through verified remediation outcomes rather than simply counting how many alerts an AI agent processes.
Looking Ahead
With general availability announced on October 15, 2026, eligible GitHub customers can begin enabling agentic autofix through the applicable administrative and repository settings. The next practical test will be how well it performs across different repositories, vulnerability types and development workflows, particularly when teams use it to process multiple alerts together.
For developers, the safest approach is to treat Copilot as a remediation assistant that prepares changes for review, not as an authority whose fixes can be merged without inspection. As AI agents take on more software maintenance tasks, the combination of automated investigation, repeatable validation and accountable human review will remain central to secure development.
Frequently Asked Questions
1. What is GitHub agentic autofix?
It is an AI-powered feature that lets GitHub Copilot investigate code-scanning alerts, generate proposed fixes, rerun CodeQL and prepare draft pull requests for developers to review.
2. When did agentic autofix become generally available?
GitHub announced general availability on October 15, 2026.
3. Can GitHub Copilot fix multiple security alerts at once?
Yes. Teams can select up to 25 eligible alerts and assign them to Copilot for remediation in a single pull request.
4. Does agentic autofix automatically merge code?
No. The workflow prepares a draft pull request. Developers remain responsible for reviewing, testing and deciding whether to merge the proposed changes.
5. Does agentic autofix cost money?
It consumes Code Security AI credits and GitHub Actions minutes. Organisations should review their billing configuration and budgets before enabling widespread use.
6. Does the feature guarantee that a vulnerability is fixed?
No. Validation is best-effort and does not prove that the entire application is secure. Developers should inspect and test the changes before merging them.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
