AdaCore: Build Software that Matters
Untitled design
Nov 19, 2026

Fuzzers vs. AI: Why the Future of High-Integrity Software is Hybrid

A recent benchmark article published by Google Project Zero (Fuzzers vs. AI: Comparing Fuzzilli and BigSleep on JavaScript Engines) has drawn attention to the ongoing debate within the software security community around the benefits of fuzzers Vs LLMs for finding software vulnerabilities. For the first time, researchers conducted a rigorous head-to-head comparison between a state-of-the-art coverage-guided fuzzer (Fuzzilli) and an agentic AI bug-finding system (BigSleep, powered by Gemini) running on a massive production target (Chrome’s V8 engine).

The Project Zero Benchmark

The headline takeaway from Project Zero was clear: AI agents and traditional fuzzers are not mutually exclusive—they are deeply complementary. Each tool surfaces unique vulnerability profiles that the other misses.

This conclusion aligns with our findings at AdaCore, and, upon evaluating the report, two specific observations stood out that speak directly to the core design philosophy behind GNATfuzz and our recently announced Hot-Spot workflow.

Solving the Directional Starting Point Problem

In the Project Zero report, the authors noted a key structural asymmetry in how AI agents and fuzzers operate:

"For each bug we collect the commit that (likely) introduced the bug, and ask the agent to review those changes just as in the production CI environment. Note that the other direction, trying to rediscover past BigSleep bugs with Fuzzilli is more difficult to set up, since fuzzers cannot easily be given a similar 'starting point'." — Google Project Zero

This observation hits the nail on the head regarding classic fuzzer limitations. Traditional coverage-guided fuzzers are exceptional at broad exploration, but when faced with vast codebases, they can waste hours or days in "blind exploration," struggling to find a directional starting point. Conversely, an LLM agent easily takes a code diff or commit history as a prompt. This limitation of traditional fuzzers is precisely what GNATfuzz Hot-Spot was designed to solve.

Instead of letting the fuzzer wander blindly through millions of execution paths, the Hot-Spot workflow ingests a static analysis report (SARIF format) or code diff and derives a "heatmap" of theoretical warnings. Hot-Spot then automatically traverses the call graph, finds an accessible fuzzable entry point, and launches a highly targeted dynamic campaign aimed squarely at that specific line of code. By supplying the fuzzer with a precise starting point derived from static analysis or code commits, Hot-Spot gives dynamic analysis the directional context it historically lacked.

The Anomaly Detection Oracle: Ada vs. Unmanaged Languages

Another interesting aspect of Project Zero’s study is its reliance on sanitizers like AddressSanitizer (ASan) as the primary bug-detection oracle. In unmanaged languages like C, C++, or JavaScript engines, fuzzers rely heavily on external sanitizers to detect memory corruption, buffer overflows, or use-after-free errors. Without a sanitizer attached, many C/C++ runtime anomalies execute silently without crashing the binary. In addition, there is another consideration here: the performance implications and soundness of this approach, which we investigated at length in this report, "Secure by Design Principles - Fuzzing in a Memory Safe Verification Environment"; sanitizers add a performance overhead, and exploit techniques like "red zoning jumping" lead to vulnerable blind spots.

In the Ada and SPARK ecosystem, the story is completely different. Ada’s rich, built-in runtime check semantics—including Constraint_Error for range checks, overflow checks, array index checks, and discriminant checks—provide an exceptionally strong anomaly detection oracle out-of-the-box. When GNATfuzz executes an Ada binary, any violation of mathematical or memory invariants immediately triggers an explicit exception that GNATfuzz captures instantly. Because Ada provides far richer runtime feedback than C/C++ without requiring heavy external sanitization overhead, a head-to-head race between GNATfuzz and an LLM on Ada code is vastly tighter and more competitive. Fuzzing Ada doesn't just catch hard crashes—it catches subtle logic and constraint violations that traditional dynamic tools pass over.

GNATfuzz: End-to-End Fuzzing Platform

Project Zero’s findings highlight why automated, intelligent dynamic testing remains indispensable. Within AdaCore’s Dynamic Analysis Suite, GNATfuzz has evolved into a complete, end-to-end fuzzing platform engineered specifically to eliminate historical adoption barriers:

  • "Fuzz-Efficient" Binary Corpus Generation: Traditional fuzzers mutate raw byte streams, often wasting compute cycles mutating alignment padding or structural metadata. GNATfuzz strips out byte-padding overhead to generate compact, structure-aware binary test cases. Furthermore, GNATfuzz can seamlessly import and export GNATtest test vectors, creating a self-improving corpus over repeated CI/CD runs and enhancing code coverage across unit test campaigns.
  • Multi-Language Ecosystem: Native support for Ada and C, with active development extending GNATfuzz to Rust and C++ codebases.
  • Advanced Branch Solving (SymCC & RedQueen): To bypass "magic number" checks and deep conditional gates that stop basic mutators in their tracks, GNATfuzz embeds two advanced technologies:
    • RedQueen / CMPLOG: Uses input-to-state correspondence analysis to dynamically discover comparison values and inject them directly into mutated test seeds.
    • SymCC (Symbolic Execution): Uses symbolic execution to reason about mathematical branch predicates and solve complex conditional paths.
  • Automated Harness Generation: Eliminates manual test setup by automatically generating test harnesses, type marshallers, and build infrastructure directly from project GPR files.
  • Turnkey Workflows:
    • fuzz_everything: A one-click, parallelized workflow that automatically analyzes, generates, builds, and fuzzes every fuzzable entry point in a project simultaneously across multi-core systems.
    • hot-spot: The SAST/DAST "force multiplier" workflow that turns static analysis warnings into verified runtime vulnerabilities backed by automated reproducer scripts.

Conclusion

Project Zero’s conclusion offers a clear blueprint for the future of software assurance: run both.

At AdaCore, we agree that AI agents are not replacements for dynamic fuzzing but rather supercharged operators, enablers, and verifiers. Because GNATfuzz exposes clean, CLI-driven atomic commands (analyze, generate, build, generate-corpus, minimize-corpus, fuzz) and structured JSON/SARIF artifacts, AI sub-agents excel at operating GNATfuzz directly. An AI agent can review a pull request, invoke gnatfuzz, and let the dynamic engine execute millions of test cases per second to verify its hypotheses. In addition, there may be cases where a fuzzer struggles to achieve the required coverage; in this scenario, an observing agent can diagnose the fuzzing run, orchestrate non-intrusive code wrappers and stubs, and then execute the fuzzer again for even more targeted testing. The counter is also true: LLMs are typically good at identifying code problems but may struggle to provide easy-to-debug reproducers. GNATfuzz Hot-Spot serves as the ultimate hallucination circuit-breaker for LLM bug-hunting. When an LLM predicts a security flaw or false positive, Hot-Spot subjects the flagged subprogram to targeted dynamic execution. If the fuzzer triggers the exception, you get an augmented SARIF report containing a concrete, 100% reproducible crash script and decoded input parameters. If the fuzzer cannot trigger it after exhaustive execution, you gain quantitative coverage evidence to support a defensible false-positive refutation argument.

The debate between traditional fuzzing and AI-native bug discovery isn't a zero-sum game. As AI agents become more sophisticated at reasoning about code, pairing them with the mathematical rigor of symbolic execution, coverage-guided fuzzing, and strongly-typed language runtimes creates an unbeatable defense.

FAQs

Fuzzing and AI bug-finding agents work best together, not as alternatives. Google Project Zero’s recent benchmark comparing the Fuzzilli fuzzer with the BigSleep AI agent on Chrome’s V8 engine found that each approach surfaced vulnerabilities the other missed. AI agents are well suited to reviewing code changes and reasoning about likely flaws, while coverage-guided fuzzers execute large numbers of test cases and can produce concrete, reproducible evidence of a bug.

GNATfuzz Hot-Spot gives the fuzzer a targeted starting point rather than letting it explore the codebase broadly. It takes a static analysis report (SARIF) or a code diff, identifies the code locations of interest, traverses the call graph to find a fuzzable entry point, and then launches a fuzzing campaign aimed at that location. This helps address a limitation Project Zero noted: unlike AI agents, traditional fuzzers cannot easily be pointed at a specific commit or change.

Fuzzing Ada code benefits from Ada’s built-in runtime checks, which act as a bug-detection oracle without the need for external sanitizers. Range, overflow, array index, and discriminant checks raise an explicit exception when violated, which GNATfuzz can capture directly. In C and C++, many memory errors can execute silently unless a sanitizer such as AddressSanitizer is attached, which adds performance overhead and may leave some blind spots. As a result, fuzzing Ada can surface constraint and logic violations that might go undetected in unmanaged languages.

Author

Paul Butcher

Paul Butcher
AdaCore

Paul is the UK Programme Manager, Head of Dynamic Analysis for AdaCore, and the Lead Engineer for GNATfuzz. He has over 25 years of experience in developing and verifying embedded safety-critical real-time systems. Before joining AdaCore, Paul was a consultant engineer, working for UK aerospace companies such as Leonardo Helicopters, BAE Systems, Thales UK, and QinetiQ. Before becoming a consultant, Paul worked as a Software Developer and Safety Engineer for the Typhoon platform, safety-critical automated train driving software, military UAVs, the Tactical Processor for the Wildcat platform, and mission planning systems for Typoon, EH101, and Wildcat. Paul graduated from the University of Portsmouth with a Bachelor’s Degree with Honours in Computing and a Higher National Diploma in Software Engineering.

Blog_

Latest Blog Posts