All articles

How Chainguard’s frontier AI harness keeps your code safe

Patrick Donahue SVP, Product

The last few weeks made the consequences of frontier AI getting good at finding software vulnerabilities impossible to ignore.  There are far more exploitable bugs hiding in plain sight than most of us assumed, and attackers found plenty of them before most orgs did. The time between knowing a bug exists and someone exploiting it is shrinking fast.

Last month at Chainguard Assemble London 2026, we announced Chainguard’s harness to help organizations deal with this change, and we’ve already received a ton of interest from teams interested in using frontier AI to keep themselves safe before attackers can strike. I’ve spent the last few months talking with security and engineering leaders about what this all means for their teams. Nearly every conversation lands in one of three places.

You’re scanning your apps with frontier models and drawing in findings

Some teams already have access to the most capable models. They point them at their code and get back thousands of potential vulnerabilities. That’s when the hard part begins. Which of these can be exploited? Are any of them false positives? Who writes the fix? Will the fix break something else?

Triage of sometimes tens of thousands of zero-days isn’t something a security team absorbs in a normal week. I’ve talked with organizations bringing on hundreds of contractors just to work through the backlog. A long list of possible problems is not the same as knowing which exploitable issues you should fix first.

You’re scanning with publicly available models and getting mediocre results

Other teams are using publicly available models from the AI labs or open-weight models to hunt for zero-days. That helps, but it puts you on even footing with attackers using the same models. A few open-weight models are now quite good at writing exploits, and anyone can download them. If your tooling is about as capable as what attackers can get for free, it’s harder to stay ahead of them.

You’re using traditional scanners that have lots of false positives

Scanners are useful, but each kind has limits. Software composition analysis (SCA) matches your dependencies against a database of known CVEs, so it can’t tell you about a bug nobody has reported yet. Static and dynamic application testing (SAST and DAST) can surface new issues, but they can come with high false-positive rates, and they rarely tell you whether a finding can be exploited in your running application or reliably reproduced.

All three teams face the same problem

While the details differ, the problem underneath is the same. Most teams are not using frontier AI models, with the right guardrails, to both scan their running application and analyze underlying source code. Frontier models are finding bugs that can chain together first- and third-party issues that become exploitable and dangerous.

Teams need to use offensive security that both finds exploitable, chained vulnerabilities with effective recommendations for how to fix them. This avoids teams having too many findings they can’t trust, not enough capability to keep pace with attackers, or no view of the unknown bugs at all.

Thinking like an attacker is the best way to keep yourself safe. That’s why we built Chainguard Harness.

How Chainguard’s harness works

Chainguard Harness builds your application from source, exactly as it ships, inside an isolated microVM with no credentials and no network egress. Inside that sandbox, frontier AI models from Anthropic, OpenAI, and Google attack the live, running app the way an attacker using an agent swarm would. It hunts for real exploits in your first-party code and in the open source code you depend on, including logic flaws, injection, resource exhaustion and other runtime bugs that static analysis misses.

When it finds something, our harness replays the exploit in a fresh sandbox. If it doesn’t land every time, it doesn’t make the report. This ensures you stay focused on the exploitable, reachable vulnerabilities that need to get resolved. Chainguard then writes a fix specific to your codebase and confirms it works: the exploit has to succeed against your current code and fail against the patched version. A Chainguard engineer reviews every finding and fix before it goes to you.

What you get is a short list of proven vulnerabilities, each with steps to reproduce it and a fix ready for your team or an AI agent to tackle and merge. If the flaw is in an open source dependency rather than your own code, we handle coordinated disclosure with the upstream maintainers so your team doesn’t have to permanently live on a private fork.

What changes for your team

  • Your engineers spend their time on vulnerabilities that are proven exploitable, not on sorting through alerts.

  • You get validated findings with accompanying fixes, so patching becomes a code review instead of a research project.

  • You get frontier-model results without needing to apply and wait for your own model access, building and securing your own harness, or spending tokens and headcount getting it to work.

Chainguard’s harness is also available through the Claude Marketplace by Anthropic. You can allocate part of an existing Anthropic commitment toward finding and fixing exploitable vulnerabilities.

Go on offense

Attackers are already using AI to look for weaknesses in your applications. You can wait for them to find what’s there, or find it yourself and fix it before they can strike. Join the waitlist for Chainguard’s harness today.

Share this article

Start building with Chainguard