The conversation around AI in cybersecurity often feels untethered from reality. We hear endless speculation about what models might be capable of, or how they will eventually revolutionize the industry. But there is a massive gap between the hype and the engineering reality: what can Large Language Models (LLMs) actually find in production code today?
We wanted to move beyond the theoretical. Instead of focusing on potential, our team at Intruder set out to answer a practical engineering question: using tools accessible right now, how far can we push AI to uncover genuine, exploitable vulnerabilities in real-world software? The result of this effort is a technical pipeline we call the "vulnerability vending machine"—a system that, fully autonomous, discovered its first multi-stage zero-day in a popular WordPress plugin.
The Hidden Problem with Naive AI Scanning
When you ask engineers how they use AI to find security bugs, the most common (and least effective) approach is simply pointing a general-purpose LLM at an entire codebase. This seems intuitive, but it is fundamentally flawed.
LLMs excel when you give them precise, limited context. If you present a clearly defined 50-line function and ask whether a vulnerable input can reach a sensitive sink, the model performs admirably. Throw a multi-megabyte repository at the same model, and the result is predictable: failure.
This approach is doomed by token inefficiency and context dilution. The model struggles because it is forced to ingest every file in the directory. By the time it processes the relevant code, its context window is overflowing with thousands of lines of irrelevant information. The actual vulnerability becomes buried under noise, leading to high false-positive rates and missed bugs. For more complex, chained vulnerabilities, the LLM lacks the necessary focus to map out the required logic, resulting in poor-quality outputs that fail to identify anything exploitable.
Slicing Code: The "Vending Machine" for Vulnerabilities
The secret to making this work isn't just a bigger or smarter model. It is about how you feed that model. We needed a way to provide only the code that matters.
We adopted a concept used in mature development environments: program slicing. Think of the "find implementation" or call-graph features in your favorite IDE. By leveraging these techniques, we can extract a targeted "slice" of the code—a concise, context-rich subset that contains the potential vulnerability and everything that leads up to it—without the surrounding noise.
This creates a "vending machine" effect. You feed the pipeline a codebase, and it yields high-signal slices of code. This dramatically improves context quality for the model and, crucially, minimizes token consumption.
Engineering the Agentic Pipeline
Our pipeline architecture is modular, treating each part of the discovery process as a specific task for an specialized agent or tool.
- Code Scanning and Slicing (Joern): We run the target codebase through Joern. Unlike overly restrictive static analysis rules, we use broader, "interesting" patterns to flag potential attack surfaces, such as REST routes, template hooks, and unauthenticated AJAX calls.
- Generating the Slice: For each potential entry point identified by Joern, the framework generates a functional slice: the function itself, all called methods, and the full dependency chain down to an potential sink. Basic taint tracking is applied to prune obviously safe paths, such as those passing through established, secure sanitizers.
- Triage (Sonnet): The remaining slices are passed to a lightweight model (Sonnet). Its job is triage—filtering out "obviously safe" or irrelevant code paths, like public hooks that lack side effects.
- Assessing Exploitability (Opus): High-confidence findings then go to a heavier model (Opus). Because we have already pruned the code to essential slices, Opus operates with the full, relevant call context in memory, allowing it to perform a much deeper analysis of the code and potential exploit chains.
- Autonomous Exploitation: Finally, an exploitation agent takes any issue judged to be exploitable. This agent can search the source code further if needed and, critically, maintains its own Docker environment to test and verify the exploit in real-time.
Real-World Impact: Automating CVE-2026-3985
Does this work on hardened, well-traversed code? To test this, we pointed the pipeline at the top 200 WordPress plugins. These are codebases that have been heavily picked over by bounty hunters and existing security tools.
The outcome exceeded our expectations. The pipeline vended CVE-2026-3985, a multi-stage, unauthenticated SQL injection in the Creative Mail WordPress plugin.
This wasn't just a low-signal alert. It was a high-impact, actionable finding. The bug required chaining several requests to successfully exploit, making it significantly harder for traditional, signature-based tools to detect. Furthermore, the root cause was obscured—even from the developer's static analysis tools—by a subtle mistake in the plugin's code logic.
The exploitation agent successfully generated a proof-of-concept that not only confirmed the vulnerability but also demonstrated a full extraction method capable of pulling database information, including admin hashes. It was, in every sense of the word, a zero-day discovery, fully automated.
How Artificial Intelligence Cybersecurity Tools Are Changing the Game
As we look at security Practices across the industry, it is clear that we are in a rapid transition. From startups to legacy giants like IBM, the focus is shifting from manually driven security to more automated, high-speed discovery techniques.
The "vulnerability vending machine" proves that agentic systems, when correctly architected, can perform at a level that competes with skilled human researchers. This discovery speed is not just an advantage for defenders; attack automation is advancing just as quickly. The tools we used—LLMs, Joern, and specialized agents—are becoming widely available.
The ultimate goal, and the reason we've built this system, is simple: securing systems ahead of threat actors. The vulnerabilities surfaced by our pipeline are being turned into new detection checks within the Intruder platform. For us, this isn't just about building a cool demonstration; it’s about ensuring that detection capabilities advance just as rapidly as the threats themselves.
We have a complete picture of the landscape: discovery is moving faster than ever. It is up to security engineering to build tools that ensure our Defenses can keep pace.
<br> twentyTaskId: f897213f-ffa9-447d-b60e-ee1a4922c652
