Multi-Agent Penetration Testing AI for the Web

TL;DR

This paper introduces MAPTA, a multi-agent AI system that autonomously assesses web application security, achieving high success rates on various vulnerabilities with low operational costs, addressing scalability issues in security auditing.

Contribution

The paper presents MAPTA, a novel multi-agent system combining large language models and tool-grounded execution for efficient, autonomous web security testing with demonstrated effectiveness on benchmarks and real-world data.

Findings

Achieves 76.9% success on XBOW benchmark

Discovered critical vulnerabilities in open-source repositories

Operates at a median cost of $0.073 per challenge

Abstract

AI-powered development platforms are making software creation accessible to a broader audience, but this democratization has triggered a scalability crisis in security auditing. With studies showing that up to 40% of AI-generated code contains vulnerabilities, the pace of development now vastly outstrips the capacity for thorough security assessment. We present MAPTA, a multi-agent system for autonomous web application security assessment that combines large language model orchestration with tool-grounded execution and end-to-end exploit validation. On the 104-challenge XBOW benchmark, MAPTA achieves 76.9% overall success with perfect performance on SSRF and misconfiguration vulnerabilities, 83% success on broken authorization, and strong results on injection attacks including server-side template injection (85%) and SQL injection (83%). Cross-site scripting (57%) and blind SQL injection (0%) remain challenging. Our comprehensive cost analysis across all challenges totals $21.38 with a median cost of $0.073 for successful attempts versus $0.357 for failures. Success correlates strongly with resource efficiency, enabling practical early-stopping thresholds at approximately 40 tool calls or $0.30 per challenge. MAPTA's real-world findings are impactful given both the popularity of the respective scanned GitHub repositories (8K-70K stars) and MAPTA's low average operating cost of $3.67 per open-source assessment: MAPTA discovered critical vulnerabilities including RCEs, command injections, secret exposure, and arbitrary file write vulnerabilities. Findings are responsibly disclosed, 10 findings are under CVE review.

Tables

Table 1. Table 1: Agent Types and Tool Interfaces

Agent Type	Tool Interface and Role
Coordinator	Plans, orchestrates, synthesizes: sandbox_agent, run_command, run_python, get_registered_emails, list_account_messages, get_message_by_id, send_slack_alert, send_slack_summary
Sandbox (1..N)	Executes tactics in isolated LLM context but shared container: run_command, run_python
Validation	Consumes and refines candidate PoC; executes concretely; returns pass/fail with evidence

Table 2. Table 2: MAPTA’s performance on the 104 XBOW Benchmark Challenge

Metric	Value	Metric	Value
Total Challenges	104	Success Rate	76.9%
Successful Challenges	80	Failed Challenges	24
Avg. Solve Time	275.0s	Median Solve Time	143.2s
Min Solve Time	26.3s	Max Solve Time	1428.7s
Total Regular Input Tokens	3,244,880	Total Output Tokens	1,100,790
Total Cached Tokens	50,524,032	Total Reasoning Tokens	594,880
Total Token Cost	$21.38	Avg. Cost per Challenge	$0.206
Total Commands	2613	Avg. Commands per Challenge	25.1

Table 3. Table 3: Per-Target Vulnerability Assessment Results with Token Breakdown by Agent

	GitHub	Main Agent Tokens			Sandbox Agent Tokens			Vulnerabilities			Cost
Target	$\star$	Regular	Cached	Output	Regular	Cached	Output	H	M	L	($)
OSN-06	21K	22K	270K	12K	322K	6.9M	70K	4	2	0	4.85
OSN-03	9K	9K	17K	11K	28K	372K	23K	5	1	0	1.57
OSN-04	18K	47K	834K	15K	176K	1.1M	117K	1	1	1	6.05
OSN-05	36K	40K	615K	20K	253K	1.7M	116K	2	0	0	6.55
OSN-01	26K	221K	3.8M	18K	182K	200K	180K	1	0	0	8.02
OSN-02	8K	8K	18K	8K	79K	657K	30K	1	0	0	1.97
appsmith	38K	12K	35K	9K	40K	339K	34K	0	0	0	2.11
directus	32K	11K	58K	11K	40K	536K	34K	0	0	0	1.97
gitea	50K	9K	18K	9K	131K	1.4M	27K	0	0	0	1.93
grafana	70K	7K	25K	10K	254K	432K	19K	0	0	0	1.73

Full text

We present MAPTA, a multi-agent system for autonomous web application security assessment that combines large language model orchestration with tool-grounded execution and end-to-end exploit validation. On the 104-challenge XBOW benchmark, MAPTA achieves 76.9% overall success with perfect performance on SSRF and misconfiguration vulnerabilities, 83% success on broken authorization, and strong results on injection attacks including server-side template injection (85%) and SQL injection (83%). Cross-site scripting (57%) and blind SQL injection (0%) remain challenging. Our comprehensive cost analysis across all challenges totals $21.38 with a median cost of$0.073 for successful attempts versus $0.357 for failures. Success correlates strongly with resource efficiency, enabling practical early-stopping thresholds at approximately 40 tool calls or$0.30 per challenge.

MAPTA’s real-world findings are impactful given both the popularity of the respective scanned GitHub repositories (8K-70K stars) and MAPTA’s low average operating cost of $3.67 per open-source assessment: MAPTA discovered critical vulnerabilities including RCEs, command injections, secret exposure, and arbitrary file write vulnerabilities. Findings are responsibly disclosed, 10 findings are under CVE review.

1 Introduction

Web application security assessment faces a fundamental scalability crisis driven by AI-powered development acceleration. AI-assisted development platforms democratize application creation, enabling non-technical entrepreneurs and domain experts to build web services without traditional programming knowledge. However, this broader developer demographic lacks security expertise, creating applications with larger attack surfaces. The fastest-growing businesses today (from AI coding assistants to no-code platforms) accelerate application development, but security assessment remains constrained by manual processes and tools requiring human interpretation.

The core challenge lies in the semantic gap between pattern-based vulnerability detection and contextual exploitation understanding. A SQL injection pattern in source code may be completely unexploitable due to prepared statements, input validation, or database permissions invisible to static analysis. Conversely, business logic vulnerabilities, particularly those involving multi-step attack chains, often evade detection by signature-based tools, as they exploit application-specific workflows rather than known patterns [14, 1]. Studies and industry reports emphasize that such flaws represent a significant share of real-world web application vulnerabilities, yet remain under-detected by automated scanners [23].

Recent advances in large language models (LLMs) and autonomous agent systems offer an approach to bridge this semantic gap. LLMs demonstrate reasoning capabilities about code semantics, security patterns, and exploitation strategies [4, 5]. However, applying these capabilities to penetration testing requires orchestration of tools and the meticulous verification of theoretical vulnerabilities through practical exploitation attempts, i.e. end-to-end proof-of-concept exploits.

Pioneering research systems have demonstrated the viability of LLM-driven penetration testing. PentestGPT [8] established foundational multi-stage workflows for enumeration and exploitation, while PenHeal [13] advanced the field by coupling vulnerability discovery with automated remediation strategies. These systems validated the core premise that LLMs can reason about security assessment tasks and coordinate tool usage for autonomous testing.

However, existing approaches face critical limitations: lack of rigorous cost-performance analysis along with insufficient vulnerability validation leading to false positives. While commercial systems like XBOW have emerged claiming competitive performance and contributing valuable benchmarks to the community, they lack scientific reproducibility in their core methodologies, with only high-level descriptions available through blog posts rather than detailed system architectures or open-source implementations [10].

We present MAPTA (Multi-Agent Penetration Testing AI), to the best of our knowledge the first open-source multi-agent penetration testing AI system for the web, enabling end-to-end, continuous penetration testing without human intervention. MAPTA’s approach fundamentally transforms security assessment from human-dependent pattern recognition to adaptive adversarial execution, where AI agents autonomously reason about application behavior, adapt exploitation strategies, and validate vulnerabilities through concrete execution, matching the speed of AI-powered development.

1.1 Key Insights and Contributions

Our work addresses the scalability-accuracy tradeoff in web application security through several key insights. Building on the foundational work of PentestGPT and PenHeal, MAPTA advances the state-of-the-art through rigorous cost-performance measurement, mandatory proof-of-concept validation for all findings, and multi-agent orchestration that reduces the false positives and resource inefficiencies of prior approaches. Rather than a monolithic AI system, we employ a multi-agent architecture with a coordinator agent for strategic coordination and multiple sandbox agents for tactical execution. This separation enables high-level reasoning about attack strategies while maintaining secure, isolated execution of tools and exploits. LLMs require tools to conduct penetration testing, so our architecture integrates tools (nmap, python, ffuf) through orchestration, where agents reason about tool selection, parameter configuration, and result interpretation based on target application characteristics. We distinguish theoretical vulnerabilities from practical exploits through sandboxed proof-of-concept execution. This approach transforms vulnerability assessment from hypothesis generation to empirical validation, reducing false positives while providing actionable security intelligence. Our system adapts testing strategies based on discovered application characteristics, and importantly, partial exploitation results. This adaptation mimics human penetration tester reasoning while operating at machine scale and minutes of average assessment time. Our contributions include:

• •

Tool-grounded multi-agent architecture. We design a three-agent-roles system where the Coordinator handles orchestration, Sandbox agents perform tactical execution within a shared per-job Docker container, and a Validation agent serves as end-to-end proof-of-concept oracles to eliminate theoretical findings and reduce false positives (Figure 1, Table 1, §2.1–2.3).

• •

Cost–performance accounting with actionable results. We provide resource accounting across 104 XBOW challenges, tracking token-level I/O (3.2M regular input, 50.5M cached, 1.10M output, 0.595M reasoning; $21.38 total) with a median cost of$0.117 per challenge. Our analysis reveals strong negative correlations between success and resource consumption (tools r = -0.661, cost -0.606, tokens -0.587, time -0.557), enabling practical early-stopping thresholds of approximately 40 tool calls, $0.30, or 300 seconds (§3.2–3.3, Table 2, Fig. 3–8).

• •

Black-box performance on modern web targets. We achieve 76.9% success across 104 XBOW challenges, with perfect performance on SSRF and misconfiguration vulnerabilities and strong results on server-side template injection (85%), SQL injection (83%), and command injection (75%). We identify remaining performance gaps in areas such as blind SQL injection (0%) and cross-site scripting (57%) (§3.2, §3.4, Fig. 7, Table 2).

• •

Real-world white-box validation. We demonstrate practical impact through testing ten popular open-source applications (8K–70K GitHub stars) across modern technology stacks including Next.js, React, Node.js, and Flask. This evaluation discovered 19 vulnerabilities, with 14 classified as high or critical severity and 10 pending CVE assignments, all accompanied by end-to-end proof-of-concept exploits under responsible disclosure (§4.1).

• •

Open-science artifacts. We provide the code, our evaluation results, and fixes for 43 out of 104 outdated XBOW Benchmark Docker images to enable reproducibility in autonomous security testing.

2 Architecture

This section describes MAPTA’s multi-agent design that orchestrates specialized roles for autonomous penetration testing with mandatory proof-of-concept validation.

2.1 Multi-Agent Architecture

MAPTA implements a three-role, tool-driven architecture that couples high-level planning with concrete exploit execution. A Coordinator agent performs strategy and delegation; Sandbox agents execute inside a single per-job Docker container; and a Validation agent converts candidate findings into verified, end-to-end PoCs. Orchestration is dynamic—the Coordinator decides at runtime when to delegate to sandbox agents through the sandbox_agent tool versus acting directly—while resource handling uses thread-local isolation and per-scan accounting for elegant teardown, reproducibility, and concurrent safety.

Within this work, an agent is an LLM-driven controller with (i) a goal (“obtain verified PoC for a target”), (ii) a bounded action space (security tools it may call and how to parameterize them), (iii) an observation stream (tool outputs, HTTP responses, code, telemetry), (iv) short-term memory/state (its working context and artifacts), and (v) termination/budget rules (stop on validated exploit or when cost/time/tool-call limits hit). In MAPTA this manifests concretely as role-specialized agents—Coordinator (orchestrates), Sandbox (executes commands/code in an isolated per-job container), and Validation (turns a candidate into an end-to-end PoC and returns pass/fail evidence).

Coordinator Agent.

Responsible for attack-path reasoning, tool orchestration, and report synthesis. The coordinator operates with 8 tools: sandbox_agent (delegate to a sandbox agent), run_command, run_python, email workflow helpers get_registered_emails, list_account_messages, get_message_by_id, and alerting via send_slack_alert, send_slack_summary.

Sandbox Agents (1..N).

Execute tactical steps with isolated LLM context for focus and to keep the Coordinator’s context clean. Each sandbox agent operates with 2 tools: run_command (shell) and run_python (Python). All sandbox agents spawned by the same Coordinator operate on the same per-job Docker container, enabling stateful reuse of filesystem artifacts, dependencies, credentials, and reconnaissance outputs across subtasks.

Validation Agent.

Consumes a candidate PoC artifact (HTTP request sequence, payload, or script) and verifies exploitability by concrete execution on the per-job docker container, returning pass/fail with evidence (flag capture for CTF or side-effect evidence for real targets). The intent of this design is to reduce the reporting of theoretical findings. We understand that this could also potentially result in false negatives, where theoretical findings are valid and could materialize under a different state space.

2.2 Threat Model

MAPTA operates under two distinct testing methodologies depending on the evaluation scenario, each representing different real-world penetration testing approaches.

Blackbox Local CTF Assessment. For CTF challenges (XBOW benchmark evaluation), MAPTA operates under a pure blackbox model from an external attacker perspective. The system receives only (local) target URLs and challenge descriptions, without access to source code, database schemas, or internal configurations. Testing proceeds through behavioral analysis of application responses, error messages, timing characteristics, and other externally observable features to infer vulnerabilities and develop exploitation strategies. This approach mirrors real-world external penetration testing scenarios where attackers have no insider knowledge.

Whitebox Local Assessment. For real-world application evaluation, MAPTA conducts whitebox security assessments of locally cloned open-source repositories. This methodology provides complete source code access, enabling the agents to mimic static analysis, dependency vulnerability scanning, and code flow analysis to identify potential attack vectors. Applications are pulled, deployed and tested within virtual isolated local environments.

Both methodologies operate within strict ethical constraints, avoiding destructive operations, data exfiltration, or persistent system modifications. CTF testing targets purpose-built vulnerable applications designed for security assessment, while whitebox testing occurs entirely within isolated local sandboxes to prevent any impact on production systems or third-party infrastructure.

2.3 Scope and Limitations

MAPTA targets web vulnerabilities that are (i) reachable over HTTP(S) and (ii) verifiable via concrete end-to-end PoCs, favoring classes where exploitability—not just pattern matches—can be demonstrated. In the evaluation we cover 13 categories spanning the majority of OWASP Top 10 (2021) and several OWASP API Top 10 (2023) families (Figure 7).

Our primary focus encompasses access control vulnerabilities (A01), including insecure direct object references (IDOR), privilege escalation, and function-level authorization flaws that align with API security concerns such as BOLA and BFLA. These authorization weaknesses represented 29 challenges in our evaluation with 83% success rate, demonstrating MAPTA’s effectiveness in identifying access control bypasses through systematic privilege boundary testing.

Injection vulnerabilities (A03) constitute another major evaluation category, spanning SQL injection, blind SQL injection, command injection, and server-side template injection (SSTI). We evaluate cross-site scripting (XSS) as a distinct injection vector due to its unique exploitation characteristics. MAPTA achieved strong performance on SSTI (85% success), standard SQL injection (83%), and command injection (75%), while showing challenges with XSS variants (57%) and complete difficulty with blind SQL injection scenarios (0% success), indicating areas for future improvement in timing-based attack detection.

Security misconfigurations (A05) and server-side request forgery (A10) represent categories where MAPTA achieved perfect performance (100% success each). Misconfigurations include server configuration errors, CORS policy failures, and exposed administrative interfaces, while SSRF evaluation focuses on end-to-end exploitation demonstrating internal network access or cloud metadata extraction. Similarly, cryptographic failures and sensitive data exposure (A02) scenarios achieved 100% success where present in the dataset, covering weak randomness in secret generation and inadvertent credential leakage through client-side exposure.

Authentication vulnerabilities (A07) encompass session management weaknesses, login bypass techniques, and broken authentication mechanisms, achieving 33% success rate in our evaluation. This lower performance indicates the complexity of authentication flow analysis and the need for enhanced session state reasoning. Business logic vulnerabilities classified under insecure design (A04) require multi-step reasoning about application-specific workflows, while vulnerable and outdated components (A06) are detected through dependency analysis in white-box assessment mode with impact validation where feasible.

Limitations. Our approach has several inherent limitations including the exclusion of network-level vulnerabilities such as SSL/TLS misconfigurations, network protocol vulnerabilities, or infrastructure security beyond what is discoverable through application-layer testing, and the inability to assess physical security controls, social engineering vulnerabilities, or human factors beyond what can be tested through technical means. We also do not evaluate OWASP A08 (Software & Data Integrity Failures) or A09 (Logging/Monitoring Failures). While our authorization testing results subsume key OWASP API Top 10 security issues such as the mentioned BOLA, BFLA, and related object-level authorization flaws, we do not target resource consumption, rate limiting, or API observability concerns in this work.

While MAPTA reduces false positives through end-to-end proof-of-concept exploit generation and concrete execution with the validation agent within a virtual environment, we cannot guarantee zero false positives, particularly for complex business logic vulnerabilities. Business logic flaws often require a deeper understanding of application-specific workflows, user roles, and intended behaviors that may be difficult to distinguish from legitimate functionality through automated testing alone. For instance, a multi-step transaction that appears to bypass authorization controls may represent intended behavior under specific conditions not apparent to automated analysis. Future work may for example add automated canary placement systems that embed detectable markers throughout application workflows to provide additional exploitation validation.

2.4 Orchestration Logic

MAPTA executes within a bounded loop. Each assessment progresses through four phases with explicit stop conditions (validated exploit, budget/time/tool-call caps). Figure 1 shows the roles and per-job container while Table 1 lists tool interfaces. As the orchestrator agent sees fit, the execution flow may begin with a hypothesis synthesis, where the Coordinator derives likely attack surfaces and a prioritized set of probes with gating predicates (e.g., endpoint present, auth state obtained) from the target description and early telemetry. This may then lead to targeted dispatch, where probes are executed, either inline (run_command, run_python) or via sandbox_agent for focused sub-tasks such as payload crafting, enumeration bursts, or multi-step request sequences. Outputs are normalized into observations that feed the gating predicates with a global retry loop bounded by a maximum number of attempts. When preconditions for an exploit path are satisfied, the system may move to PoC assembly, where the Coordinator constructs a minimal PoC artifact—whether a request sequence, payload, or script—together with an expected oracle or side-effect for verification. Finally, during validation and finalization, the PoC is handed to the Validation agent for concrete execution or refinement, yielding a pass/fail result with evidence (flag in CTF scenarios; state change, data access, or RCE evidence in real-world assessments). The job terminates on a successful validation or when budget caps (time, tool calls, token/cost) are reached. CTF runs use a single agent and treat flag extraction as the oracle, while real-world runs employ the full Coordinator + Sandbox + Validation architecture with PoC-by-execution. Both operational modes share the same single-pass controller and per-job Docker isolation.

2.5 Execution Environment and Isolation

Each assessment runs in one Docker container per job, a virtual machine hosting a linux derivate, in our case Ubuntu. All agents attached to the same Coordinator share this container to amortize setup cost and retain state (installed toolchains, enumerations, downloaded artifacts). The container is ephemeral and terminated at job end. We distinguish LLM context isolation (separate prompts/memory per sandbox agent to help agents to focus) from system state sharing (single container), which reduces prompt bloat and cross-talk while preserving useful runtime state across sub-tasks. Only Docker is used as the isolation substrate in our deployment.

Job lifecycle and safety guarantees.

The job lifecycle follows three distinct phases: first, the system creates a fresh per-job container and injects only job-scoped credentials and configuration as needed; second, sandbox agents reuse the same container so that intermediate artifacts (auth cookies, wordlists, compiled helpers) persist across steps; and finally, on completion or failure, the system gracefully stops and removes the container, purges job-scoped secrets, and persists only evidence and minimal logs for reproducibility. This lifecycle yields predictable, low-overhead execution with isolation between concurrent jobs.

2.6 Configurations: CTF vs Real-World

CTF (blackbox).

In the CTF configuration, the system operates as a single agent (Coordinator only) where the Coordinator executes directly via run_command and run_python tools, and validation reduces to flag extraction as the ground-truth oracle. This configuration mirrors external attacker constraints and aligns to our knowledge with the XBOW evaluation methodology. Because the XBOW CTF challenges are blackbox based, they require less context (no source) and have relatively simple web applications without extensive JavaScript code that we would expect in larger web applications. Hence, a single agent mode appears appropriate.

Real-World (whitebox).

For real-world assessments, we deploy the full multi-agent architecture comprising a Coordinator, one or more Sandbox agents, and a Validation agent. The Coordinator dynamically offloads tasks to sandbox agents (sharing the same per-job container) for targeted enumeration and exploit development, while the Validation agent executes proof-of-concept exploits end-to-end to confirm impact with concrete evidence such as state changes, data access, or remote code execution.

2.7 Resource Handling and Observability

Each MAPTA sandbox agent runs in its own thread for parallelization, while we perform accounting with a per-scan UsageTracker:

• •

Tooling: counts, latencies for run_command/run_python and delegation via sandbox_agent;

• •

LLM I/O: input/output/cached/reasoning tokens and cost;

• •

Wall-clock: end-to-end runtime.

The tracker enables budget caps (cost/time/tool-call limits), early stopping when success likelihood drops, and graceful teardown on limit hit. Empirically, we observe negative correlations between success and resource use (tools, tokens, cost, and time) (see §3.3).

Summarizing, MAPTA separates orchestration (Coordinator) from acting (Sandbox) and verifying (Validation), maintains context isolation for agent cognition while sharing a single Docker runtime per job, and enforces measure-first engineering through resource tracking and controlled teardown.

3 CTF Evaluation

We evaluate MAPTA using the XBOW benchmark [25], a practical CTF benchmark for autonomous penetration testing evaluation. While we initially planned to include comparisons with the PentestGPT benchmark [8], the associated repository was unavailable at the time of evaluation.

We therefore evaluate MAPTA using the XBOW benchmark, a collection of 104 web application security challenges designed for autonomous penetration testing evaluation. XBOW’s recognition as the #1 penetration testing platform on HackerRank in 2025 underscores its industry relevance and challenge quality for evaluating autonomous security systems. Each challenge contains a specific security flaw with an associated flag that serves as proof of successful exploitation, creating a binary success metric that eliminates evaluation ambiguity—either the system finds the correct flag or it fails.

Prior work has established that OpenAI’s models, particularly GPT-4, demonstrate superior performance compared to other publicly available LLMs on information security and penetration testing tasks [8, 13]. Industry practitioners, including XBOW’s commercial penetration testing platform, corroborate these findings through empirical deployment experience [26]. Given these established performance characteristics and to focus our limited financial resources, we focus our evaluation exclusively on GPT-5 under high-effort agent configurations throughout this work.

The CTF evaluation operates under blackbox conditions where MAPTA receives only the target URL and challenge description, matching real-world penetration testing scenarios. While the XBOW benchmark includes vulnerability type and category metadata in Docker readmes, we withheld these detailed classifications from MAPTA to ensure autonomous strategy determination based solely on observed application behavior. Challenge descriptions occasionally contained vulnerability hints, but this mirrors realistic penetration testing engagements where limited contextual information is available. Each challenge deploys as an isolated Docker container with standardized network configuration. 43 of the original 104 XBOW Docker images required manual fixes due to deprecated software versions—we completed extensive engineering efforts to restore functionality and plan to contribute these fixes back to the community via pull request to ensure continued dataset availability. We further have not found any online CTF solutions for this benchmark, and hence believe that MAPTAs solutions represent genuine discovery rather than model-trained regurgitation.

3.1 Evaluation Metrics

We measure MAPTA’s performance using four objective metrics. First, we use a binary success metric for flag discovery: either MAPTA finds the correct flag (100% success) or fails (0% success). This eliminates false positive concerns since only correct exploitation yields the flag. Second, we measure time to solution as the total time from challenge start to flag discovery, measured in seconds, including reconnaissance, vulnerability analysis, and exploitation phases. Third, we track computational cost as the total cost in USD for LLM API calls, calculated using GPT-5 pricing at the time of writing ($1.25/1M input tokens,$10.00/1M output tokens, $0.125/1M cached tokens). Finally, we assess tool execution efficiency through the number of tool invocations required to reach the solution, measuring the efficiency of the agent’s exploration strategy.

3.2 Results and Performance Analysis

MAPTA achieved a 76.9% success rate across the complete XBOW dataset, successfully solving 80 of 104 challenges. Table 2 presents performance metrics including timing, cost, and resource utilization characteristics.

Our analysis reveals cost efficiency characteristics, as demonstrated in Figure 3. Challenges averaged $0.206 per attempt across the full dataset, with the cost breakdown revealing output tokens as the primary expense, reflecting the system’s analytical reasoning requirements.

Examining tool execution patterns, Figure 5 reveals adaptive tool selection with challenges averaging 25.1 tool calls per challenge. The distribution shows command execution heavily favored over Python runtime calls, indicating MAPTA’s preference for direct tool calling. Complex challenges demonstrate the system’s persistent approach to multi-step vulnerability analysis. Figure 6 shows curl as the dominant command across all challenges, reflecting the HTTP-centric nature of web application testing, while bash usage patterns indicate sophisticated exploitation scenarios requiring shell access.

The temporal performance characteristics illustrated in Figure 2 demonstrate efficient exploitation capabilities. The 275.0-second average solution time reflects the full dataset complexity, with a median solve time of 143.2 seconds indicating consistent performance for most challenges, while the maximum time of 1428.7 seconds represents the most complex failed challenges that reached timeout limits.

Finally, our token utilization analysis in Figure 4 reveals efficient usage patterns across different categories. Cached tokens comprise the largest portion of total token usage, contributing to cost reduction through context reuse. Also, higher reasoning token usage correlates with challenge complexity and multi-step exploitation scenarios.

3.3 Resources and Success Correlations

Our correlation analysis (point-biserial, Pearson with binary outcome and N=104) across all challenge metrics reveals negative correlations between success and resource utilization, providing insights into agent behavior and efficiency patterns. All correlations are statistically significant (p<0.001).

Tool Usage vs Success (r=-0.661). The negative correlation indicates that more tool calls correlate with lower success rates, suggesting that failed attempts involve more exploratory tool usage as the agent struggles to find viable attack vectors. 2. 2.

Cost vs Success (r=-0.606). Higher computational costs associate with failures, indicating that failed challenges consume more expensive resources through extended reasoning cycles and repeated tool invocations. 3. 3.

Token Usage vs Success (r=-0.587). More tokens used in unsuccessful attempts, possibly due to longer reasoning and exploration cycles as the agent attempts multiple approaches without finding successful exploitation paths. 4. 4.

Time vs Success (r=-0.557). Longer time spent correlates with failure, showing a clear pattern of quick successes versus prolonged unsuccessful attempts.

These correlations reveal a clear efficiency pattern: successful challenges tend to be solved quickly with fewer resources, while failed challenges involve extensive exploration, more tools, longer reasoning, and higher costs. The agent appears to recognize successful paths quickly but struggles with certain challenge types despite increased resource investment. This suggests challenges may have distinct "solvable" versus "unsolvable" categories for this agent configuration, indicating opportunities for implementing early stopping mechanisms to optimize resource utilization.

Statistical Interpretation and Limitations. While these correlations are statistically significant with substantial effect sizes (r=-0.661 explains  44% of variance in success), several caveats merit consideration. The binary nature of our outcome variable (success/failure) somewhat limits correlation interpretation compared to continuous outcomes. More importantly, correlation does not imply causation—these relationships likely reflect underlying challenge difficulty rather than resource usage directly causing failure. Difficult challenges require more exploration attempts, leading to higher resource consumption regardless of the agent’s capability.

Practical Value. Nevertheless, these patterns remain meaningful and actionable for system optimization. Specifically, production deployments can implement early stopping when tool usage exceeds 40+ calls (95th percentile of successful challenges), cost surpasses $0.30 per target (indicating likely failure), or execution time reaches 300+ seconds without significant progress. For resource budgeting, organizations can allocate$0.073 per target for successful assessments versus $0.357 for exploration of difficult targets, enabling cost-predictable security assessment workflows.

3.4 Vulnerability Category Performance

Figure 7 presents MAPTA’s performance across 13 distinct vulnerability categories using the complete 104-challenge XBOW dataset. The Sankey flow visualization reveals both overall success patterns and category-specific performance characteristics that inform system optimization strategies.

Overall Performance. MAPTA achieved a success rate of 76.9% (80/104 challenges), demonstrating performance across diverse vulnerability types. This performance approaches XBOW’s reported 84.6% coverage in July 2024, achieving within 7.7 percentage points of the commercial system’s claimed performance. Notably, XBOW has not published detailed methodology, system architecture, or reproducible evaluation protocols beyond high-level blog posts with sample prompts, making independent verification impossible. In contrast, MAPTA provides transparency with open-source implementation, detailed architectural descriptions, and evaluation methodology. To our knowledge, MAPTA represents the first open-source penetration testing AI system achieving competitive performance with commercial alternatives while maintaining scientific reproducibility.

Injection Vulnerability Performance. The analysis reveals nuanced performance across injection vulnerability subtypes. Server-Side Template Injection (SSTI) shows exceptional performance with 85% success rate (11/13 challenges), indicating MAPTA’s capability in template injection analysis. SQL Injection maintains high success at 83% (5/6 challenges), while Command Injection achieves 75% success (6/8 challenges). However, Cross-Site Scripting (XSS) demonstrates lower success at 57% (13/23 challenges) despite being the largest category, and Blind SQL Injection shows 0% success rate (0/3 challenges), representing the most challenging category for the current system.

Authorization and Authentication. Broken Authorization challenges achieve 83% success rate (24/29 challenges), demonstrating capability in identifying IDOR, path traversal, and privilege escalation vulnerabilities. However, Broken Authentication shows lower performance at 33% success (1/3 challenges), indicating areas for improvement in authentication bypass techniques.

High-Performance Categories. Several categories demonstrate perfect or near-perfect success rates: Server-Side Request Forgery (100%, 3/3), Misconfiguration (100%, 3/3), Sensitive Data Exposure (100%, 2/2), and Cryptographic vulnerabilities (100%, 1/1). These results indicate MAPTA’s capability in network-based attacks.

Performance Insights. The category-specific analysis reveals that MAPTA excels at vulnerabilities requiring systematic analysis and tool-based discovery (SSRF, misconfigurations, SQL injection) but struggles with vulnerabilities requiring complex payload crafting or timing-based analysis (Blind SQL injection, certain XSS variants). This performance pattern suggests optimization opportunities through enhanced payload generation and feedback-based exploration strategies.

3.5 Failure Analysis

Analysis of the 24 failed challenges (23.1% of the dataset) reveals specific patterns and areas for improvement in autonomous penetration testing. Failed challenges consumed significantly higher computational resources, with maximum execution times reaching 1428.7 seconds and higher average costs per attempt. The correlation analysis confirms this pattern, showing that resource-intensive challenges typically indicate unsuccessful exploitation attempts.

The failure distribution across vulnerability categories provides actionable insights: Blind SQL Injection represents the most challenging category with 0% success rate, indicating limitations in timing-based attack detection and payload refinement. XSS challenges show moderate success (57%) despite representing the largest category, suggesting opportunities for enhanced payload generation and DOM manipulation strategies. Broken Authentication failures (67% failure rate) highlight the need for improved credential analysis and session manipulation capabilities.

4 Real-World Application Assessment

To evaluate MAPTA’s effectiveness beyond controlled environments, we conducted assessments on 10 production open-source web application code spanning 51K-1.3M lines of code with GitHub popularity ranging from 8K-70K stars. These applications represent diverse architectural patterns including React/Next.js frontends, Node.js/Python backends, and containerized microservice deployments. Each assessment followed a standardized protocol: (1) automated repository fetching, (2) dynamic application deployment in an isolated sandbox environment, followed by (4) a payload-guided vulnerability exploration using MAPTA’s multi-agent architecture. The main agent averaged 620K tokens for planning and coordination, while sandbox agents consumed 413K-7.3M tokens for hands-on security testing, reflecting the computational intensity of practical vulnerability discovery.

4.1 Vulnerability Discovery Results

Responsible Disclosure Note: In accordance with responsible disclosure practices, we have anonymized the identities of applications where vulnerabilities were discovered, using obfuscated names (OSN-XX) for these targets. Applications where no vulnerabilities were found (appsmithorg/appsmith, directus/directus, go-gitea/gitea, grafana/grafana) are identified by their repository names to demonstrate the breadth of our evaluation across diverse, production-grade codebases.

MAPTA identified 19 vulnerabilities across 6 applications (60% discovery rate), with a severity distribution of 73.7% High/Critical, 21.1% Medium, and 5.3% Low/Informational. Assessment costs averaged $3.67 per application over 50.7 minutes, demonstrating practical feasibility for continuous security testing workflows. Figure 9 illustrates the relationship between vulnerability discovery and assessment costs across target applications, showing that cost does not directly correlate with findings—some of the most expensive assessments yielded no vulnerabilities while others discovered critical issues at lower computational cost.

Example Critical Vulnerabilities Discovered:

• •

Command Injection via Database Export: Direct shell command construction enabling arbitrary code execution through PostgreSQL connection parameters (PGPASSWORD="$this.config.password" pg_dump --schema-only "$input")

• •

Client-Side Secret Exposure: Server-side API keys delivered via JavaScript configuration endpoints (window.env = {OPENAI_API_KEY: "$OPENAI_API_KEY"})

• •

postMessage RCE: Arbitrary code execution through overly permissive cross-frame origin validation (case ’builder.evaluate’: new Function(text))

• •

Unauthenticated Email Relay with SSRF: Public API endpoints accepting arbitrary SMTP credentials and remote attachment URLs (fileUrls: "http://169.254.169.254/latest/meta-data/")

• •

Arbitrary File Write via Client-Controlled Tools: Remote clients enabling dangerous file operations through tool merging (input.tools override enabling PatchTool)

Example High Severity Patterns:

• •

Unauthenticated API Integration Abuse: Third-party service access using attacker-supplied credential IDs (Google Sheets, Stripe PaymentIntent creation)

• •

Insecure Cryptographic Implementation: Non-cryptographic RNG for API key generation (Math.random() for 64-character secret keys)

• •

Path Traversal via File Access APIs: Unvalidated file path parameters enabling arbitrary file reads (File.read(path) without containment checks)

• •

Unauthenticated Administrative Endpoints: Critical system operations exposed without authorization (/share_delete_admin clearing Durable Objects)

Example Medium Severity Patterns:

• •

XSS via Environment Injection: Unescaped server-side template rendering in configuration endpoints ("$OPENAI_API_ENDPOINT" string interpolation)

• •

CSRF Across REST APIs: State-changing operations without Origin validation or CSRF tokens (API token creation, user invitations)

• •

SSRF via Integration APIs: Server-side request forgery through legitimate webhook and file import functionality

• •

Open Redirect via Payment Flows: Unchecked URL parameters in checkout processes (success_url, cancel_url)

5 Related Work

5.1 Classical Automated Web Security Testing

Traditional automated security testing approaches have evolved significantly over the past two decades, yet fundamental limitations persist that motivate advanced AI-driven solutions like MAPTA.

Dynamic scanners like OWASP ZAP [20] and Burp Suite [22] crawl web applications and fuzz HTTP parameters to identify common vulnerabilities. While valuable for baseline security assessment, traditional DAST approaches suffer from limitations when testing modern web applications. Single-page applications with dynamic JavaScript content may evade crawling, and business logic vulnerabilities requiring multi-step interactions remain largely undetectable due to scanners’ lack of contextual understanding for complex application workflows.

Static analysis tools examine source code to identify potential vulnerabilities without execution. However, empirical evaluations reveal significant limitations: a study of seven Java SAST tools found only 12.7% of real-world vulnerabilities were detected, with the union of all tools missing  71% [16]. Poor detection rates stem from challenges in modeling complex data flows, handling dynamic language features, and reasoning about runtime exploitability conditions. SAST tools generate high false positive rates due to conservative assumptions, while struggling with vulnerability classes requiring runtime context. This gap between theoretical detection and practical exploitability directly motivates MAPTA’s verify-by-execution approach.

Hybrid approaches combine static analysis with runtime instrumentation to reduce false positives by validating execution paths. However, deployment challenges limit adoption due to instrumentation requirements, performance overhead, and complexity across microservices and containers.

API-driven architectures introduce vulnerability classes that traditional scanners struggle with. The OWASP API Security Top 10 (2023) [17] highlights business logic vulnerabilities like BOLA, BFLA, and IDOR requiring understanding of application-specific access controls. These vulnerabilities demand stateful interaction sequences and reasoning about intended versus actual behavior.

5.2 Stateful REST/API Fuzzing

Traditional stateless fuzzing fails to detect business logic vulnerabilities, motivating stateful approaches that maintain application state across multi-step sequences.

Microsoft Research’s RESTler [3] introduced request dependency graphs from OpenAPI specifications, analyzing relationships between API calls to construct meaningful multi-step interaction sequences. RESTler’s success in discovering vulnerabilities in Azure and Office365 demonstrates the value of dependency-aware testing over naive parameter fuzzing. Extensions like Pythia [2] add coverage feedback and learning-based mutations for more targeted exploration.

Specialized frameworks like Yelp’s fuzz-lightyear target specific vulnerability classes (IDOR/BOLA) through stateful Swagger-based fuzzing. These tools demonstrate that effective business logic detection requires understanding semantic relationships between data objects and authorization controls—the fundamental pattern MAPTA generalizes through statefulness, property checks, and oracle-backed validation.

5.3 LLMs for Secure Code

Large Language Models show promise for cybersecurity tasks but have significant limitations that inform MAPTA’s design.

GitHub Copilot generates code containing vulnerabilities in  40% of CWE-targeted scenarios [21], stemming from reproducing insecure patterns in training data. These AI-generated flaws often appear functionally correct but contain subtle security issues in input validation, authentication, or cryptographic implementation that evade traditional code review.

Comprehensive surveys [6] show that while LLMs excel at security reasoning and hypothesis generation, they require external oracles and environment feedback to validate outputs and avoid hallucinations—a pattern MAPTA addresses through tool integration and concrete execution.

Google’s Big Sleep project discovered a zero-day in SQLite (November 2024) and helped foil exploitation [12, 11]. However, it remains closed-source without technical details, preventing independent verification or scientific advancement. This opacity exemplifies the broader challenge in AI security research where commercial systems achieve results but fail to advance understanding due to proprietary constraints—motivating MAPTA’s open science approach.

5.4 LLM-Driven Autonomous Testing and Tool Orchestration

Autonomous penetration testing systems represent evolution from static detection toward dynamic, reasoning-based assessment enabled by sophisticated tool orchestration. Recent advances in agentic AI systems demonstrate that tool interaction fundamentals impact performance across complex domains. ReAct [28] and Toolformer [24] established that LLMs achieve superior performance through structured tool interaction and environmental feedback loops, while SWE-agent [27] demonstrates that interface design and tool abstractions determine success rates on complex technical tasks.

PentestGPT [8] pioneered multi-stage LLM workflows for enumeration, exploitation, and privilege escalation with self-interaction capabilities. PentestGPT operates through hardcoded interactive loops with optional human oversight, limiting scalability for continuous large scale assessment workflows. Additionally, the system lacks true agentic capabilities—the PentestGPT project explicitly states that “PentestGPT v2.0 agentic upgrade will be ready soon,” indicating current limitations in autonomous decision-making and tool orchestration. While contributing structured prompting techniques and evaluation metrics, the system revealed limitations in long-horizon state management and vulnerability validation. The system reports aggregate costs ($131.5 for 10 HTB machines;$5.1 average per picoMini attempt) and discusses token conservation strategies with GPT-4-32k context limits.

Subsequent research addresses these limitations through complementary approaches: PenHeal [13] couples discovery with remediation using knapsack optimization but does not report token usage—the “cost” metric represents remediation scoring rather than LLM operational expenses. RefPentester [7] adds self-reflection and knowledge-guided planning, while browser-capable agents [15] enable direct web interaction for CSRF/SSRF testing.

MAPTA advances autonomous security assessment through resource measurement and operational efficiency analysis that addresses fundamental gaps in prior work. Our evaluation provides complete token-level accounting across 104 XBOW challenges: 3.2M regular input, 1.10M output, 50.5M cached, and 0.595M reasoning tokens, totaling $21.38 overall cost with median$0.117 per challenge. This granular breakdown reveals output tokens as the primary cost driver, enabling resource optimization strategies unavailable prior.

Beyond cost accounting, MAPTA quantifies negative correlations between resource utilization and success—tool calls (r=-0.661), dollar cost (r=-0.606), tokens (r=-0.587), and time (r=-0.557)—providing actionable early-stopping heuristics and budget allocation guidance for production deployments. Our multi-agent architecture employs a coordinator/sandbox design with dynamic tool use, combined with end-to-end proof-of-concept validation that eliminates the false positives inherent in theoretical detection approaches. While prior systems discuss token pressure mitigation strategies, MAPTA measures and quantifies the complete operational profile, establishing the first rigorous cost-performance framework for autonomous penetration testing systems.

5.5 Benchmarks and Testbeds

Traditional vulnerable applications (Juice Shop [18], WebGoat [19], DVWA [9]) focus on vulnerability types with implementations unsuitable for evaluating advanced systems. The XBOW benchmark dataset [25] represents significant advancement by providing modern web application challenges with REST APIs, complex business logic, and realistic authentication mechanisms. XBOW’s key innovation emphasizes exploit execution validation over theoretical detection—each challenge requires actual exploitation success, eliminating false positives and aligning with real-world penetration testing objectives. Our approach builds on the fundamental insight from related work that effective automated security assessment requires tool orchestration, stateful reasoning, and practical verification [28, 3]. MAPTA’s multi-agent architecture with sandboxed exploit validation directly addresses the limitations identified in single-agent systems like PentestGPT [8] and traditional scanners’ false-positive challenges [16].

6 Conclusion

MAPTA demonstrates that multi-agent architectures can achieve competitive autonomous web application security assessment at practical scale. Our evaluation across 104 XBOW challenges achieves 76.9% success with perfect performance on SSRF and misconfiguration vulnerabilities, while revealing systematic weaknesses in blind SQL injection (0%) and cross-site scripting (57%). The comprehensive cost accounting totaling $21.38 establishes the first rigorous resource model for autonomous penetration testing, with median costs of$0.073 for successful attempts versus $0.357 for failures.

While our CTF evaluation (N=104) revealed strong correlations between resource usage and success (enabling early-stopping thresholds at approximately 40 tool calls, $0.30, or 300 seconds), these patterns cannot be validated in our whitebox assessment due to the smaller sample size (N=10). Yet, MAPTA’s real-world validation is impactful with 19 discovered vulnerabilities across ten popular open-source applications, of which *14 classified as high or critical severity* (including RCE, command injections, secret exposure and arbitrary file write), at an average cost of$3.67 per assessment. All findings are responsibly disclosed to the respective parties and bug bounty programs, where applicable. In total we are awaiting responses from 10 findings that are under CVE review. We expect that larger real-world scans will uncover substantially more vulnerabilities, and recommend deploying MAPTA on a continuous basis for immediate defensive action of web applications.

Ethical Considerations

The development and evaluation of MAPTA raises important ethical considerations regarding responsible disclosure of AI-powered security testing capabilities. We address these concerns through several key principles and safeguards implemented throughout our research.

Defensive Publication and Community Awareness. The primary ethical imperative for publishing this research stems from the reality that adversarial actors likely possess similar capabilities or are actively developing them. The democratization of AI development tools and the public availability of security testing methodologies means that malicious applications of these techniques are inevitable. By publishing our findings, we enable the cybersecurity community to understand and prepare for these emerging threats. Defensive security benefits from transparency about offensive capabilities, allowing organizations to implement appropriate countermeasures and security professionals to develop detection and mitigation strategies.

Controlled Evaluation Environments. Our evaluation methodology deliberately avoids testing against live production systems to prevent unintended harm or service disruption. We conducted two distinct types of assessments: (1) blackbox evaluation using purpose-built CTF challenges from the XBOW benchmark, which are explicitly designed for security testing and vulnerability discovery, and (2) whitebox assessments of open-source applications conducted entirely within isolated local environments. The whitebox evaluations involved cloning public repositories and conducting all testing within our own sandboxed virtual machines, ensuring no impact on production deployments or third-party infrastructure.

Sandboxed Testing Infrastructure. We implemented isolation measures to prevent any testing activities from affecting external systems. All MAPTA evaluations execute within dedicated virtual machines with restricted network access, preventing unintended outbound connections or data exfiltration. The sandbox environment includes monitoring and logging mechanisms to ensure all testing activities remain contained within the designated test boundaries. This approach eliminates risks of collateral damage while maintaining the authenticity of real-world vulnerability assessment scenarios.

Responsible Vulnerability Disclosure. For vulnerabilities discovered during our whitebox assessments, we follow responsible disclosure practices by notifying maintainers of affected projects through appropriate channels. The 10 vulnerabilities submitted for CVE assignment were reported to the respective project maintainers with sufficient detail for remediation while avoiding public disclosure of exploitation techniques until patches are available. We provide actionable remediation guidance and collaborate with maintainers to ensure timely resolution of identified security issues.

Dual-Use Technology Considerations. We acknowledge that MAPTA represents dual-use technology with both defensive and potentially offensive applications. To mitigate misuse risks, our implementation focuses on defensive security applications and includes built-in ethical constraints that prevent destructive operations, data exfiltration, or persistent system modifications. The system is designed to generate proof-of-concept demonstrations rather than weaponized exploits, providing sufficient evidence for vulnerability validation without enabling direct malicious use.

Access Control and Distribution. While we commit to making MAPTA source code publicly available upon publication to enable scientific reproducibility and defensive research, we implement responsible access controls. The release includes documentation emphasizing ethical use guidelines, configuration options for defensive-only operation modes, and integration with existing responsible security testing frameworks. We encourage adoption by legitimate security professionals, researchers, and organizations while discouraging malicious applications through community governance and ethical use agreements.

The fundamental ethical principle guiding this research is that the cybersecurity community benefits more from understanding these capabilities than from attempting to suppress them. As AI-powered development accelerates application creation, correspondingly advanced security assessment tools become essential for maintaining adequate security postures. MAPTA represents a defensive response to this challenge, providing organizations with capabilities to match the evolving threat landscape while adhering to responsible research and deployment practices.

Open Science & Availability

In accordance with the Open Science Policy, we provide complete access to all research artifacts necessary to evaluate and reproduce the contributions presented in this paper. All artifacts are available at https://github.com/arthurgervais/mapta. The updated XBOW 104 Challenge Evaluation Framework is available at https://github.com/arthurgervais/validation-benchmarks.