Cloudflare Open-Sources Security Audit Skill: AI Agents That Hunt and Verify Vulnerabilities
Cloudflare Open-Sources Security Audit Skill: AI Agents That Hunt and Verify Vulnerabilities
AI coding tools can write code quickly, but can they reliably find security vulnerabilities without generating false alarms? Cloudflare is tackling this challenge with Security Audit Skill, an open-source tool that turns compatible coding agents into structured security auditors.
Available on GitHub under the MIT license, the project coordinates multiple AI agents to investigate a codebase, search for vulnerabilities, independently challenge suspected findings, and produce structured security reports. Unlike a simple prompt asking an AI to review code, it follows a multi-phase auditing workflow designed to improve coverage and reduce false positives.
Repository: Cloudflare Security Audit Skill on GitHub
What Is Cloudflare Security Audit Skill?
Cloudflare's Security Audit Skill is an open-source skill for AI coding agents that supports multi-phase security audits of software repositories. It provides the instructions, attack-class references, validation scripts, and report schemas needed to organize a more systematic review.
The project grew out of the security-auditing approach behind Cloudflare's vulnerability discovery work. Its goal is to make a single-repository version of that workflow available to developers rather than relying on an unstructured AI conversation.
The skill is designed for coding agents that support tool use and parallel sub-agents. It is not a standalone vulnerability scanner or a replacement for conventional security tools. Instead, it guides an AI agent through an auditable process for examining code and evaluating evidence.
How Does It Work?
The skill organizes an audit into six phases, moving from understanding the application to verifying the final report.
1. Reconnaissance: Understand the Codebase
Before hunting for bugs, the agent maps the application's architecture, entry points, trust boundaries, and areas where untrusted input enters the system.
It records its understanding in artifacts such as architecture.md and coverage-ledger.json. The coverage ledger helps track which parts of the application have been examined and which remain unexplored.
This matters because security bugs are often hidden in interactions between components rather than in isolated functions.
2. Coverage-Led Vulnerability Hunting
Instead of searching the entire repository without a plan, the skill divides the work into specific areas and assigns isolated hunting tasks to agents.
The audit can examine relevant vulnerability classes based on the target's architecture, including:
Authentication and authorization failures
Tenant-isolation problems and cross-customer data access
HTTP request handling and protocol inconsistencies
Prompt injection and unsafe AI-agent tool interactions
Client-side injection and browser trust boundaries
Dependency, build, release, and supply-chain risks
Cloud configuration, deployment, and resource-exhaustion issues
The skill includes specialized attack-class guidance so the audit can focus on the threats relevant to a particular application. A web application and a native application, for example, do not need identical security checks.
3. Independent Validation: Challenge Every Finding
One of the project's most important design choices is separating vulnerability discovery from vulnerability verification.
When a hunting agent identifies a possible issue, a fresh verifier examines the evidence and tries to disprove the claim. The verifier should not simply accept the original agent's conclusion.
This helps address a common weakness of AI-generated security reports: a model can mistake suspicious-looking code for an exploitable vulnerability, invent a missing condition, or confuse expected behavior with a security flaw.
A reportable finding needs a source-grounded trace and an observed result that supports the claimed security impact. If the evidence is incomplete, the skill can leave the finding unresolved rather than presenting it as confirmed.
4. Structured Findings Instead of Unverified Claims
The skill records findings in a machine-readable format and validates them against its report schema.
It distinguishes three verdicts:
Confirmed: Evidence establishes the vulnerability and its impact.
Needs validation: A potential issue has been identified, but a specific fact remains unresolved.
Rejected: The candidate was investigated and disproved.
Unresolved candidates do not receive a severity rating as though they were confirmed vulnerabilities. This distinction makes the output more useful for engineering teams that need to prioritize real security risks.
5. Independent Verification of the Final Records
The workflow goes beyond validating a candidate once. Fresh agents also review final source claims, and significant replacements to findings receive another independent verification step.
The repository includes JavaScript validators for both the findings and the coverage ledger. These help enforce structural requirements and evidence consistency.
The result is a report backed by a defined process rather than a list of potentially alarming statements generated by a single model.
6. Generate the Final Security Report
The workflow produces human-readable reports from the verified findings and coverage records. Its outputs include:
REPORT.md— the main audit reportFINDINGS-DETAIL.md— detailed vulnerability evidenceNEEDS-VALIDATION.md— unresolved candidates that need additional evidence
It also retains machine-readable records in findings.json, allowing developers to inspect the results or integrate them into their own reporting workflows.
Explore the implementation in the official repository.
How to Install Security Audit Skill
You can install the skill using the Skills CLI. You'll need a compatible coding agent with tool use and parallel sub-agent support.
First, install the skill from your terminal:
npx skills add https://github.com/cloudflare/security-audit-skill \ --skill security-auditFor a user-level installation that is available across projects, use:
npx skills add https://github.com/cloudflare/security-audit-skill \ --skill security-audit \ --globalThe exact installation and agent-selection options may depend on your environment. Refer to the official installation instructions for the latest guidance.
Run Your First Audit
Start your coding agent in the repository you want to examine, then ask it to perform a security audit.
For example:
Perform a security audit of this codebase.Map the architecture and trust boundaries, hunt forvulnerabilities, independently validate each candidate,and generate a structured report with evidence,impact, severity, and remediation guidance.You can also target a specific directory or request that the output be written to a particular location. By default, the skill writes audit results outside the target repository.
An Important Requirement: Safe Execution
Security-auditing tools sometimes need to build or test a target application to determine whether a suspected vulnerability is exploitable. Running untrusted project code carelessly can itself create a security risk.
Cloudflare's skill requires an OS-enforced sandbox before executing target-controlled builds, tests, processes, browsers, emulators, fuzzers, or fixtures. The documented controls include:
External networking disabled
A sanitized, allowlisted environment
CPU and memory limits
Restricted write access to designated scratch paths
The skill does not provide the sandbox itself; developers must configure suitable isolation separately.
Without the required controls, a candidate that needs execution-based proof should remain marked needs_validation instead of being treated as a confirmed vulnerability. This is an important limitation to understand before running the skill against an unfamiliar repository.
Is It Better Than a Traditional Security Scanner?
Security Audit Skill and conventional scanners address different parts of the security workflow.
| Capability | Security Audit Skill | Traditional scanners |
|---|---|---|
| Architecture-aware investigation | AI-guided and coverage-led | Depends on the scanner |
| Vulnerability discovery | Agent-based investigation | Rules, signatures, analysis, or specialized testing |
| Independent challenge of findings | Built into the workflow | Varies by product |
| Machine-readable reports | Included | Common in established tools |
| Runtime testing | Requires safe external isolation | Depends on the tool |
| Guaranteed vulnerability detection | No | No |
The practical advantage is the ability to combine architectural reasoning with a repeatable process for challenging and documenting findings. However, the skill does not guarantee that every vulnerability will be discovered, and it should complement rather than replace static analysis, dependency scanning, conventional testing, and expert review.
Cloudflare also notes that repeated audit runs can uncover additional vulnerabilities missed during earlier passes. A single successful run should not be interpreted as proof that a codebase is secure.
Who Should Use It?
Security Audit Skill may be useful for:
Full-stack developers who want a deeper security review before deployment.
Open-source maintainers who need a repeatable process for investigating reported vulnerabilities.
Security engineers who want AI agents to assist with source-code investigation and evidence gathering.
AI application developers working with tools, agents, prompt processing, and untrusted inputs.
Teams building multi-tenant SaaS products that need to examine authorization boundaries and customer-data isolation.
For example, a multi-tenant SaaS developer could use the workflow to investigate whether one customer can access another customer's records, whether webhook validation is sufficient, or whether an authorization check is consistently enforced across API routes. The results still need to be verified against the actual application and its deployment environment.
Is Cloudflare Security Audit Skill Free?
The repository is available under the MIT license, making the skill itself open source. You can inspect the implementation, adapt it, and use it subject to the license terms.
However, running it may involve costs associated with your coding agent, AI model usage, compute resources, and sandbox infrastructure. Open source does not necessarily mean that every part of the audit workflow is free to operate.
Read the MIT license and repository files before incorporating the project into your own tooling.
Final Thoughts
Cloudflare's Security Audit Skill demonstrates a useful direction for AI-assisted application security: moving beyond a single prompt and organizing the work around coverage, independent verification, structured evidence, and reproducible reporting.
Its strongest idea is not simply using more AI agents to search for bugs. It is making those agents challenge one another's conclusions and distinguishing confirmed vulnerabilities from unresolved leads.
For developers, it offers an interesting way to strengthen code reviews and security testing. But it remains an aid to security engineering, not a guarantee of safety. Proper sandboxing, repeated audits, conventional security tools, and human review remain essential.
Explore the project: GitHub — cloudflare/security-audit-skill