Agentic Fuzzing: Opportunities and Challenges

Junyoung Park, Insu YunarXiv 2026 · DOI · arXiv

TL;DR

This paper introduces "agentic fuzzing," a novel approach that leverages advanced AI agents to find complex logic bugs in software. By using historical bugs as "seeds" and empowering AI agents to reason about root causes and hypothesize new vulnerabilities, this method significantly outperforms traditional fuzzing techniques, especially for hard-to-find logic flaws.

What Problem Does This Paper Address?

Finding logic bugs in mature, complex software like the V8 JavaScript engine is a significant challenge. Traditional fuzzing methods, which rely on observing crashes or code coverage, often miss these bugs because they don't necessarily manifest as obvious errors. Static analysis tools, while useful, struggle to capture the intricate, multi-step reasoning required to trigger logic flaws. Even with historical bug data, existing tools can't effectively generalize this knowledge to find similar bugs in different parts of the codebase or in different implementations. This gap leaves critical vulnerabilities undiscovered.

Methods

The core innovation is agentic fuzzing, which treats AI agents as the primary reasoning engine, not just an auxiliary tool. The process starts with a reference bug (a known vulnerability) as a seed.

  1. Analyzer Agent: This agent takes the reference bug and extracts its root cause and mechanism.
  2. Investigator Agent: Guided by the root cause, this agent searches the codebase for similar patterns and formulates vulnerability hypotheses.
  3. Scenario Analyzer Agent: This agent attempts to verify hypotheses by generating and executing Proof-of-Concept (PoC) code.
  4. Validator Agent: This agent independently verifies the PoC and generates a detailed report.

To manage the complexity and scale of this process, the authors developed:

  • Scenario Coverage: A mechanism to track explored (location, hypothesis) pairs to avoid redundant investigations across different seeds.
  • DPP-MAP Seed Scheduler: An algorithm that prioritizes seeds based on diversity to explore a broader range of root causes efficiently.

Datasets

  • V8 JavaScript Engine: The primary target for evaluation.
  • Chromium Issue Tracker: Used to collect 3,146 reference bug seeds for V8.
  • SpiderMonkey and JavaScriptCore: Other JavaScript engines used to test cross-engine fuzzing capabilities.

Key Insights and Ideas

  • AI Agents as Reasoning Engines: The paper argues that for complex logic bugs, AI agents should drive the entire bug-finding process, not just assist existing tools. Their ability to understand code semantics and perform multi-step reasoning is crucial.
  • Historical Bugs as "Seeds" for Reasoning: Instead of just generating inputs, reference bugs serve as starting points for AI agents to understand why a bug occurs and then hypothesize where else similar issues might exist.
  • Scenario Coverage is Key to Efficiency: Without tracking explored scenarios, agentic fuzzing can become incredibly redundant. This mechanism prevents agents from re-investigating the same vulnerability patterns.
  • Diversity in Seed Selection Matters: Simply processing seeds chronologically or randomly can lead to wasted effort on similar bugs. Prioritizing diverse root causes helps maximize bug discovery within a limited budget.
  • Cross-Engine Transferability: The root causes of bugs can often be generalized across different implementations of similar software, allowing seeds from one engine to find bugs in another.

Key Results

  • AFuzz discovered 40 bugs in the V8 JavaScript engine, including three duplicates, within a one-month evaluation period.
  • These findings led to $35,000 in bug bounties and two CVE assignments (CVE-2026-2649 and CVE-2026-7902).
  • The discovered bugs spanned various V8 subsystems, including compilers, parsers, and interpreters, and included complex logic flaws that conventional methods missed.
  • AFuzz found 5 bugs in SpiderMonkey and 14 bugs in JavaScriptCore using seeds from V8, demonstrating cross-engine applicability.
  • The four-stage pipeline design, combined with scenario coverage and DPP-MAP scheduling, proved effective in maximizing bug discovery.

Limitations and Future Work

  • Cost Effectiveness: Agentic fuzzing is currently expensive, limiting the number of seeds that can be processed and the scope of evaluation. More research is needed to improve cost efficiency.
  • No Reference Bug: The approach relies on the availability of reference bugs. For closed-source software or projects with few public bug reports, this is a significant limitation. Future work could explore bootstrapping seeds from documentation or related projects.
  • Design Uncertainty: The optimal design for agentic fuzzers is still an open question, as agent behavior can be sensitive to model updates and prompt engineering. The authors suggest exploring how agents can self-organize or how to make designs more robust across model generations.
  • Open-Source Models: Current open-source LLMs are not yet competitive with commercial models for agentic fuzzing tasks, though this is expected to improve.
  • Generalization: While AFuzz showed promise on other software targets (ANGLE, Windows kernel), further evaluation on more diverse targets is needed.

Summary updated

BibTeX
@misc{park2026agentic,
  author = {Junyoung Park and Insu Yun},
  title = {{Agentic Fuzzing: Opportunities and Challenges}},
  year = {2026},
  eprint = {2605.10074},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2605.10074},
}

Loading related content...

Figure