← Back to Vulnerability Identification Harness Reviews indexCISO / Security Architect voice

What a CISO Should Actually Take From Project Glasswing

A risk, governance, and bug-bounty-economics read on five AI vulnerability-discovery harnesses — where the controls are real, where the metrics still need work, and what this does to your existing disclosure and remediation programs.

The shared pattern behind five independent harnesses

I reviewed five implementations of AI-driven vulnerability discovery and remediation built around Project Glasswing — Visa’s Vulnerability Agentic Harness (VVAH), Capital One’s VulnHunter, the open-source STRIX pentest agent, Anthropic’s own reference implementation, the Defending Code Reference Harness (DCRH), and Cloudflare’s internal fleet-scale pipeline (its Vulnerability Discovery Harness and Vulnerability Validation System, VDH/VVS) — plus one unrelated system, Alibaba’s Open Code Review (OCR), as an outside check on whether the pattern holds beyond security work. My interest isn’t the model. It’s what changes in your risk posture, your bug bounty economics, and your disclosure obligations once one of these is pointed at your estate.

The premise, and why it’s a governance problem before it’s an engineering one

Anthropic’s announcement of Project Glasswing is explicit about the capability jump: an unreleased model found a 27-year-old OpenBSD crash and chained a Linux kernel privilege escalation, largely without human steering, and scored 83.1% against 66.6% for Anthropic’s own next-best model on a reproduction benchmark [7][10]. CrowdStrike’s CTO’s quote on the announcement page is the sentence I’d put in front of a board: “the window between a vulnerability being discovered and being exploited by an adversary has collapsed… what once took months now happens in minutes with AI” [7].

That statement is also a staffing problem before it’s a technical one. Roughly 4.8 million cybersecurity roles were unfilled globally in 2025 [12]; 59% of security professionals in ISC2’s 2025 survey were considering leaving the field entirely, and about half reported exhaustion just keeping current with the threat landscape [11]; 63% of CISOs personally witnessed or experienced burnout in the past year [14]. If discovery volume is about to scale the way Glasswing’s own numbers suggest — Cloudflare alone generated 20,799 raw candidates from their fleet [6] — the constraint you’re managing isn’t “can we find more bugs.” It’s “can triage and remediation capacity survive the discovery side getting this much faster.” Every dollar and headcount decision downstream of adopting one of these tools should start from that gap, not from the tool’s discovery accuracy.

What the controls actually look like, and whether I’d sign off on them

I looked specifically for what a security architect needs before approving one of these for production use: trust boundaries, blast radius if the model is adversarially manipulated, and whether remediation can happen without a human in the loop.

On trust boundaries, all five treat the scanned target as hostile, correctly. VVAH refuses to load a config.yaml found inside the scanned repository itself, specifically to prevent a committed file from redirecting model credentials or endpoints [1]. DCRH’s autonomous pipelines execute entirely inside gVisor on an egress-restricted network, with the only route out an allowlisted proxy [4]. VulnHunter’s independent verifier runs with no Bash and no network access at all — it cannot clone, fetch, or execute anything [2]. This is the right default posture for a tool whose entire job is to process attacker-relevant, potentially adversarial input, and I’d flag any implementation that didn’t start from “the target may contain prompt injection” as not ready for review.

On remediation, every implementation reviewed stops short of unsupervised merge, which is the control that matters most. VVAH’s post-scan agents never get Bash, on the stated reasoning that “a prompt-injected agent with a host shell would be RCE on the scanner” [1]. VulnHunter’s fixer edits only on a branch or worktree, with a human approval gate at every phase boundary [2]. DCRH wraps target-derived text reaching its patch agent in explicit <untrusted_data> markers, and its own documentation is careful to call this a mitigation, not a guarantee — every generated diff still needs human review [4]. This is the finding I’d lead a board update with: the industry-standard control right now is “human is the last gate before merge,” full stop, not “model output is trusted at any confidence threshold.”

On validation, the adversarial-review pattern is the strongest signal of engineering maturity I found. Cloudflare runs discovery and validation on deliberately different models so that one model’s output is judged by “an unbiased, adversarial third party whose sole job is to ruthlessly stress-test [the first model’s] assumptions” [6]. DCRH’s grading agent runs in a fresh container that receives only proof-of-concept bytes, never the finder’s reasoning [4]. If you’re evaluating a vendor or an internal team’s harness proposal, ask specifically whether the validator can see the finder’s chain-of-thought — if it can, you don’t have independent verification, you have the model checking its own work with extra steps.

The harness is itself an asset that needs a threat model — and most replication efforts skip this

The controls above concern what the harness does to the target. The risk I’d actually flag in an approval memo is what the harness is in its own right: a system that ingests hostile input, executes untrusted code, holds API keys and repo credentials, and stores working exploits for unfixed bugs in your own estate. If your team is standing up a copy of one of these — and several are open source, so they will — the following module-level risks each need an owner before it touches production code, because the architecture is free but the original authors’ threat model is not.

The discovery module ingests attacker-controlled input. The scanned repo can carry prompt injection; the mitigations (VVAH refusing an in-repo config.yaml [1], DCRH’s <untrusted_data> wrapping, which its own docs call a mitigation not a guarantee [4]) are necessary and insufficient. Require that target content can never reach a system-prompt position or select a model endpoint, and note this module usually has the widest tool access, so an injection here has the largest blast radius.

The validation module runs untrusted code by design. Arbitrary code execution is a feature here. gVisor plus allowlist-proxy egress (DCRH [4]) is the standard to hold to; Docker-alone and shared sandboxes (STRIX [3]) are weaker — a container escape is a host compromise, and shared isolation lets one poisoned target reach sibling work. Insist on per-run disposable sandboxes and default-deny egress; the egress path is the exfiltration path.

The remediation module with write access is the highest-severity failure mode. A prompt-injected fixer that can merge is attacker-influenced code in your repo. The controls every reviewed team kept — no shell for the fixer [1], branch-only writes, human merge gate [2] — are the ones I would make non-negotiable conditions of approval. This is also the module most tempting to over-automate for throughput, which is exactly where over-automation is most dangerous.

The findings store is a crown-jewel target and the least-protected module in the source material. A database of validated, unpatched vulnerabilities with working proof-of-concept exploits against your own systems is, if breached, a pre-qualified attack plan handed to an adversary. None of the reviewed docs fully specify protection here. Add controls the originals don’t: encryption at rest, access control at least as strict as your most sensitive incident data, and retention limits so fixed findings don’t linger as an exploit library.

The credential and customization modules are a secrets-exposure and insider-risk surface. Model keys and repo/CI tokens live in config; demand least-privilege, short-lived, read-only tokens and pinned model endpoints. And treat operator hooks — validator_hints.yaml / remediation_policy.yaml-style files [1] and Wishlist-style human-fulfillment requests [6] — as privileged changes under code review, because they can widen permissions or disable a validation gate without touching code.

For a memo: adopting one of these tools means onboarding a new high-value internal system that executes untrusted input, holds secrets, and stores exploit material. It belongs in your own asset inventory, your own pen-test scope, and your own incident-response plan — not treated as “just a scanner.”

The metrics gap you need to know about before you cite these numbers upward

Cloudflare is the only one of the five publishing a real funnel, and their numbers are genuinely strong: 20,799 raw candidates compressed to 7,245 actionable findings, with validation rejection rate improving from 40% to 11% as their pipeline matured [6]. Use those numbers carefully in any board or audit context, because Cloudflare states the limitation themselves: “there’s no labeled set of every real bug in a codebase, so any claimed recall number is entirely speculative” [6]. No team reviewed publishes a false-negative rate, and none can, honestly. VulnHunter’s dev-only benchmarking harness is the closest thing to ground-truth measurement in the group — it scores detection accuracy against a known-vulnerable corpus [2] — but that measures recall against known bugs, which is a different claim than “this tool won’t miss things.”

For a bug bounty program specifically, this cuts both ways. These harnesses are optimized for precision over raw recall — VulnHunter’s own stated design goal is “three real, proven bugs” over “three hundred maybes” [2] — which is good news for triage load but means you should not treat a clean scan as evidence of absence. Budget your bounty program’s payout curve and your own internal scanning cadence assuming these tools compress noise, not that they achieve completeness.

Where this changes your disclosure obligations, and where it doesn’t yet have an answer

This is the section I think matters most for a CISO audience specifically, because none of the five harnesses reviewed are built to handle it.

Every implementation assumes you own the merge button. That assumption is safe for first-party code — your own repos, your own release process, your own approval chain. It breaks the moment the harness correctly flags a vulnerability in a transitive open-source dependency you don’t maintain. And that’s not a rare edge case: roughly 24.78% of npm library versions are transitively affected by a known vulnerability, from only about 19.96% of libraries [19], and Log4Shell — still the clearest case study — left more than 80% of its 12,000+ affected Maven artifacts more than one dependency hop deep, meaning the affected project literally could not fix itself without an upstream party moving first [21]. Three years later, roughly 12–13% of Java applications and downloads were still running a vulnerable version [22].

Your embargo process needs to account for propagation time, and current norms don’t. Standard coordinated-disclosure windows — the Linux distros list’s sub-14-day standard [17], CERT/CC’s 45 days [17], Google Project Zero’s 90 days plus 14-day grace [16] — were all designed around a single maintainer shipping a single fix to a single set of consumers. None of them budget time for a fix to walk N hops of a dependency graph before it actually reaches the vulnerable code your harness flagged. If your internal disclosure SLA assumes “reported to fixed” maps cleanly onto industry embargo norms, that assumption doesn’t hold once the finding is transitive, and I’d revisit any SLA language that doesn’t distinguish first-party from transitive findings.

A meaningful share of your dependency graph has no one to disclose to at all. Black Duck’s 2026 OSSRA report found 49% of codebases contain components with no development activity in the past two years [23]; HeroDevs estimates at least 81,000 package versions across five major registries carry known CVEs on end-of-life lines that will never be officially patched [24]. For that slice, a harness can find the bug and even draft a technically correct patch, but there’s no maintainer to review a PR and no embargo to coordinate — your only real options are fork-and-maintain-yourself, replace the dependency, or accept the risk formally. None of the five harnesses I reviewed model this decision; they all assume “propose fix, human approves, done.”

Findings can’t yet be exchanged across tools or organizations in any standard way. Traditional static-analysis tooling solved this years ago with SARIF (Static Analysis Results Interchange Format), an OASIS-standardized format that lets scanners hand results to CI systems, ticketing tools, and each other in one common shape — GitHub’s code-scanning feature ingests SARIF natively [25]. Nothing comparable exists for AI-agent-generated findings: each of the five implementations packages its evidence differently, and there’s no way to require a vendor or an internal team to emit findings in a form your other tooling can consume without custom integration work. The practical consequence for procurement and audit: you cannot currently write “vendor must emit SARIF-comparable findings” into a contract, because the equivalent standard for agentic findings doesn’t exist yet, and validation status and PoC evidence stay tool-specific rather than portable. This is the other half of the open-source remediation gap above — even where a coordination layer for cross-organization fixes existed, it would have no common format to move findings through.

Funding is currently weighted toward finding more, not fixing what’s already found — and that’s a program-design signal, not just an industry critique. Project Glasswing’s own numbers: up to $100M in model usage credits for discovery, against $4M in direct maintainer-capacity funding [7]. If you’re standing up an internal program modeled on this, budget your own spend the same way you’d want the industry to: remediation and maintainer/triage capacity should scale with your discovery volume, not lag behind it as an afterthought. The Linux Foundation’s CEO makes the point directly in his own quote on the Glasswing announcement — open-source maintainers have “historically been left to figure out security on their own” [7], and that’s exactly the failure mode an internal program should be designed not to reproduce for your own downstream teams.

What I’d put in an approval memo

Adopt the pattern — separate finder from validator, cross-model or fresh-context review, no shell for post-discovery agents, human as the final merge gate — as a baseline control set; every mature implementation I reviewed independently converged on it. Do not accept a vendor’s or team’s recall or false-negative claims without asking directly how they’d know; none of the five I reviewed can actually answer that question honestly, and the honest ones say so. And build your remediation SLA and budget around the fact that first-party findings and transitive open-source findings are structurally different problems — one has a merge button you control, the other might not have a merge button at all.


References

  1. Visa, Visa Vulnerability Agentic Harness (VVAH), github.com/visa/visa-vulnerability-agentic-harness — open-sourced June 10, 2026 under the Apache License 2.0 (© 2026 Visa, Inc.). Reviewed design documentation.
  2. Capital One, VulnHunter, github.com/capitalone/VulnHunter. Reviewed design documentation.
  3. STRIX, open-source autonomous penetration-testing agent — architecture and design documentation reviewed for this piece. Reviewed design documentation.
  4. Anthropic, Defending Code Reference Harness (DCRH), github.com/anthropics/defending-code-reference-harness. Reviewed design documentation.
  5. Cloudflare, “Project Glasswing: what Mythos showed us,” The Cloudflare Blog, May 18, 2026.
  6. Cloudflare, “Build your own vulnerability harness,” The Cloudflare Blog, June 18, 2026.
  7. Anthropic, “Project Glasswing: Securing critical software for the AI era,” April 7, 2026.
  8. CyberGym cybersecurity vulnerability-reproduction benchmark result, cited via [7].
  9. ISC2, 2025 Cybersecurity Workforce Study.
  10. DeepStrike, “Cybersecurity Skills Gap Statistics for 2025.”
  11. Proofpoint, Voice of the CISO 2025, cited via industry burnout roundups.
  12. Google Project Zero, “Policy and Disclosure: 2025 Edition.”
  13. GitHub Blog, “Coordinated vulnerability disclosure (CVD) for open source projects.”
  14. “Original Sin of npm: A Study on Vulnerability Propagation in JavaScript Dependency Networks,” arXiv.
  15. Open Source Insights (deps.dev), “Understanding the Impact of Apache Log4j Vulnerability.”
  16. Vulert, “Log4Shell 2026: Is Your Application Still Vulnerable?”
  17. Black Duck / Synopsys, 2026 OSSRA Report.
  18. HeroDevs, “81,000 Open Source Package Versions Have Known CVEs and No Patch.”
  19. OASIS, Static Analysis Results Interchange Format (SARIF) v2.1.0, docs.oasis-open.org/sarif/sarif/v2.1.0.

Full source list, including all five harnesses’ architecture citations, in the companion piece: “Inside Project Glasswing: How Five Independent Teams Built the Same Machine.”