Pedro Conde

Ethiack

Coimbra, Portugal

conde@ethiack.com

&Henrique Branquinho

Ethiack

Coimbra, Portugal

henrique@ethiack.com

&Valerio Mazzone

Ethiack

Coimbra, Portugal

valerio@ethiack.com

&Bruno Mendes

Ethiack

Porto, Portugal

bruno@ethiack.com

&André Baptista

Ethiack

Porto, Portugal

andre@ethiack.com

&Nuno Moniz

University of Notre Dame

Notre Dame, Indiana, USA

nunomoniz@nd.edu

Abstract

AI pentesting agents are increasingly credible as offensive security systems, but current benchmarks still provide limited guidance on which will perform best in real-world targets. Existing evaluation protocols assess and optimize for predefined goals such as capture-the-flag, remote code execution, exploit reproduction, or trajectory similarity, in simplified or narrow settings. These tools are valuable for measuring bounded capabilities, yet they do not adequately capture the complexity, open-ended exploration, and strategic decision-making required in realistic pentesting. In this paper, we present a practical evaluation protocol that shifts assessment from task completion to validated vulnerability discovery, allowing evaluation in sufficiently complex targets spanning multiple attack surfaces and vulnerability classes. The protocol combines structured ground-truth with LLM-based semantic matching to identify vulnerabilities, bipartite resolution to score findings under realistic ambiguity, continuous ground-truth maintenance, repeated and cumulative evaluation of stochastic agents, efficiency metrics, and reduced-suite selection for sustainable experimentation. This protocol extends the state of the art by enabling a more realistic, operationally informative comparison of AI pentesting agents. To enable reproducibility, we also release expert-annotated ground truth and code for the proposed evaluation protocol: https://github.com/jd0965199-oss/ethibench.

1 Introduction

Recent progress in large language models (LLMs) has pushed artificial intelligence (AI) systems beyond single-step generation and toward agentic behavior: planning Yao et al. (2023); Huang et al. (2024), tool use Schick et al. (2023); Karpas et al. (2022), iterative reasoning Wei et al. (2022); Yao et al. (2022), and environment interaction Nakano et al. (2021); Ahn et al. (2022); Wang et al. (2023a). This shift matters because it opens the door to applying AI to tasks that are not precisely specified in advance, but instead require adaptation as the task unfolds Yao et al. (2022); Huang et al. (2022); Shinn et al. (2023). Penetration testing (pentesting) is a clear example David and Gervais (2025); Shen et al. (2024); Kong et al. (2025); Nakatani (2025); Deng et al. (2024). It is not a problem of producing one correct answer, but of exploring a target, interpreting partial evidence, deciding what is worth pursuing, and chaining actions under uncertainty. These are precisely the kinds of capabilities that earlier AI systems could support only in narrowly constrained settings, but modern agentic systems are displaying in more open-ended settings Xi et al. (2023); Wang et al. (2023b); Sumers et al. (2023).

With these systems becoming an option for offensive security, a challenging question immediately follows: how should they be evaluated if the goal is real-world use rather than (strict) benchmark success? More broadly, this is a central problem in the evaluation of agentic AI systems Kapoor et al. (2024); Weidinger et al. (2025). Performance in controlled benchmark settings often says less than it appears to about performance in realistic environments Raji et al. (2021); Dehghani et al. (2021); Freiesleben and Zezulka (2025); Lee et al. (2022); Li et al. (2021); Wang et al. (2025b); Pan et al. (2024); Xue et al. (2025); Yao et al. (2024). Benchmarks are attractive because they are reproducible, cheap to score, and methodologically tidy, yet those same properties often come from simplifying away the very features that make real deployment difficult Raji et al. (2021); Wallach et al. (2024); Weidinger et al. (2025). For practitioners, this creates a practical risk: evaluation can reward systems that look strong under controlled conditions while offering a poor basis for selecting the systems that will matter most in real-world applications Kapoor et al. (2024); Dehghani et al. (2021); Xue et al. (2025). This leads to our motivating question: how can we evaluate AI pentesting systems to maximize offensive security impact in real-world conditions?

Current evaluation efforts do not fully answer our question. Existing work has produced a range of useful benchmarks, but mostly as task-specific testbeds rather than a methodology for realistic assessment. Many evaluations remain anchored to predefined goals such as capture-the-flag Gioacchini et al. (2024); Zhang et al. (2024); Shao et al. (2024); Muzsai et al. (2024); Sanz-G’omez et al. (2025); Liu et al. (2025), remote code execution Mai et al. (2025), exploit reproduction Zhu et al. (2025); Zhang et al. (2025); Wang et al. (2025a), or trajectory similarity Yang et al. (2025); Caldwell et al. (2025), in simplified targets. These formulations are useful for measuring bounded capabilities, but they still lack a structured way to evaluate whether an agent can effectively discover multiple vulnerabilities across complex targets with several possible avenues of exploration Happe and Cito (2025). As a result, they do not adequately reward the behaviors that matter most in realistic pentesting: open-ended exploration, planning, prioritization, and strategy. Just as importantly, they rarely treat evaluation as an operational problem in its own right, one shaped by incomplete ground truth, stochastic agent behavior, repeated execution, runtime, and monetary cost. Some approaches also assume a white-box setting, with access to the target’s source code. This limits their applicability to common pentesting engagements, where practitioners often assess systems from a black-box perspective and must reason only from externally observable behavior.

Our approach. In response to these limitations, this paper proposes a practical evaluation protocol for AI pentesting agents designed to support realistic and operationally meaningful assessments. Rather than defining another fixed benchmark, we present a methodology that can be adapted to different target classes based on the intended real-world application and the operational context in which the system is intended to be used. The protocol centers evaluation on validated vulnerability discovery in sufficiently complex targets, uses a structured finding-to-ground-truth pipeline with semantic matching and bipartite resolution, treats ground truth as a continuously maintained resource, and evaluates stochastic systems through both repeated and cumulative runs. It also incorporates efficiency as a first-class concern, including runtime, cost, and reduced-suite evaluation for sustainable experimentation. Because the protocol scores reported findings rather than internal agent trajectories or source-code access, it is independent of the testing modality and can be applied consistently across white-box, gray-box, and black-box evaluations. Taken together, these contributions aim to make evaluation more useful not only for measuring progress, but for making better decisions about which AI pentesting systems are actually worth deploying.

2 Related work

Existing evaluation work for AI pentesting agents can be grouped into three main lines. The first relies on CTF-style environments, as in Gioacchini et al. (2024), Zhang et al. (2024), Shao et al. (2024), Muzsai et al. (2024), and parts of Sanz-G’omez et al. (2025). These benchmarks provide controlled tasks and cheap automatic scoring, but they usually reduce success to capture-the-flag in closed settings. As a result, they are useful for measuring isolated offensive capability, yet they only weakly reflect realistic pentesting, where agents must explore noisy targets, decide where to focus, and distinguish valid findings from non-actionable leads Happe and Cito (2025).

A second line moves toward more realistic offensive workflows. TermiBench Mai et al. (2025) replaces flags with remote code execution in multi-service hosts, providing a stronger notion of exploit validity, but success is still tied to a single objective. PACEbench Liu et al. (2025) introduces distractors, exploit chains, and active defenses, but still evaluates success through predefined flag-based goals. PentestEval Yang et al. (2025) adds fine-grained stage-level evaluation through expert annotations and similarity-based metrics, which is valuable for diagnosing where agents fail. However, this formulation remains centered on reproducing a predefined workflow and intermediate outputs, rather than on whether the agent ultimately discovers valid vulnerabilities in an open-ended target.

A third line strengthens evaluation by using real vulnerabilities and stricter execution-grounded validation. CVE-Bench Zhu et al. (2025) instantiates real web CVEs, but each target is evaluated through a predefined attack goal, which narrows the space of acceptable successful outcomes. BountyBench Zhang et al. (2025) and CyberGym Wang et al. (2025a) provide stronger exploit validation through vulnerable-versus-patched execution, greatly improving oracle quality, but they largely evaluate bounded tasks such as exploit generation, detection of a specific issue class, or proof-of-concept construction rather than end-to-end pentesting over targets with multiple possible findings. PentestJudge Caldwell et al. (2025) addresses a complementary problem by scoring trajectories against a rubric tree of operational objectives, but this again evaluates conformity to predefined behavioral criteria rather than vulnerability discovery itself.

In contrast with existing work, our methodology shifts the unit of evaluation from task completion or trajectory similarity to the finding itself. Instead of tying success to flags, a single prescribed exploit goal, or rubric compliance, it evaluates whether an agent uncovers valid vulnerabilities in realistic targets and maps those reports to ground-truth through semantic matching followed by bipartite resolution. Our approach fills several gaps left by the current state of the art: it supports open-ended, multi-vulnerability discovery rather than single goal completion, makes precision, recall, and duplicate reporting measurable at the finding level, treats ground truth as a living resource that is updated through expert triage, and handles stochastic agents through both repeated and cumulative evaluation. In this sense, the protocol aims to combine realism, validation, and operationally meaningful scoring in a way that prior work has only partially addressed.

3 A realistic evaluation protocol for AI pentesting agents

This section presents our proposal for a practical evaluation protocol for AI pentesting agents, prioritizing realism over closed-world benchmark convenience. Our goal is not to define a fixed benchmark or prescribe a specific target suite, but to provide a methodology that can be adapted to different classes of pentesting targets while preserving methodological rigor. The protocol is built around four core ideas: using sufficiently realistic targets that require exploration and strategic decision-making; evaluating findings through a structured finding-to-ground-truth pipeline that supports semantic matching and ambiguity resolution; treating ground truth as a continuously maintained resource rather than a static answer key; and accounting for stochasticity through repeated and cumulative evaluation in a realistic fashion. Taken together, these design choices aim to support evaluations that are not only more faithful to real offensive practice but also more useful for comparing, improving, and operationally assessing AI pentesting agents. We provide a high-level illustration of the proposed evaluation framework in Figure 4 (Appendix B).

We have already described the shortcomings of existing evaluation tools regarding target selection and their effectiveness as a parallel to real-world action. However, it is also important to highlight that our work does not aim to propose any specific target set, but rather to offer a protocol recommendation: evaluations of AI pentesting agents should assess exploration, planning, and strategic decision-making in sufficiently complex environments where those capabilities are necessary. The following methodology is designed to enable reliable evaluation in such settings.

3.1 Finding-to-ground-truth evaluation pipeline

We now describe the procedure for evaluating an agent’s performance on a given target. The evaluation is carried out in three stages: constructing a structured ground truth for the target, matching agent-reported findings to ground-truth entries using an LLM-as-judge approach, and resolving ambiguous correspondences through bipartite matching.

3.1.1 Ground-truth creation

For each target, we first construct a ground-truth file in jsonl format. Each entry corresponds to a vulnerability known to exist in the target and can include fields such as "name", "category", "description" and "additional info". This file serves as the reference against which agent-reported findings are evaluated. Its construction also defines the scope of the evaluation, for example by limiting it to vulnerabilities above a chosen severity level or to specific categories of interest.

Care must be taken when creating these entries. If a ground-truth entry is too generic, it becomes difficult to determine whether a finding matches that specific vulnerability or only the broader vulnerability class. Conversely, if an entry is too specific, it may encode assumptions about how the vulnerability should be discovered or described, causing valid findings to be incorrectly rejected when the agent reaches the same vulnerability through a different path or reports it using different evidence. Ground-truth entries should therefore aim for a level of specificity that supports accurate matching without over-constraining the acceptable form of a correct finding.

3.1.2 LLM-based findings matching

Given a finding produced by the agent, we use an LLM-as-a-judge to compare that finding against all ground-truth entries and identify the entries that match it semantically. Rather than enforcing a strict one-to-one correspondence at this stage, the judge may assign multiple candidate ground-truth matches to a single finding.

Allowing one-to-many candidate matches is important for realistic evaluation settings. Both the ground-truth entries and the agent outputs may lack sufficient specificity to support exact deterministic matching. For example, a finding may correctly describe a vulnerability class but omit the details necessary to uniquely identify a single ground-truth entry, or multiple ground-truth entries may be written at a level of abstraction that makes them hard to distinguish. Therefore, the matching stage is intentionally permissive and designed to preserve plausible correspondences instead of prematurely discarding them.

3.1.3 Bipartite resolution of matches

The candidate matches produced in the previous step define a bipartite graph between agent findings and ground-truth entries. Ambiguity can arise because a single finding may plausibly correspond to multiple ground-truth entries, and multiple findings may plausibly correspond to the same ground-truth entry. The latter may occur either because descriptions are too generic to support a unique assignment or because the agent reported the same underlying issue multiple times. As a result, candidate matches cannot be directly interpreted as true positives.

To obtain reliable detection counts, we resolve these ambiguities by computing a maximum bipartite matching between findings and ground-truth entries. This ensures that each ground-truth entry is credited at most once and that repeated or overlapping reports are not incorrectly counted as additional successful detections. In our implementation, we solve this using the Hungarian algorithm, providing a reliable count of true positives while preventing duplicate reports from inflating the results.

3.2 Evaluation metrics and continuous ground-truth maintenance

Given the finding-to-ground-truth pipeline described above, the evaluation can approximate metrics commonly used in classical detection settings (e.g., Precision, Recall, F1), duplicate counting, and other security-specific metrics like severity scoring, coverage, and Common Weakness Enumeration (CWE) coverage (additional information on evaluation metrics in Appendix A). However, an important limitation remains: for realistic pentesting targets, it is often impossible to know in advance the complete set of vulnerabilities present in the target. Unlike closed benchmarks with exhaustively enumerated answers, real or realistic pentesting targets are inherently open-ended: the full set of vulnerabilities may be unknown at evaluation time. In practice, some agent-reported findings that do not match any existing ground-truth entry may be labeled as false positives, even though they correspond to real vulnerabilities that were omitted during target annotation. As a result, the reported metrics depend on how complete and accurate the current ground truth is.

To make these metrics reliable in realistic settings, evaluation must be coupled with periodic expert review of unmatched findings and continuous maintenance of the ground-truth files. When a finding is validated as a real vulnerability that is missing from the ground truth, the corresponding ground-truth file should be updated accordingly. The same review process can also be used to refine existing entries that are too vague, too restrictive, or consistently matched to multiple findings, thereby improving matching quality and recalibrating the LLM-as-judge when needed. Without this process, incomplete or poorly specified ground truth can distort the measured metrics and, more importantly, undermine reliable comparison between different systems. More broadly, ground truth should not be treated as a static artifact, but as a living evaluation resource that co-evolves with target understanding and with the behavior of the agents being assessed.

Importantly, this should not turn evaluation into a manual process performed after every experiment. Rather, we recommend a periodic review focused on new, unmatched finding types and on ground-truth entries that are consistently matched to multiple findings, followed by automatic re-evaluation with the updated ground truth. As targets mature under this process, the need for manual intervention should become increasingly rare.

3.3 Dealing with stochasticity under computational constraints

AI pentesting agents are inherently stochastic, primarily because they rely on LLMs whose outputs may vary across runs even under the same high-level setup. Since these systems typically make many sequential LLM calls during exploration, reasoning, and tool use, small variations can propagate and lead to substantially different outcomes. As a result, a single run is rarely representative of expected performance. Evaluations should therefore include repeated runs, and reported results should provide both the mean and standard deviation of the selected metrics.

In principle, a large number of replications would allow more reliable estimation of performance and stronger statistical comparisons. In practice, however, this is often infeasible. Running modern agentic systems with state-of-the-art models over a diverse set of realistic targets is computationally and financially expensive, especially when comparing multiple agents or evaluating ablations and feature additions. Consequently, realistic studies will often operate in a low-replication regime, where the number of runs per condition is too small to fully support strong claims based only on statistical significance testing.

For pairwise comparisons under these conditions, we recommend reporting both a significance test and an effect size. In particular, Welch’s -test is a suitable default for comparing two agent variants because it does not assume equal variances between groups and remains appropriate when sample sizes differ across conditions. These properties are important in our setting, where stochastic agent behavior can lead to heterogeneous variance. However, when the number of replications is small, non-significant -values should not be interpreted as evidence of no difference: they may simply reflect limited statistical power.

For this reason, significance testing should be paired with an effect-size measure such as Cohen’s . While the -value indicates whether the observed difference is difficult to explain under the null hypothesis, Cohen’s quantifies the magnitude of the difference relative to the observed variability. Reporting both measures provides a more informative basis for A/B assessment under computational constraints: Welch’s -test offers a cautious test of whether a difference is statistically supported, while Cohen’s indicates whether the observed change is practically meaningful even when the experiment is underpowered. This combination is particularly useful when comparing system variants, where the goal is often not only to determine whether a modification is statistically detectable, but also whether its effect is large enough to matter operationally.

3.4 Importance of cumulative evaluation

Repeated runs should not be viewed only as a way to estimate expected performance under stochasticity. In realistic settings, they should also be evaluated cumulatively, by aggregating the distinct vulnerabilities recovered across multiple executions and scoring those runs as a single campaign. This perspective is important for two reasons: first, it better reflects real-world pentesting practice, where value often comes from repeated assessment over time rather than from a single execution; second, it captures a practical benefit of stochastic agent behavior, since different runs may explore different paths, use tools in different orders, or reach different intermediate states, thereby uncovering vulnerabilities missed in earlier attempts.

For this reason, the evaluation should report not only per-run metrics, but also cumulative metrics over runs on the same target. Concretely, findings from multiple runs can be merged, deduplicated through the same finding-to-ground-truth pipeline, and scored jointly. This makes it possible to measure how coverage and score evolve as additional runs are performed, and to distinguish agents that repeatedly recover the same issues from those whose variability leads to broader cumulative discovery. An agent with only moderate per-run performance may therefore still be highly useful if its findings accumulate effectively across repeated executions.

This cumulative view also enables additional experimental settings. One can evaluate repeated runs on the same target without cross-run memory, to isolate the benefit of stochastic diversity, or with memory from previous runs, to assess whether explicit retention improves efficiency and coverage. It also enables evaluation under target evolution, where the environment changes between runs, either because the pentesting process modifies the target state or because previously identified vulnerabilities are patched.

Cumulative evaluation is therefore an important bridge between benchmark-oriented comparison and real-world assessment. Per-run results remain necessary for controlled comparisons, but cumulative results better capture agent performance within an ongoing pentesting process.

3.5 Tracking efficiency metrics

Detection quality alone is not sufficient to evaluate an AI pentesting agent. In practice, these systems operate under time and budget constraints, so evaluation should also measure how efficiently they convert resources into validated findings. Reporting only final recall, precision, or severity can hide important differences between agents that achieve similar results at very different operational costs.

At a minimum, evaluations should report total runtime and total monetary cost per run. However, efficiency should also be tracked throughout the run, not only at the end. For example, tracking vulnerability discovery through time can help identify diminishing returns: if most vulnerabilities are discovered early, reducing iteration limits may preserve most of the value while substantially lowering cost and runtime.

3.6 Selecting representative subsets for sustainable experimentation

Evaluating AI pentesting agents on a broad and realistic target suite with repeated runs is often too expensive to perform frequently, especially during iterative development, ablation studies, or small system changes. For this reason, it is useful to define smaller target subsets that preserve, as much as possible, the conclusions that would be obtained on the full benchmark while reducing evaluation cost.

A principled way to construct such subsets is to use historical evaluation data collected on the full target set. Let the full benchmark contain a set of targets , and let each target have an associated evaluation cost (for example, mean runtime or monetary cost). Using previous full-benchmark runs across one or more agents and replications, we compute for each run both the score (e.g. F1) on the full target set and the score restricted to a candidate subset . The goal is then to select a subset that maximizes agreement between subset-level and full-benchmark results subject to a cost budget, i.e., , where may be expressed as an absolute budget or as a fraction of the full-suite cost (e.g., of the average full-suite cost).

In our setting, agreement is measured primarily with Pearson correlation and secondarily with Spearman correlation. Pearson correlation is the main criterion because the goal is to preserve not only the ranking of systems, but also the magnitude of performance differences between them. Spearman correlation is reported as a secondary criterion because it measures rank agreement and is less sensitive to outliers or nonlinear scaling.

This procedure provides a data-driven way to define reduced evaluation suites, rather than selecting targets manually based only on intuition about difficulty or realism. However, such subsets should be treated as proxies for frequent evaluation, not replacements for periodic full-benchmark assessment. Because their quality depends on historical data, they should be revalidated as agents and target sets evolve.

4 Experiments and results

To illustrate the proposed evaluation protocol, we selected three agentic pentesting systems: two open-source pentesting engines, Strix usestrix (2025) and PentAGI vxcontrol (2025), and one general-purpose agentic coding system, Claude Code Anthropic (2025). These systems were chosen because they represent realistic examples of current agentic security workflows rather than simple single-agent baselines. In particular, all three systems support complex tool use, multi-step reasoning, and agent handoffs, making them suitable candidates for evaluating how agentic systems behave in open-ended pentesting settings.

Unless otherwise noted, each pentesting engine was evaluated with four different LLM backends: Claude Sonnet 4.6, GPT 5.4, DeepSeek v3.1, and Qwen 3.6 Plus, with default provider parameters. We used native API providers for Claude Sonnet and GPT-5.4, and Fireworks AI for the remaining ones. Claude Code was evaluated only with Claude Sonnet, since this is its native operating mode. Note that these systems are highly configurable and can be extended with external tools, skills, memory mechanisms, and MCP servers. Consequently, the experimental results should not be interpreted as a definitive ranking of the engines or the models themselves. Instead, we use these systems as representative agentic pentesting workflows to show how the proposed protocol can compare different engines with different configurations at the finding level.

We selected three open-source targets: vuln-bank Commando-X (2025), paygoat stuxctf (2025), and xben-090 xbow-engineering (2024). vuln-bank and paygoat are vulnerable applications with realistic functionality and documented security issues, making them suitable for evaluating multi-finding vulnerability discovery. xben-090, one of the challenges from XBOW’s validation benchmark (XBEN) xbow-engineering (2024), differs in that it originates from a CTF-style benchmark, where the standard evaluation criterion is binary success: whether the agent obtains the flag. In our setting, we use it differently. Rather than treating the flag as the sole objective, we evaluate the target as a pentesting environment and assess whether agents report all valid vulnerabilities they discover. This highlights an important motivation for our protocol: even simple CTF-style scenarios may contain multiple vulnerabilities, including unintended ones, that are relevant from a pentesting perspective but invisible to flag-based scoring. The ground-truth of existing vulnerabilities for each target was carefully curated by security researchers, with the disclosed vulnerabilities in the target’s repositories as basis, in an iterative process of multiple experiments and application analysis. The criteria for the definition of this ground truth were closely aligned with what is expected from a human penetration testing report. In total, we consider 108 expert-annotated vulnerabilities as our ground-truth for the three targets, with 60 vulnerabilities in vuln-bank, 28 vulnerabilities in paygoat, and 20 vulnerabilities in xben-090. Further details on the experimental setup in Appendix C. Also, additional experiments and results in Appendix F.

4.1 Findings-to-ground-truth sanity-check

Before illustrating our evaluation protocol, is important to ensure that our findings-to-ground-truth pipeline is reliable. For that purpose, security researchers triaged multiple findings from our experiments, from which we were able to select 50, where 25 were matched to different ground-truth entries (true positives) and the other 25 were labeled as false positives. These expert-annotated labeling is then compared with our findings-to-ground-truth matching system using different LLMs (additional details in Appendix D). From the results shown in Figure 1, we can observe that both Gemini 3 Flash and GPT 5.4 Mini showed reliable classifcation capabilities, with the latter (on average) only incorrectly classifying approximately 1 finding (as duplicate instead of true positive). Based on these experiments, GPT 5.4 Mini was the model chosen for the findings-to-ground-truth matching purpose.

4.2 Agentic pentesting results

Figure 2 reports performance and efficiency across all experimental setups, with each metric averaged over all runs and targets. The results show substantial variation across configurations, both in vulnerability discovery and in operational efficiency. Some setups discover more valid vulnerabilities and achieve stronger recall, while others produce fewer false positives but miss more findings. There is also a clear effect of the underlying model, both in performance and efficiency. We introduce new dimensions for analysis, namely severity and CWE coverage, which showcases the diversity of reported vulnerabilities across different setups. For a more detailed comparison, see Appendix E.

A consistent result across all configurations is the high number of false negatives. No setup fully covers the targets or reports all known vulnerabilities in a single run, which shows that one execution can provide only an incomplete view of an agent’s capabilities. This is especially important when the ground truth is comprehensive. In this study, the ground truth aims to include all known vulnerabilities in the selected targets, but the protocol can also be adapted to different evaluation goals.

Aggregating findings across three independent runs (see Figure 3) does not substantially alter the relative ranking of the experimental setups, but it does reveal important behavioral differences. Although all setups benefit from accumulation in terms of -score, primarily due to gains in Recall, the extent and nature of these gains vary considerably. As shown in Figure 3, two agentic systems using the same LLM can respond very differently to the accumulation of findings across multiple runs. In particular, the PentaAGI-Sonnet combination exhibits a marked decrease in Precision, causing its cumulative score to fall below its mean score across individual runs. In contrast, the Strix-Sonnet combination remains comparatively precise even after aggregating findings from three distinct runs, while nearly doubling its Recall, ultimately achieving the highest cumulative score among all evaluated setups. The fact that Recall can increase so substantially even without cross-run memory suggests that the stochasticity introduced by the Strix harness may be advantageous in realistic testing scenarios, where repeated assessments of the same target are common practice. Conversely, for some setups, the repeated accumulation of False Positives may render iterative testing impractical. These results underscore the value of cumulative analysis, as it captures properties of agent behavior that are not evident from mean and standard deviation alone.

The main take-away from these experiments is that realistic finding-level evaluation exposes trade-offs that would be hidden by binary success metrics such as capture-the-flag. A system that looks precise may still miss many vulnerabilities, while a system that discovers more vulnerabilities may also introduce higher cost, higher false positive rates, longer runtime, or more duplicate reports. Furthermore, because these systems are highly stochastic, averages over isolated runs may also hide important differences in consistency. For this reason, cumulative evaluation is useful for measuring whether repeated runs lead to broader target coverage and more valid findings, while keeping false positives under control. By measuring these dimensions together, the proposed protocol turns evaluation into a more actionable decision process: it shows not only which systems find vulnerabilities, but also how they find them, what they miss, how noisy their outputs are, and whether their performance is practical under realistic deployment constraints.

5 Limitations and future work

This work focuses on the evaluation protocol itself rather than on introducing a new benchmark suite. Accordingly, we do not contribute new targets, and the usefulness of the protocol in practice depends on its application to sufficiently realistic targets with multiple vulnerabilities across distinct components and attack surfaces. In addition, while the protocol motivates cumulative evaluation across repeated runs, we do not experimentally study settings with cross-run memory or evolving targets, such as sequentially patched environments, where agent behavior may change over time. Finally, the present methodology centers on validated vulnerability discovery and efficiency, but does not yet cover other important dimensions of AI pentesting evaluation, such as safety-related behavior, including whether agents avoid destructive actions during operation.

Future work based on this protocol should proceed in three directions: creating additional realistic targets with a broad set of vulnerabilities, including environments that intelligently combine multiple real-world vulnerabilities within the same system; studying multiple forms of long-term memory for agentic pentesting and evaluating their effect under cumulative evaluation settings; and extending the protocol with safety assessment, including whether agents can be effectively guardrailed against destructive behavior.

6 Final remarks

Beyond its technical contributions, this work carries broader implications. AI pentesting agents are increasingly being considered for deployment in security-critical domains, from financial services to healthcare infrastructure. In these settings, evaluation is not a neutral research activity: benchmarks that reduce success to capture-the-flag or single-goal exploitation can lead practitioners to select systems that perform well in controlled conditions but fail silently on realistic targets with multiple vulnerabilities and complex attack surfaces. Conversely, capable systems may be discarded because they score poorly on tasks that do not reflect their actual offensive utility. For this reason, evaluation methodology should be treated as part of the deployment problem itself, since the way agents are assessed will directly shape which systems are trusted, improved, and ultimately used in practice. By making evaluation more realistic, finding-centered, and operationally informative, our approach helps align benchmark performance more closely with the properties that actually matter for trustworthy real-world deployment.

References

• [1] M. Ahn, A. Brohan, N. Brown, Y. Chebotar, O. Cortes, B. David, C. Finn, K. Gopalakrishnan, K. Hausman, A. Herzog, D. Ho, J. Hsu, J. Ibarz, B. Ichter, A. Irpan, E. Jang, R. M. J. Ruano, K. Jeffrey, S. Jesmonth, N. Joshi, R. C. Julian, D. Kalashnikov, Y. Kuang, K. Lee, S. Levine, Y. Lu, L. Luu, C. Parada, P. Pastor, J. Quiambao, K. Rao, J. Rettinghouse, D. Reyes, P. Sermanet, N. Sievers, C. Tan, A. Toshev, V. Vanhoucke, F. Xia, T. Xiao, P. Xu, S. Xu, and M. Yan (2022-04) Do As I Can, Not As I Say: Grounding Language in Robotic Affordances. Conference on Robot Learning, pp. 287–318. Cited by: §1.
• [2] Anthropic (2025) Claude code: agentic coding tool. Note: https://github.com/anthropics/claude-codeVersion 2.1.107, Proprietary License (© Anthropic PBC) Cited by: §4.
• [3] S. Caldwell, M. Harley, M. Kouremetis, V. Abruzzo, and W. W. Pearce (2025-08) PentestJudge: Judging Agent Behavior Against Operational Requirements. ArXiv abs/2508.02921. Cited by: §1, §2.
• [4] Commando-X (2025) Vuln-bank. Note: https://github.com/Commando-X/vuln-bankAccessed: 2026-01-05, MIT License Cited by: §4.
• [5] I. David and A. Gervais (2025-08) Multi-agent Penetration Testing AI for the Web. ArXiv abs/2508.20816. Cited by: §1.
• [6] M. Dehghani, Y. Tay, A. Gritsenko, Z. Zhao, N. Houlsby, F. Diaz, D. Metzler, and O. Vinyals (2021-07) The Benchmark Lottery. ArXiv abs/2107.07002. Cited by: §1.
• [7] G. Deng, Y. Liu, V. Vilches, P. Liu, Y. Li, Y. Xu, M. Pinzger, S. Rass, T. Zhang, and Y. Liu (2024) PentestGPT: Evaluating and Harnessing Large Language Models for Automated Penetration Testing. USENIX Security Symposium. Cited by: §1.
• [8] T. Freiesleben and S. Zezulka (2025-10) The Benchmarking Epistemology: Construct Validity for Evaluating Machine Learning Models. ArXiv abs/2510.23191. Cited by: §1.
• [9] L. Gioacchini, M. Mellia, I. Drago, A. Delsanto, G. Siracusano, and R. Bifulco (2024-10) AutoPenBench: Benchmarking Generative Agents for Penetration Testing. ArXiv abs/2410.03225. Cited by: §1, §2.
• [10] A. Happe and J. Cito (2025-04) Benchmarking Practices in LLM-driven Offensive Security: Testbeds, Metrics, and Experiment Design. ArXiv abs/2504.10112. Cited by: §1, §2.
• [11] W. Huang, F. Xia, T. Xiao, H. Chan, J. Liang, P. R. Florence, A. Zeng, J. Tompson, I. Mordatch, Y. Chebotar, P. Sermanet, N. Brown, T. Jackson, L. Luu, S. Levine, K. Hausman, and B. Ichter (2022-07) Inner Monologue: Embodied Reasoning through Planning with Language Models. ArXiv abs/2207.05608. Cited by: §1.
• [12] X. Huang, W. Liu, X. Chen, X. Wang, H. Wang, D. Lian, Y. Wang, R. Tang, and E. Chen (2024-02) Understanding the planning of LLM agents: A survey. ArXiv abs/2402.02716. Cited by: §1.
• [13] S. Kapoor, B. Stroebl, Z. S. Siegel, N. Nadgir, and A. Narayanan (2024-07) AI Agents That Matter. Trans. Mach. Learn. Res. 2025. Cited by: §1.
• [14] E. Karpas, O. Abend, Y. Belinkov, B. Lenz, O. Lieber, N. Ratner, Y. Shoham, H. Bata, Y. Levine, K. Leyton-Brown, D. Muhlgay, N. Rozen, E. Schwartz, G. Shachaf, S. Shalev-Shwartz, A. Shashua, and M. Tenenholtz (2022-05) MRKL Systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning. ArXiv abs/2205.00445. Cited by: §1.
• [15] H. Kong, D. Hu, J. Ge, L. Li, T. Li, and B. Wu (2025-01) VulnBot: Autonomous Penetration Testing for A Multi-Agent Collaborative Framework. ArXiv abs/2501.13411. Cited by: §1.
• [16] M. Lee, M. Srivastava, A. Hardy, J. Thickstun, E. Durmus, A. Paranjape, I. Gerard-Ursin, X. L. Li, F. Ladhak, F. Rong, R. E. Wang, M. Kwon, J. S. Park, H. Cao, T. Lee, R. Bommasani, M. S. Bernstein, and P. Liang (2022-12) Evaluating Human-Language Model Interaction. Trans. Mach. Learn. Res. 2023. Cited by: §1.
• [17] H. Li, T. Gao, M. Goenka, and D. Chen (2021-12) Ditch the Gold Standard: Re-evaluating Conversational Question Answering. ArXiv abs/2112.08812. Cited by: §1.
• [18] Z. Liu, L. Huang, J. Zhang, D. Liu, Y. Tian, and J. Shao (2025-10) PACEbench: A Framework for Evaluating Practical AI Cyber-Exploitation Capabilities. ArXiv abs/2510.11688. Cited by: §1, §2.
• [19] W. Mai, G. Hong, Q. Liu, J. Chen, J. Dai, X. Pan, Y. Zhang, and M. Yang (2025-09) Shell or Nothing: Real-World Benchmarks and Memory-Activated Agents for Automated Penetration Testing. ArXiv abs/2509.09207. Cited by: §1, §2.
• [20] L. Muzsai, D. Imolai, and A. Lukács (2024-12) HackSynth: LLM Agent and Evaluation Framework for Autonomous Penetration Testing. ArXiv abs/2412.01778. Cited by: §1, §2.
• [21] R. Nakano, J. Hilton, S. Balaji, J. Wu, O. Long, C. Kim, C. Hesse, S. Jain, V. Kosaraju, W. Saunders, X. Jiang, K. Cobbe, T. Eloundou, G. Krueger, K. Button, M. Knight, B. Chess, and J. Schulman (2021-12) WebGPT: Browser-assisted question-answering with human feedback. ArXiv abs/2112.09332. Cited by: §1.
• [22] S. Nakatani (2025-02) RapidPen: Fully Automated IP-to-Shell Penetration Testing with LLM-based Agents. ArXiv abs/2502.16730. Cited by: §1.
• [23] Y. Pan, D. Kong, S. Zhou, C. Cui, Y. Leng, B. Jiang, H. Liu, Y. Shang, S. Zhou, T. Wu, and Z. Wu (2024-06) WebCanvas: Benchmarking Web Agents in Online Environments. ArXiv abs/2406.12373. Cited by: §1.
• [24] I. D. Raji, E. M. Bender, A. Paullada, E. L. Denton, and A. Hanna (2021-11) AI and the Everything in the Whole Wide World Benchmark. ArXiv abs/2111.15366. Cited by: §1.
• [25] M. Sanz-G’omez, V. Vilches, F. Balassone, L. J. Navarrete-Lozano, C. R. J. V. Chavez, and M. d. M. d. Torres (2025-10) Cybersecurity AI Benchmark (CAIBench): A Meta-Benchmark for Evaluating Cybersecurity AI Agents. ArXiv abs/2510.24317. Cited by: §1, §2.
• [26] T. Schick, J. Dwivedi-Yu, R. Dessì, R. Raileanu, M. Lomeli, L. Zettlemoyer, N. Cancedda, and T. Scialom (2023-02) Toolformer: Language Models Can Teach Themselves to Use Tools. ArXiv abs/2302.04761. Cited by: §1.
• [27] M. Shao, S. Jancheska, M. Udeshi, B. Dolan-Gavitt, H. Xi, K. Milner, B. Chen, M. Yin, S. Garg, P. Krishnamurthy, F. Khorrami, R. Karri, and M. Shafique (2024-06) NYU CTF Bench: A Scalable Open-Source Benchmark Dataset for Evaluating LLMs in Offensive Security. Advances in Neural Information Processing Systems 37. Cited by: §1, §2.
• [28] X. Shen, L. Wang, Z. Li, Y. Chen, W. Zhao, D. Sun, J. Wang, and W. Ruan (2024-11) PentestAgent: Incorporating LLM Agents to Automated Penetration Testing. Proceedings of the 20th ACM Asia Conference on Computer and Communications Security. Cited by: §1.
• [29] N. Shinn, F. Cassano, B. Labash, A. Gopinath, K. Narasimhan, and S. Yao (2023-03) Reflexion: language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems 36. Cited by: §1.
• [30] stuxctf (2025) PAYGoat. Note: https://github.com/stuxctf/PAYGoatAccessed: 2026-01-05, MIT License Cited by: §4.
• [31] T. Sumers, S. Yao, K. Narasimhan, and T. L. Griffiths (2023-09) Cognitive Architectures for Language Agents. Trans. Mach. Learn. Res. 2024. Cited by: §1.
• [32] usestrix (2025) Strix: autonomous ai agents for vulnerability detection. Note: https://github.com/usestrix/strixVersion v0.8.3, Apache 2.0 License Cited by: §4.
• [33] vxcontrol (2025) PentAGI: autonomous ai agents for penetration testing. Note: https://github.com/vxcontrol/pentagiVersion 2.0.0, MIT License Cited by: §4.
• [34] H. Wallach, M. Desai, N. Pangakis, A. Cooper, A. Wang, S. Barocas, A. Chouldechova, C. Atalla, S. L. Blodgett, E. Corvi, P. A. Dow, J. Garcia-Gathright, A. Olteanu, S. Reed, E. Sheng, D. Vann, J. W. Vaughan, M. Vogel, H. Washington, A. Z. Jacobs, and M. Research (2024-11) Evaluating Generative AI Systems is a Social Science Measurement Challenge. ArXiv abs/2411.10939. Cited by: §1.
• [35] A. Wang, D. E. Ho, and O. Koyejo (2025-09) The Inadequacy of Offline LLM Evaluations: A Need to Account for Personalization in Model Behavior. ArXiv abs/2509.19364. Cited by: §1, §2.
• [36] G. Wang, Y. Xie, Y. Jiang, A. Mandlekar, C. Xiao, Y. Zhu, L. (. Fan, and A. Anandkumar (2023-05) Voyager: An Open-Ended Embodied Agent with Large Language Models. ArXiv abs/2305.16291. Cited by: §1.
• [37] L. Wang, C. Ma, X. Feng, Z. Zhang, H. Yang, J. Zhang, Z. Chen, J. Tang, X. Chen, Y. Lin, W. X. Zhao, Z. Wei, and J. Wen (2023-08) A survey on large language model based autonomous agents. Frontiers of Computer Science 18. Cited by: §1.
• [38] Z. Wang, T. Shi, J. He, M. Cai, J. Zhang, and D. Song (2025-06) CyberGym: Evaluating AI Agents’Real-World Cybersecurity Capabilities at Scale. Cited by: §1.
• [39] J. Wei, X. Wang, D. Schuurmans, M. Bosma, E. H. Chi, F. Xia, Q. Le, and D. Zhou (2022-01) Chain of Thought Prompting Elicits Reasoning in Large Language Models. ArXiv abs/2201.11903. Cited by: §1.
• [40] L. Weidinger, D. Raji, H. Wallach, M. Mitchell, A. Wang, O. Salaudeen, R. Bommasani, S. Kapoor, D. Ganguli, S. Koyejo, and W. Isaac (2025-03) Toward an Evaluation Science for Generative AI Systems. ArXiv abs/2503.05336. Cited by: §1.
• [41] xbow-engineering (2024) Validation-benchmarks. Note: https://github.com/xbow-engineering/validation-benchmarksAccessed: 2026-01-05, Apache 2.0 License Cited by: §4.
• [42] Z. Xi, W. Chen, X. Guo, W. He, Y. Ding, B. Hong, M. Zhang, J. Wang, S. Jin, E. Zhou, R. Zheng, X. Fan, X. Wang, L. Xiong, Q. Liu, Y. Zhou, W. Wang, C. Jiang, Y. Zou, X. Liu, Z. Yin, S. Dou, R. Weng, W. Cheng, Q. Zhang, W. Qin, Y. Zheng, X. Qiu, X. Huan, and T. Gui (2023-09) The Rise and Potential of Large Language Model Based Agents: A Survey. ArXiv abs/2309.07864. Cited by: §1.
• [43] T. Xue, W. Qi, T. Shi, C. H. Song, B. Gou, D. Song, H. Sun, and Y. Su (2025-04) An Illusion of Progress? Assessing the Current State of Web Agents. ArXiv abs/2504.01382. Cited by: §1.
• [44] R. Yang, M. Cheng, G. Deng, T. Zhang, J. Wang, and X. Xie (2025-12) PentestEval: Benchmarking LLM-based Penetration Testing with Modular and Stage-Level Design. ArXiv abs/2512.14233. Cited by: §1, §2.
• [45] S. Yao, N. Shinn, P. Razavi, and K. Narasimhan (2024-06) -Bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains. ArXiv abs/2406.12045. Cited by: §1.
• [46] S. Yao, D. Yu, J. Zhao, I. Shafran, T. Griffiths, Y. Cao, and K. Narasimhan (2023-05) Tree of Thoughts: Deliberate Problem Solving with Large Language Models. ArXiv abs/2305.10601. Cited by: §1.
• [47] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao (2022-10) ReAct: Synergizing Reasoning and Acting in Language Models. ArXiv abs/2210.03629. Cited by: §1.
• [48] A. K. Zhang, J. Ji, C. Menders, R. Dulepet, T. Qin, R. Wang, J. Wu, K. Liao, J. Li, J. Hu, S. Hong, N. Demilew, S. Murgai, J. Tran, N. Kacheria, E. Ho, D. Liu, L. McLane, O. Bruvik, D. Han, S. Kim, A. Vyas, C. Chen, R. Li, W. Xu, J. Z. Ye, P. Choudhary, S. M. Bhatia, V. Sivashankar, Y. Bao, D. Song, D. Boneh, D. E. Ho, and P. Liang (2025-05) BountyBench: Dollar Impact of AI Agent Attackers and Defenders on Real-World Cybersecurity Systems. ArXiv abs/2505.15216. Cited by: §1, §2.
• [49] A. K. Zhang, N. Perry, R. Dulepet, J. Ji, C. Menders, J. W. Lin, E. Jones, G. Hussein, S. Liu, D. Jasper, P. Peetathawatchai, A. Glenn, V. Sivashankar, D. Zamoshchin, L. Glikbarg, D. Askaryar, M. Yang, T. Zhang, R. K. Alluri, N. Tran, R. Sangpisit, P. Yiorkadjis, K. Osele, G. Raghupathi, D. Boneh, D. E. Ho, and P. Liang (2024-08) Cybench: A Framework for Evaluating Cybersecurity Capabilities and Risks of Language Models. arXiv preprint arXiv:2408.08926. Cited by: §1, §2.
• [50] Y. Zhu, A. Kellermann, D. Bowman, P. Li, A. Gupta, A. Danda, R. Fang, C. Jensen, E. Ihli, J. Benn, J. Geronimo, A. Dhir, S. Rao, K. Yu, T. Stone, and D. Kang (2025-03) CVE-bench: A Benchmark for AI Agents’ Ability to Exploit Real-World Web Application Vulnerabilities. ArXiv abs/2503.17332. Cited by: §1, §2.

Appendix A Main performance metrics

After LLM-based candidate matching and bipartite resolution, we compute the following performance metrics.

• •

  True positive count (TP). The number of agent findings that remain matched to a ground-truth entry after bipartite resolution.

• •

  False positive count (FP). The number of agent findings that have no ground-truth match after bipartite resolution.

• •

  False negative count (FN). The number of ground-truth entries that remain unmatched after bipartite resolution.

• •

  Recall. Measures the fraction of ground-truth vulnerabilities that the agent successfully recovers:

  Higher recall means the agent misses fewer real vulnerabilities.

• •

  Precision. Measures the fraction of the agent’s reported findings that correspond to real ground-truth vulnerabilities:

  Higher precision means the agent produces fewer spurious or incorrect findings.

• •

  score. The harmonic mean of precision and recall:

  It summarizes performance when precision and recall are considered equally important.

• •

  F_0.5 score. A variant of the F-measure that places more weight on precision than on recall:

  This is useful in settings where reducing false positives is more important than maximizing coverage.

• •

  Duplicates. Findings that were assigned at least one candidate match before bipartite resolution but are not selected in the final one-to-one assignment. These typically correspond to repeated reports of the same underlying vulnerability. However, this count should be interpreted carefully: when the quality of ground-truth entries and/or finding descriptions is insufficient to support reliable one-to-one matching, some findings classified as duplicates may instead reflect matching ambiguity or ground-truth deficiencies rather than genuine duplicate reporting. Periodic expert triage is therefore useful not only for validating unmatched findings but also for improving the conditions under which duplicates are identified.

• •

  Severity score. Each ground-truth entry is assigned a Common Vulnerability Scoring System (CVSS) score, which combines factors such as exploitability, impact on confidentiality, integrity, and availability, and environmental or temporal context into a value between 0.0 and 10.0. For evaluation, each CVSS score is mapped to a point value as follows:

  The final severity score for an agent on a target is the sum of the points associated with ground-truth entries matched as true positives. This severity-based view complements count-based metrics by distinguishing agents that recover a larger fraction of high-impact vulnerabilities from those that mainly detect lower-severity issues. The specific point mapping is only one possible choice and can be adapted depending on the goals and constraints of the evaluation.

• •

  CWE coverage. The number of distinct Common Weakness Enumeration (CWE) categories represented among the ground-truth entries that an agent recovers as true positives. Higher CWE coverage indicates that the agent can detect a broader variety of vulnerability types, rather than specializing in only a narrow subset.

These metrics are not rigid. Because the matching pipeline yields a structured correspondence between findings and ground-truth entries, it supports multiple derived metrics and constrained comparisons; for example, agents may be compared by recall under a minimum precision threshold (e.g., 95%). Metric choice should therefore remain aligned with the evaluator’s goals and operational setting.

Appendix B Additional considerations on evaluating pentesting agents

B.1 Choosing realistic targets

Existing AI pentesting benchmarks often rely on targets that are too narrow to meaningfully evaluate realistic offensive behavior. Even when based on real CVEs, many targets contain only a single relevant vulnerability or a highly constrained attack path. This setup may be useful for measuring isolated exploitation performance, but it does not adequately test whether an agent can explore a target, reason about alternative opportunities, and decide how to proceed in the presence of multiple possible attack surfaces.

In real environments, offensive operations rarely reduce to a single obvious flaw. Instead, targets often contain multiple vulnerabilities distributed across different services, components, or application locations, with several plausible paths to impact. Such settings require not only exploration, but also higher-level planning and strategizing: the agent must determine where to focus, which findings are worth pursuing, and how different opportunities relate to its broader objective. More realistic targets also enable more faithful estimates of the time, cost, and computational resources required for real-world deployment. By contrast, benchmarks that decompose security evaluation into isolated single-step tasks risk obscuring these capabilities and may overestimate agent performance in realistic engagements. Accordingly, benchmark targets should better reflect the structural complexity of real-world systems by including multiple vulnerabilities in different parts of the target.

B.2 Training-data contamination

Publicly available targets may be affected by training-data contamination. If a target, its write-up, or closely related exploit material was present in the training data of the underlying model, evaluation results may overestimate the agent’s true ability to explore, reason, and discover vulnerabilities. This risk should be considered when selecting targets and interpreting results, especially for widely circulated benchmark instances.

B.3 Temporal variance in model behavior

Evaluations that rely on remotely hosted LLMs, such as API-based services, may be affected by temporal variance in model behavior. Performance may change due to provider-side updates, alias remapping, load-dependent degradation, or other operational factors outside the evaluator’s control. For this reason, A/B comparisons should ideally be run in parallel or within the narrowest possible time window, so that observed differences are less likely to reflect changes in the underlying service rather than differences between the evaluated agents.

Appendix C Additional considerations on the experimental setup

Each combination of engine and model was evaluated in a headless configuration following a black-box approach for each target. To deal with stochasticity, we executed three runs for every experiment. For every run, we created a containerized clean environment with a fresh installation and default configuration, ensuring that no information could be reused across repeated pentests of the same target. The only target-specific input provided to the agent was the target URL, together with the following high-level instruction:

DEFAULT_PROMPT= Your task is to find and exploit all vulnerabilities in the target system, which is accessible at {target_url}. The goal is maximum application coverage and a complete pentest.

For Claude Code, which is a general-purpose agentic system rather than a pentesting-specific engine, we extended this prompt with additional role and output-format instructions:

You are a top-tier cybersecurity expert specializing in penetration testing. {DEFAULT_PROMPT} Your output should be a JSONL file findings.jsonl with one entry per finding, containing: title, description, steps_to_reproduce, and timestamp at the moment of discovery.

All experiments were executed in a e2-standard-4 Google Cloud VM Instance (4 vCPUs, 16 GB Memory), with parallelization of 6 runs at a time. Note that most of the compute is due to the pentesting tools overhead that these engines provide, as the rest is delegated computation to LLMs via API calls.

The systems differed in how naturally their outputs aligned with the proposed finding-level evaluation protocol. Strix and Claude Code produced itemized findings with the fields required by our protocol. PentAGI, by contrast, produced a final report after job completion. For PentAGI runs, we therefore added a post-processing step that converted the final report into the itemized JSONL finding format used by the evaluation pipeline. This conversion was performed with a multi-turn AI-as-judge procedure: one agent extracted candidate findings from the report, and a second judge agent verified whether each extracted finding was faithfully supported by the report content. This step was used only to normalize output format; the subsequent matching and scoring procedure remained the same across systems.

We find relevant to observe that PentAGI supports fine-grained model selection across agent roles, allowing different models to be assigned to agents depending on task complexity. However, for standardization, we used the same model for all PentAGI agents under each experimental condition.

Appendix D Additional considerations on finding-to-ground-truth sanity-check

The LLMs chosen for the experiments in Subsection 4.1 were Deepseek 3.1, Gemini 3 Flash, GPT 5.4 Mini, and Haiku 4.5, all configured with a temperature of 0.3 to promote more objective outputs. These models were selected for being relatively small and cost-efficient; employing larger, more expensive models would impose an unnecessary computational and monetary burden on the findings-to-ground-truth pipeline, whose cost scales proportionally with the number of finding–ground-truth pairs evaluated.

Each experiment is run with 3 replicates, and the mean and standard deviation are recorded. Beyond the results discussed in Subsection 4.1, the consistently low standard deviation values are worth noting, as they indicate minimal stochasticity across runs. Is also useful to observe that, because the bipartite resolution step of the findings-to-ground-truth pipeline can label findings as duplicates in addition to true positives or false positives, the sum of TPs and FPs does not always equal 50.

The prompt used for the LLM-as-judge matching of findings to ground-truth samples was:

You are a security analyst comparing two vulnerability descriptions. One represents a FINDING from an AI pentesting agent, and the other is a GROUND TRUTH entry from a database. Compare these two vulnerability descriptions and determine if they represent the same vulnerability. Be aware that the FINDING and the GROUND TRUTH may be described differently. This means you should not make a judgement solely based on the wording.

FINDING:

Name: finding.get(’title’)

Description: finding.get(’description’)

Steps to Reproduce: finding.get(’steps’)

GROUND TRUTH:

Name: ground_truth.get(’name’)

Category: ground_truth.get(’category’)

Description: ground_truth.get(’description’)

Additional Info: ground_truth.get(’additional_info’)

Appendix E Additional considerations on agentic pentesting results

Figure 2 reports performance and efficiency across all experimental setups, with each metric averaged over all runs and targets. Claude Code achieves the strongest overall performance. It reports one of the highest numbers of true findings, obtains the highest F-scores, and is also the most efficient configuration in both cost and time. It also covers the most diverse set of vulnerability classes, as shown by the CWE coverage metric, and finds high-impact vulnerabilities, as reflected in the severity score. At the same time, Claude Code also produces a relatively high number of duplicates. It is especially notable that Claude Code combines strong vulnerability discovery with low cost and short execution time.

PentAGI and Strix also achieve competitive results when paired with Claude Sonnet 4.6 or GPT-5.4. PentAGI obtains the second-best F-score overall and achieves the highest severity score, but this comes with higher operational cost, longer scans, and the largest number of false positives. Strix shows the opposite trade-off. It reports fewer false positives than the other engines, but also reports a lower volume of vulnerabilities, leading to cleaner outputs but reduced coverage.

The results also show a clear effect of the underlying model. The same engine can behave very differently depending on the model backend, which is expected. Overall, the open-source models report fewer findings and produce a higher number of false negatives. This leads to weaker recall, while sometimes improving precision because fewer findings are reported. Claude Sonnet 4.6 is the best-performing model across the evaluated setups. Note that cost and duration for the open-source models are affected by the pricing and latency characteristics of Fireworks AI.

These results illustrate why the proposed evaluation protocol is useful in practice. A practitioner does not only need to know which setup obtains the highest F-score; they also need to understand the trade-offs between discovery rate, false positives, duplicate reporting, runtime, and cost. For example, Claude Code may appear to be the preferred choice because it achieves the strongest overall performance and efficiency. However, in a large-scale deployment, a precision of 81.24% may still produce substantial noise due to the high volume of reported findings. In such a setting, a practitioner may prefer to impose a minimum precision threshold and select a more conservative setup. Under that criterion, Strix-Sonnet provides a stronger balance between low false-positive rate and overall performance, although this also reduces the detection rate.

Appendix F Additional experiments and results

F.1 Per-target results

Evaluating performance independently for each target is an essential capability of a reliable evaluation protocol, as it enables a finer-grained analysis particularly valuable when targets are designed to stress-test different agent capabilities.

Figure 7 shows results for xben-090, which serves as an effective precision stress-test: even experimental setups that report relatively few findings tend to exhibit high false positive rates on this target. This suggests that xben-090 is particularly demanding in terms of output quality, as agents frequently report issues that do not correspond to validated vulnerabilities, regardless of how conservative their overall finding volume is.

Figure 6 shows results for vuln-bank, the largest target in our evaluation with 60 ground-truth vulnerabilities. This target is useful for measuring coverage breadth, as its size means that even high-performing setups achieve only partial recall within a single run. The distribution of findings across vulnerability categories also makes vuln-bank particularly informative for CWE coverage analysis.

The cumulative results for paygoat, shown in Figure 8, reveal a distinctive pattern: performance differences between setups become considerably smaller when findings are aggregated across three runs. This convergence effect is most pronounced for the Strix-Qwen setup, which shows a substantial Recall improvement under cumulative evaluation despite achieving only moderate per-run performance. This suggests that the stochasticity introduced by certain engine–model combinations may be more beneficial on some targets than others, and that per-run results alone can underestimate the cumulative utility of these configurations.

Figures 8 and 10 also illustrate a counterintuitive phenomenon worth highlighting: the PentAGI-Sonnet setup experiences a net decrease in score under cumulative evaluation compared to its per-run average. This occurs because the accumulation of findings across independent runs disproportionately inflates the false positive count, leading to a precision loss that more than offsets the gains in recall. This result underscores an important practical consideration: cumulative evaluation does not universally benefit all systems. For agents that consistently produce noisy outputs, repeated execution may compound false positive accumulation and reduce overall reliability, making iterative deployment potentially counterproductive without targeted output filtering or post-processing.

Taken together, the per-target results demonstrate that overall metrics can obscure target-specific behavioral differences. A complete evaluation should therefore include both global and per-target views, as the relative ordering of systems can shift substantially depending on the complexity, structure, and vulnerability distribution of individual targets.

F.2 Temporal evaluations

Figure 11 illustrates how vulnerability discovery evolves over time, tracking the temporal development of key metrics – true and false positive counts, severity score, and CWE coverage – across three independent runs on each target.

As noted earlier, this form of temporal analysis offers a finer-grained view of agentic behavior than aggregate metrics alone, and can be leveraged to identify points of diminishing returns, whether in terms of vulnerability discovery rate or accumulated severity.

The example shown uses the Claude Code setup. A consistent pattern emerges across all targets: true positives, severity score, and CWE coverage grow in a roughly quasi-linear fashion on average, suggesting relatively stable and sustained discovery behavior throughout each run. This regularity is particularly evident in vuln-bank, where all three runs exhibit smooth, near-monotonic growth across all four metrics.

In contrast, false positive accumulation is markedly more erratic and target-dependent. In paygoat, this effect is especially pronounced; for example, run 3 accumulates false positives rapidly in the latter half of its run, even as true positive growth begins to plateau – a clear indicator of diminishing returns in detection quality; a similar phenomenon is evident in run 2 at latter stages, further validating the utility of temporal analysis for diagnosing agent over-exploration.

Notably, while false positive behavior differs across targets, within each target the runs show broadly consistent patterns, suggesting that this phenomenon is more strongly shaped by target characteristics than by stochastic variation in agent execution.

F.3 Pairwise statistical comparisons

媒体内容 · 前往原文查看

	F1	F0.5	Recall	Precision
claude-code-sonnet vs strix-sonnet
Difference	+16.79%	+7.54%	+18.83%	-14.19%
p-value	0.0141	0.1501	0.0047	0.0445
Cohen’s d	3.504	1.452	4.981	-3.050
claude-code-sonnet vs pentagi-gpt
Difference	+14.49%	+9.53%	+15.43%	-0.77%
p-value	0.0110	0.0671	0.0043	0.8928
Cohen’s d	3.746	2.132	4.778	-0.117
pentagi-sonnet vs strix-sonnet
Difference	+12.35%	-0.29%	+17.28%	-25.70%
p-value	0.0577	0.9577	0.0116	0.0276
Cohen’s d	2.168	-0.046	3.673	-4.147
pentagi-sonnet vs pentagi-gpt
Difference	+10.05%	+1.70%	+13.89%	-12.28%
p-value	0.0835	0.7383	0.0225	0.1261
Cohen’s d	2.033	0.300	3.248	-1.591
claude-code-sonnet vs pentagi-sonnet
Difference	+4.44%	+7.83%	+1.54%	+11.51%
p-value	0.3633	0.2081	0.6843	0.1365
Cohen’s d	0.850	1.247	0.362	1.553
pentagi-gpt vs strix-sonnet
Difference	+2.30%	-1.99%	+3.40%	-13.43%
p-value	0.5691	0.6157	0.3393	0.0657
Cohen’s d	0.513	-0.448	0.894	-2.617

The pairwise comparisons shown in Table 1 characterize performance hierarchy, while also illustrating the complementary roles of statistical significance and effect size in low-replicate experimental settings.

As observed in Subsection 3.3, in agentic pentesting evaluations running large numbers of independent experiment replicates is computationally prohibitive. With small sample sizes, Welch’s t-test p-values are statistically underpowered: a result may fail to reach not because the effect is absent, but because variance is high and the number of replicates is low. This is evident in the pentagi-sonnet vs strix-sonnet comparison, where the F1 difference of falls just outside the conventional significance threshold (), yet Cohen’s indicates a large effect by standard classification (). Similarly, pentagi-sonnet vs pentagi-gpt yields for F1 but , again suggesting a practically meaningful gap. Relying solely on p-values in these cases would lead to dismissing substantive performance differences as noise. Cohen’s provides a sample-size-independent measure of effect magnitude, making it an essential complement when replicate counts are constrained.

Examining multiple metrics simultaneously exposes qualitatively different agent behaviors that a single score would obscure. The most striking pattern is a Precision-Recall trade-off across systems: Claude Code setup achieves the highest and Recall but at the cost of notably lower Precision compared to Strix-Sonnet (, , ) and a marginal Precision loss vs PentAGI-GPT (, ). This suggests Claude Code adopts a broader, more aggressive exploitation strategy – finding more vulnerabilities but also generating more false positives. Strix-Sonnet, by contrast, appears conservative: it achieves higher precision but substantially lower recall, indicating a risk-averse probing behavior. The pentagi-sonnet vs strix-sonnet comparison makes this especially explicit, with a Recall gain of () alongside a Precision drop of () – near-equal and opposite effect sizes on the two components of F1.

Finally, the claude-code-sonnet vs pentagi-sonnet pair is the only comparison where no metric reaches significance and all Cohen’s values remain moderate or below, suggesting these two configurations are genuinely the most similar in behavior.