The most advanced AI models on the planet are very good at finding ways to break software. We point them at ours.
Eightfold is one of a small number of companies with sanctioned, frontier-level access to use these models for offensive security. We participate in OpenAI Daybreak and Anthropic’s Cyber Verification Program, we run the latest open-weight models in our own testing workflows, and we sit close enough to the labs to see AI-powered cyber defense evolve week over week, not quarter over quarter. That is a front-row seat most security teams never get.
But access was never the point. The point is what you do with it. We take these models and set them loose on our own systems every single day: reading our code, exploring our running applications, and hunting for vulnerabilities the way a determined researcher would, before a real one does. And because we validate what they find against the live application rather than stopping at a suspicious line of code, we have cut false positives by roughly 85%, with many findings now arriving complete with screenshots and video of the exploit in action. The result is a pentesting program that runs at machine speed and holds up to human scrutiny.
In our last engineering post, How we’re enhancing Eightfold security in the AI era, we walked through the ten AI-driven security capabilities we run in production, many of them as automated gates on every change we ship. AI-driven pentesting is one of them. This post goes deeper: where frontier AI is already changing traditional security testing, where it still falls short, and how our human pentesters and outside researchers cover the rest.
Why we stopped choosing between fast and thorough.
Ask any security team and they’ll tell you the same old tension: automated tools are fast but shallow, manual pentests are deep but slow. For years that felt like a law of nature. You picked a point on the spectrum and lived with what you gave up.
At Eightfold, our products move fast, ship often, and touch sensitive candidate and employee data across a huge surface area: recruiter workflows, hiring manager tools, candidate-facing pages, admin consoles, integrations. A once-a-quarter pentest engagement was never going to keep pace with our release cycle and scope, and a scanner running on autopilot was never going to catch the subtle, human kind of bug that actually gets exploited in the wild. Rather than choosing one lane, we built a program that layers AI-driven testing, human expertise, and outside researchers on top of each other, each one covering for what the others miss. Here’s how it actually works, end to end.
Layer one: Let the AI go first.
The first pass at any given surface area is autonomous AI pentesting. We use Strix, in-house tooling, and Claude and GPT models to review code and explore the running application.
AI is already very good at finding suspicious code, but code alone doesn’t always tell you whether something is actually exploitable. A model may identify a path that looks vulnerable without understanding how the application behaves in production, which can create a lot of theoretical findings and false positives.
Our participation in OpenAI Daybreak and Anthropic’s Cyber Verification Program has helped us close that gap. Instead of stopping at a code-level finding, our workflows can attempt to validate the issue against the running application through headless exploration. That has reduced false positives by roughly 85%, and many findings now come with concrete evidence such as screenshots and video recordings showing how the issue can be reproduced. The result is a much better signal: fewer theoretical AI bugs, and more validated vulnerabilities that engineers can act on.
AI findings don’t get trusted blindly.
Even with much stronger validation, we don’t take the AI’s word for it. Findings are revalidated by a human before they are treated as real.
That step matters because AI can still get things wrong: a vulnerability may be reproducible but have limited impact, or the model may misunderstand some part of the application’s context. Today, roughly 75% of the findings that make it through our AI-driven testing workflow hold up as genuine, true-positive vulnerabilities. The rest are false positives or informational findings. That combination of automated validation and human review gives us a much stronger signal than code analysis alone.
Layer two: send in the humans.
Once the AI has done its pass and revalidation has separated signal from noise, our manual pentesters step in, but not to redo what the AI already covered. That would be a waste of some very expensive expertise. Instead, manual testing is aimed at the places where AI still struggles:
- Access control: the kind of “wait, should this role actually be able to see that?” logic that requires understanding intent, not just code paths.
- Business logic flaws: bugs that aren’t a broken function so much as a broken assumption baked into how a feature is supposed to work.
- Whatever else is still sitting on the AI’s coverage backlog: categories of bugs the automated tooling hasn’t been tuned to reliably catch yet.
This is really the heart of our Responsible AI philosophy. AI handles the breadth, humans handle the judgment calls that breadth can’t replace. Someone who understands what a hiring manager should be allowed to do, and can spot the one edge case where the product quietly lets them do more, is still doing something AI hasn’t fully learned to do on its own.
Layer three: let external researchers try to break us.
Internal testing, no matter how good, still has a blind spot. It’s internal. The people testing the product are, on some level, thinking about it the way the people who built it think. In this third layer of testing, we run a Vulnerability Disclosure Program (VDP) and a private bug bounty program, inviting external security researchers to surface vulnerabilities from angles our own teams might not think to try.
These programs matter precisely because outside researchers don’t share our assumptions. They don’t know which corners we think are safe. That outside-in pressure is a genuinely different kind of signal than anything AI or our internal pentesters produce, and it’s a check we take seriously.
Security doesn’t stop at the pentest, it lives in the SDLC.
All of the above describes a fairly traditional shape: test, revalidate, fix, with AI added to the mix. But we’ve also pushed AI further into the software development lifecycle itself, not just the testing phase bolted on afterward.
That means AI isn’t only looking for bugs during a designated testing window. It continuously analyzes changes and can revisit the running application even after code has shipped, giving us another layer of security coverage throughout the lifecycle.
The candid assessment. Neither side wins alone.
If there’s one clear takeaway from our process, it’s a fairly humble assessment: we don’t believe AI alone is enough, and we don’t believe humans alone are enough either.
Lean too hard on AI and you’ll miss the bugs it wasn’t built to see: the ones that require understanding intent, context, or a business rule nobody wrote down. Lean too hard on humans and you run into the oldest problem in security testing: people have limited hours, limited attention, and can’t manually re-check every corner of a product every time it changes.
As a result we don’t ask either one to do the whole job. AI gives us speed and relentless coverage. Human pentesters give us judgment in the places that need it most. External researchers give us a perspective we could never fully replicate internally. Put together, that’s not a compromise between fast and thorough. It’s actually both, which is the whole point.
Visit our Trust Portal for a closer look at our commitment to security, compliance, and transparency at every level.