Pith. sign in

REVIEW 4 major objections 4 minor 25 references

Reinforcement Learning for Automated Cybersecurity Penetration Testing

T0 review · 4 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper claims a reinforcement-learning agent, trained only on simulated websites, extracted every vulnerability its tool set could reach when run against the real vulnerable applications DVWA and DockerLabs.

desk verdict A sensible GDL symmetry prior and simulator design, but the qualitative, non-independent evaluation can't support the paper's central claim. read the letter →

arxiv 2507.02969 v1 pith:3WJ5AX3U submitted 2025-06-30 cs.CR cs.AI

Daniel López-Montero , José L. Álvarez-Aldana , Alicia Morales-Martínez , Marta Gil-López , Juan M. Auñón García This is my paper
classification cs.CRcs.AI
keywords reinforcementlearningpenetrationtestingwebapplicationsecuritygeometricdeeppermutationinvariancesimulation-basedtrainingvulnerabilitydiscoveryproximalpolicyoptimization
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that penetration testing of web applications can be automated by a reinforcement-learning agent that decides, at each step, which security tool to run, on which URL, and with which configuration. The agent is trained entirely in a simulated environment where random tree-shaped websites are generated procedurally, then tested on real vulnerable applications (DVWA and DockerLabs) commonly used for hacker training. The reported result is that the agent extracted all vulnerabilities within its capabilities, while the abstract states the algorithm maximizes vulnerabilities found and minimizes steps taken. If the claim holds, the expertise-heavy process of choosing and sequencing attack tools could be delegated to a policy that balances discovery reward against action cost, trained cheaply and safely in simulation.

What carries the argument

The load-bearing mechanism is an RL control loop over a structured cybersecurity MDP. Per URL the action space is $A_{url} = T_1 \sqcup T_2 \sqcup T_3 \sqcup T_4 \sqcup T_5$ with $|A_{url}| = 134$: crawler (28 configurations), form and parameter detection (1), SQL injection (90), brute force (24), and cross-site scripting (3), and the full action space is $|A| = 134n$ for $n$ discovered URLs. The state records, for each action, whether it has been executed and its latest reward, augmented with URL features and a decaying temporal memory $\lambda^t$ that down-weights old observations. The reward is a convex combination of discovery value $V$ (new URLs, status codes, parameters, SQLi/XSS types, credentials, goal reached) and action cost $C$. Training happens in a simulator whose website topologies are generated by a modified Barabási-Albert algorithm and whose nodes are seeded with status codes, tools, versions, and vulnerabilities from unspecified probability distributions. What makes the approach scale is treating the URL set as an unordered collection: the Critic aggregates per-URL values by summation (permutation invariance) and the Actor concatenates per-URL logits (permutation equivariance), which the paper reads as a special case of a Graph Neural Network with isolated nodes.

What would settle it

Two checks would settle it. First, at the simulator level: run the same actions both in the simulator and with the real tools against DVWA or DockerLabs, and compare the distributions of HTTP status codes, discovered parameters, and vulnerabilities — divergence means the training environment does not justify the real-world claim. Second, at the agent level: take a fresh real target with an independently documented vulnerability inventory and count whether the agent finds every vulnerability its 134-action toolset is capable of detecting; any reachable-but-missed entry refutes the completeness result.

Watch

Extended reading notes

Core claim

The central claim is that a reinforcement-learning policy can learn to prioritize and sequence penetration-testing actions well enough to match, within its tool set, a complete vulnerability sweep of real web targets. The task is formulated as a bi-objective Markov Decision Process with a 134-action toolset per URL (crawler depths, dictionary fuzzing, form and parameter detection, SQL injection levels/risks/techniques, credential brute force, and XSS levels), a state that tracks past action outcomes with exponential temporal decay, and a reward $R(s_t,a_t,s_{t+1}) = \mu V(s_t,s_{t+1}) + (1-\mu)C(a_t)$ that pays for newly discovered information and vulnerabilities while charging a fixed computational cost per action. The agent is trained on procedurally generated simulated websites — random trees built with a modified Barabási-Albert algorithm — and, after a hyperparameter search that selects PPO over SAC and DQN, tested on the real sites DVWA and DockerLabs, where the authors report it successfully extracted all vulnerabilities within its capabilities. The scaling trick that makes the model feasible — 69,304 parameters despite a state and action space that grow with every discovered URL — is a geometric-deep-learning prior: the Critic is permutation-invariant across URLs (summing per-URL value heads) and the Actor is permutation-equivariant (concatenating per-URL logits).

Load-bearing premise

The whole result depends on the simulated websites behaving like real ones: the policy learns whatever the simulator teaches, so if the simulated security tools respond differently from the actual tools on DVWA and DockerLabs, the agent's real-world success is unexplained — and the paper offers no quantitative comparison of simulated versus real action outcomes.

Editorial extensions

If this is right

  • If the correctness of the claim is granted, vulnerability scanning becomes a fully automated planning task: the agent chooses tool, target URL, and configuration at each step, and can be re-run periodically for maintenance scans or inside continuous-integration pipelines.
  • The permutation-geometric design implies model size does not grow with the number of URLs, so the same 69,304-parameter architecture should extend to substantially larger websites without retraining from scratch.
  • Training in simulation sidesteps the two obstacles that block RL in real pentesting — the risk of accidentally attacking a live network during training and the cost of slow real-tool interaction — so the train-in-simulation, test-in-the-real-world recipe is reusable for wider tool sets.
  • Because reward is scaled by vulnerability criticality (stacked SQL queries scored 100, discovered credentials 150, reflected XSS 70), the learned policy naturally prioritizes high-impact findings, matching the orientation of bug-bounty-style testing.
  • The hyperparameter search identifies PPO with a [64, 32] two-layer network and learning rate $3.29 \times 10^{-3}$ as the configuration that generalizes best to held-out simulated environments, giving a concrete recipe for reproducing the agent.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper never specifies the probability distributions that generate simulated status codes, tools, and vulnerabilities, nor does it compare simulated action outcomes against the real tools' outputs; a direct extension would be to calibrate the simulator from logged tool behavior, which would make the claimed simulation-to-reality transfer measurable instead of asserted.
  • The actor treats URLs as independent nodes, an assumption the paper flags as not always true; because the architecture is already a graph network with no edges, adding edges to represent cross-page dependencies (for example, chained attacks that use one page's findings on another) is the most natural next architectural step.
  • The same simulation-plus-symmetry recipe should transplant to other security domains with decomposable targets — API security testing, cloud misconfiguration auditing, or network-level pentesting — provided a faithful simulator is built for each; this is speculative, since the paper tests only web applications.
  • The completeness claim ('all vulnerabilities within its capabilities') is conditional on the fixed 134-action toolset; any extension of the action space would require re-verification, suggesting a useful future benchmark: a full vulnerability inventory of each test site mapped against exactly which actions can and cannot reach each entry.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper proposes a reinforcement learning (RL) approach for automated web-application penetration testing. The agent is trained in a procedurally generated simulated environment with an action space built from common security tools (crawler, parameter detection, SQL injection, brute force, XSS), and the policy is parameterized with permutation-invariant/equivariant networks inspired by geometric deep learning. The authors train PPO, SAC, and DQN, report that PPO performs best, and then state that the agent was tested on the real vulnerable applications DVWA and DockerLabs, where 'the agent successfully extracted all vulnerabilities within its capabilities.' The abstract claims that the developed RL algorithm 'maximizes the number of vulnerabilities found while minimizing the number of steps required.'

Significance. If the central claims were supported, the paper would be a useful contribution to automated pentesting: it combines a reasonably sized action space, a simulation-based training pipeline, and a symmetry-aware neural architecture that reduces parameter count. The permutation-equivariant actor and invariant critic (Section 3, Eqs. 6 and 8) are a sensible design choice and are clearly explained. However, the experimental evidence does not establish the claimed maximization/minimization behavior, and the real-world evaluation is not held out because insights from it were used to tune the reward and simulation. The paper's value is therefore prospective rather than demonstrated, and it currently lacks the quantitative rigor expected for the claimed results.

major comments (4)
  1. [Section 4] The real-world evaluation does not support the central claim stated in the abstract. Section 4 reports only the qualitative sentence 'The agent successfully extracted all vulnerabilities within its capabilities' and high-level action statistics in Figures 4 and 5. No vulnerability counts, per-episode step counts, success rates, standard deviations across seeds, or comparisons against a random-action or single-tool baseline are provided. Without such metrics, the claim of 'maximizes the number of vulnerabilities found while minimizing the number of steps required' is not demonstrated. The authors should report quantitative results on DVWA and DockerLabs, including the number of vulnerabilities found versus the number exploitable by the agent's toolset, the number of steps to completion, variance across runs, and a baseline comparison.
  2. [Section 4, last paragraph] The evaluation is not independent because the authors state: 'In some cases, these insights were used to fine-tune the reward function and improve the simulation.' Concretely, the real-world tests on DVWA and DockerLabs were used to alter the training environment and reward function, so the reported success is not an out-of-sample test of the learned policy. This confounds the generalization claim. The authors must either (a) hold out the real environments completely, reporting only results from a frozen policy that was never adjusted based on those environments, or (b) clearly separate development-time exploratory testing from a final held-out evaluation. As written, the real-world results cannot be attributed to the RL agent's learned behavior.
  3. [Section 2.4] The fidelity of the simulated environment is not quantified. The text says that simulated actions 'must mirror the real action's internal logic' and are 'validated to fit a general purpose use of the tools,' but no probability distributions for status codes, tools, versions, or vulnerabilities are specified, and no quantitative comparison between simulated action outcomes and real tool outputs is given. Since the agent is trained entirely in simulation and the paper's real-world transfer is a central claim, the absence of any sim-to-real validation leaves that transfer unexplained. The authors should report the full generative model of the simulator and, at minimum, compare state-transition and vulnerability-discovery statistics on DVWA/DockerLabs against the simulated distributions.
  4. [Sections 2.2 and 2.3] The reward trade-off parameter μ (Section 2.3) and the temporal decay factor λ (Section 2.2) are never assigned numerical values, even though they directly determine the objective function and the agent's behavior. The reward table (Table 2) and cost table (Table 3) are given, but μ and λ remain free parameters. Without their values, the experiments are not reproducible and the reported training curves cannot be interpreted. The authors should report the exact values used for μ and λ, as well as the ranges considered in the hyperparameter search.
minor comments (4)
  1. [Section 2.1] The SQL injection action set T3 is described as having 6 techniques, but the text lists only five: boolean-based blind, time-based blind, error-based, UNION query-based, and stacked queries. This discrepancy should be fixed.
  2. [Throughout] There are several typographical issues: 'DVW A' in Section 2 and 'Appendinx C' in Section 2.3, and the abstract and body refer to 'DockerLabs' inconsistently in formatting. A careful proofread is needed.
  3. [Figure 3] The training and validation reward curves appear to show a single run per algorithm, with no error bars or shaded confidence intervals. Adding multiple seeds would make the comparison between PPO, SAC, and DQN more convincing.
  4. [Section 3, Eq. (8)] The actor architecture assumes that the state of one URL does not influence action probabilities for another URL. The authors note this assumption but do not test it; a brief ablation or discussion of when this assumption breaks would strengthen the paper.

Circularity Check

2 steps flagged · score 6.0 of 10

Real-world success claim is fitted: test-set insights were used to retune reward and simulation, and the headline objective restates the reward definition.

  1. fitted input called prediction [Section 4, Experiments, DVWA/DockerLabs testing paragraph]
    "The testing was conducted on multiple machines, including DVWA and DockerLabs. The agent successfully extracted all vulnerabilities within its capabilities. ... In some cases, these insights were used to fine-tune the reward function and improve the simulation. ... the team leveraged them to refine the reward mechanisms and enhance the simulation’s effectiveness."

    The paper's only evidence for the central claim is the unquantified statement that the agent 'successfully extracted all vulnerabilities within its capabilities' on the real test environments. The same paragraph then admits that insights from that test inference were used to modify two core inputs of the method: the reward function and the simulation. Since the reward function defines what counts as success and the simulation defines the training distribution, using test-environment insights to adjust them means the reported real-world success is not an out-of-sample prediction. The evaluation is fitted to the test set by construction, so the claimed generalization is not independently demonstrated.

  2. self definitional [Section 2.3, Reward R, and Abstract]
    "The overarching goal is to maximize the discovery of critical vulnerabilities in the shortest possible time. Thus, we formulate the problem as a bi-objective optimization task: R(st, at, st+1) = µV(st, st+1) + (1−µ)C(at)"

    The abstract's headline result—'maximizes the number of vulnerabilities found while minimizing the number of steps required'—is exactly the objective encoded in the reward function R. No independent real-world metrics (vulnerability counts, step totals, success rates, or baselines) are reported in Section 4. The asserted result is therefore a restatement of the reward definition rather than an empirically evaluated finding. This becomes fully circular when combined with the test-set fine-tuning, because the reward itself was adjusted using the very test outcomes that are then presented as evidence of success.

full rationale

The paper's central claim—that the RL algorithm maximizes vulnerabilities found while minimizing steps—is not supported by any quantitative, held-out evaluation. Section 4 contains the only real-world evidence, an unquantified statement that the agent extracted all vulnerabilities within its capabilities, followed by an explicit admission that insights from those test runs were used to fine-tune the reward function and improve the simulation. This breaks the independence of the evaluation: the reward function is the definition of the objective, and the simulation is the training environment, so tuning either of them using test-environment inference means the reported success is partly forced by construction rather than demonstrated generalization. There is no external benchmark, no comparison to random actions or single-tool baselines, and no reported variance. The geometric-deep-learning architecture and PPO training are not circular in themselves, and the self-citations in the related work are not load-bearing. The circularity is concentrated in the evaluation loop: the test set is used to adjust the training inputs, and the resulting behavior is then reported as successful validation of the method. This warrants a partial-circularity score of 6 rather than a higher score, because the simulation design and the RL training pipeline still contain independent engineering content; the flaw is that the central empirical prediction is not held out from the fitting process.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The paper relies on several hand-chosen reward and system parameters (reward weights, costs, μ, λ, Poisson mean) and on assumptions about simulation-to-real transfer, symmetry factorization, and tool fidelity. Most of these are not quantitatively validated. No new physical or conceptual entities are introduced beyond the software modules and the modified Barabási-Albert tree generator.

free parameters (5)
  • Reward weights V (Table 2) = Various: e.g., 8 for status [200,300), 60-100 for SQLi types, 150 for password brute force, 1000 for goal reached
    Manually chosen and 'carefully fine-tuned' (Section 2.3, Table 2) to shape agent behavior; no external basis is given.
  • Action costs C (Table 3) = Various integers per configuration (e.g., crawler depths, SQLi levels, dictionary sizes)
    Hand-set fixed costs for each tool configuration, described as 'carefully fine-tuned' (Section 2.3, Table 3).
  • μ (reward trade-off) = Not stated
    Controls balance between discovery reward and action cost in R = μ V + (1 − μ) C (Section 2.3); value not reported.
  • λ (temporal decay) = Not stated
    Decay factor applied to previously observed state information, λ ∈ (0, 1), introduced in Section 2.2; value not reported.
  • Poisson mean for number of simulated nodes = 40
    Number of nodes in the simulated website topology is drawn from Poisson(40) (Algorithm 1); chosen by hand.
assumptions (5)
  • domain assumption The MDP state representation with exponential decay memory sufficiently captures the temporal dependencies for optimal policy learning.
    Section 2.2 acknowledges the environment is not strictly Markovian and uses a cumulative decay encoding; the paper assumes this suffices.
  • domain assumption The simulated environment's distributions of status codes, tools, and vulnerabilities are representative enough of real web applications for the policy to transfer.
    Section 2.4 states the simulation is used for training to prevent DoS and improve diversity; the paper assumes this generalizes to real sites.
  • domain assumption The critic is permutation invariant and the actor is permutation equivariant with respect to URL order, and the actor factorization across URLs does not harm performance.
    Section 3, Eq. (3)-(8); the authors explicitly say 'this assumption may not always hold, there is no indication that it negatively impacts model performance.'
  • domain assumption The simulated behavior of security tools (crawler, SQLi, brute force, XSS) matches the real tools' logic well enough for the learned policy to be usable.
    Section 2.4: 'The behavior of the simulated actions must mirror the real action's internal logic... validated to fit a general purpose use of the tools.'
  • domain assumption The restricted action space of 134 actions per URL covers the important vulnerability classes needed to assess the test websites.
    Section 2.1 limits actions to OWASP Top 10 based tools; the test results are only as good as this coverage.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Reinforcement Learning for Automated Cybersecurity Penetration Testing." pith.science (2026). https://pith.science/paper/3WJ5AX3U

@misc{pith2026250702969,
  author       = {Pith},
  title        = {Pith review of: Reinforcement Learning for Automated Cybersecurity Penetration Testing},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/3WJ5AX3U}},
  note         = {Machine review of arXiv:2507.02969}
}
read the original abstract

This paper aims to provide an innovative machine learning-based solution to automate security testing tasks for web applications, ensuring the correct functioning of all components while reducing project maintenance costs. Reinforcement Learning is proposed to select and prioritize tools and optimize the testing path. The presented approach utilizes a simulated webpage along with its network topology to train the agent. Additionally, the model leverages Geometric Deep Learning to create priors that reduce the search space and improve learning convergence. The validation and testing process was conducted on real-world vulnerable web pages commonly used by human hackers for learning. As a result of this study, a reinforcement learning algorithm was developed that maximizes the number of vulnerabilities found while minimizing the number of steps required

Figures

Figures reproduced from arXiv: 2507.02969 by the authors.

Figure 1
Figure 1. Action Space is composed of individual actions that can take place in each URL. [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. Six randomly generated environments used for training and agent validation. The colors indicate the status [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. Training and validation during 1e6 timesteps. [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: Results obtained during testing at the end of each episode (500 timesteps). [PITH_FULL_IMAGE:figures/full_fig_p010_4.png]
Figure 5
Figure 5. Figure 5: Sub-action selection probability during inference. Actions within the same tool are represented by the same [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]
Figure 6
Figure 6. Figure 6: Penbot Web interface. A Report Generation Generating a penetration testing (pentesting) report involves documenting the findings, methodologies, and recommen￾dations from a penetration test in a structured format. A well-crafted report typically includes: • Executive S…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

25 extracted references · 12 canonical work pages

  1. [1]

    Cyber-security and reinforcement learning — A brief survey

    Amrin Maria Khan Adawadkar and Nilima Kulkarni. Cyber-security and reinforcement learning — A brief survey. Engineering Applications of Artificial Intelligence, 114: 0 105116, September 2022. ISSN 0952-1976. doi:10.1016/j.engappai.2022.105116. URL https://www.sciencedirect.com/science/article/pii/S0952197622002512

    work page arXiv 2022

  2. [2]

    Automated penetration testing based on a threat model

    Norah Ahmed Almubairik and Gary Wills. Automated penetration testing based on a threat model. In 2016 11th International Conference for Internet Technology and Secured Transactions ( ICITST ) , pages 413--414, December 2016. doi:10.1109/ICITST.2016.7856742

    work page arXiv 2016

  3. [3]

    Emergence of Scaling in Random Networks

    Albert-László Barabási and Réka Albert. Emergence of Scaling in Random Networks . Science, 286 0 (5439): 0 509--512, October 1999. doi:10.1126/science.286.5439.509. URL https://www.science.org/doi/10.1126/science.286.5439.509. Publisher: American Association for the Advancement of Science

    doi:10.1126/science.286.5439.509 1999

  4. [4]

    Bronstein, Joan Bruna, Taco Cohen, and Petar Veličković

    Michael M. Bronstein, Joan Bruna, Taco Cohen, and Petar Veličković. Geometric Deep Learning : Grids , Groups , Graphs , Geodesics , and Gauges , May 2021. URL http://arxiv.org/abs/2104.13478. arXiv:2104.13478 [cs, stat]

    arXiv 2021

  5. [5]

    CYBERSHIELD : A Competitive Simulation Environment for Training AI in Cybersecurity

    José Álvaro Fernández Carrasco, Iñigo Amonarriz Pagola, Raúl Orduna Urrutia, and Rodrigo Román. CYBERSHIELD : A Competitive Simulation Environment for Training AI in Cybersecurity . In 2024 11th International Conference on Internet of Things : Systems , Management and Security ( IOTSMS ) , pages 11--18, September 2024. doi:10.1109/IOTSMS62296.2024.1071020...

    arXiv 2024

  6. [6]

    Adversarial Reinforcement Learning in a Cyber Security Simulation

    Richard Elderman, Leon Pater, Albert Thie, Madalina Drugan, and Marco Wiering. Adversarial Reinforcement Learning in a Cyber Security Simulation . February 2017. doi:10.5220/0006197105590566

    work page doi:10.5220/0006197105590566 2017

  7. [7]

    CybORG ++: An Enhanced Gym for the Development of Autonomous Cyber Agents , October 2024

    Harry Emerson, Liz Bates, Chris Hicks, and Vasilios Mavroudis. CybORG ++: An Enhanced Gym for the Development of Autonomous Cyber Agents , October 2024. URL http://arxiv.org/abs/2410.16324. arXiv:2410.16324 [cs]

    arXiv 2024

  8. [8]

    Using Cyber Terrain in Reinforcement Learning for Penetration Testing

    Rohit Gangupantulu, Tyler Cody, Paul Park, Abdul Rahman, Logan Eisenbeiser, Dan Radke, and Ryan Clark. Using Cyber Terrain in Reinforcement Learning for Penetration Testing . arXiv:2108.07124 [cs], August 2021. URL http://arxiv.org/abs/2108.07124. arXiv: 2108.07124

    work page Pith review arXiv 2021

Show all 25 references
  1. [9]

    Ghanem and Thomas M

    Mohamed C. Ghanem and Thomas M. Chen. Reinforcement Learning for Intelligent Penetration Testing . In 2018 Second World Conference on Smart Trends in Systems , Security and Sustainability ( WorldS4 ) , pages 185--192, October 2018. doi:10.1109/WorldS4.2018.8611595

    2018

  2. [10]

    Ghanem and Thomas M

    Mohamed C. Ghanem and Thomas M. Chen. Reinforcement Learning for Efficient Network Penetration Testing . Information, 11 0 (1): 0 6, January 2020. doi:10.3390/info11010006. URL https://www.mdpi.com/2078-2489/11/1/6. Number: 1 Publisher: Multidisciplinary Digital Publishing Institute

    2020 doi

  3. [11]

    Soft Actor - Critic Algorithms and Applications , January 2019

    Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Soft Actor - Critic Algorithms and Applications , January 2019. URL http://arxiv.org/abs/1812.05905. arXiv:1812.059...

    2019 arXiv

  4. [12]

    Automated Penetration Testing Using Deep Reinforcement Learning

    Zhenguo Hu, Razvan Beuran, and Yasuo Tan. Automated Penetration Testing Using Deep Reinforcement Learning . In 2020 IEEE European Symposium on Security and Privacy Workshops ( EuroS PW ) , pages 2--10, September 2020. doi:10.1109/EuroSPW51379.2020.00010

    2020

  5. [13]

    Prokopczyk, Yusra Al-Khazraji, Marek Matuszak, Mário Pinto, Edgar Marques, and Evridiki Ntagiou

    Daniel López-Montero, Alexander Benítez-Buenache, Nuno Carvalho-dos Santos, Javier Gallardo-Lozano, Maciej J. Prokopczyk, Yusra Al-Khazraji, Marek Matuszak, Mário Pinto, Edgar Marques, and Evridiki Ntagiou. Towards INtelligent automated Functional and Security Testing ( INFAST...

    2023

  6. [14]

    Playing Atari with Deep Reinforcement Learning , December 2013

    Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing Atari with Deep Reinforcement Learning , December 2013. URL http://arxiv.org/abs/1312.5602. arXiv:1312.5602 [cs]

    2013 arXiv

  7. [15]

    PenGym : Realistic training environment for reinforcement learning pentesting agents

    Huynh Phuong Thanh Nguyen, Kento Hasegawa, Kazuhide Fukushima, and Razvan Beuran. PenGym : Realistic training environment for reinforcement learning pentesting agents. Computers & Security, 148: 0 104140, January 2025. ISSN 0167-4048. doi:10.1016/j.cose.2024.104140. URL https:...

    2025

  8. [16]

    Multiobjective Tree - Structured Parzen Estimator

    Yoshihiko Ozaki, Yuki Tanigaki, Shuhei Watanabe, Masahiro Nomura, and Masaki Onishi. Multiobjective Tree - Structured Parzen Estimator . Journal of Artificial Intelligence Research, 73: 0 1209--1250, April 2022. ISSN 1076-9757. doi:10.1613/jair.1.13188. URL https://www.jair.or...

    2022 doi

  9. [17]

    An AI - Based Approach for Automating Penetration Testing

    Manaswi Patil, Devaki Thakare, Arzoo Bhure, Shweta Kaundanyapure, and Dr Mune. An AI - Based Approach for Automating Penetration Testing . International Journal for Research in Applied Science and Engineering Technology, 12: 0 5019--5028, April 2024. doi:10.22214/ijraset.2024.61113

    2024

  10. [18]

    Bahaa-Eldin, and Zt Fayed

    Verina Saber, Dina ElSayad, Ayman M. Bahaa-Eldin, and Zt Fayed. Automated Penetration Testing , A Systematic Review . In 2023 International Mobile , Intelligent , and Ubiquitous Computing Conference ( MIUCC ) , pages 373--380, September 2023. doi:10.1109/MIUCC58832.2023.102783...

    2023

  11. [19]

    Proximal Policy Optimization Algorithms , August 2017

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal Policy Optimization Algorithms , August 2017. URL http://arxiv.org/abs/1707.06347. arXiv:1707.06347 [cs]

    2017 arXiv

  12. [20]

    Autonomous Penetration Testing using Reinforcement Learning

    Jonathon Schwartz and Hanna Kurniawati. Autonomous Penetration Testing using Reinforcement Learning . arXiv:1905.05965 [cs], May 2019. URL http://arxiv.org/abs/1905.05965. arXiv: 1905.05965

    1905 arXiv

  13. [21]

    POMDP + Information - Decay : Incorporating Defender 's Behaviour in Autonomous Penetration Testing

    Jonathon Schwartz, Hanna Kurniawati, and Edwin El-Mahassni. POMDP + Information - Decay : Incorporating Defender 's Behaviour in Autonomous Penetration Testing . Proceedings of the International Conference on Automated Planning and Scheduling, 30: 0 235--243, June 2020. ISSN 2...

    2020

  14. [22]

    Hameed, and Min Xu

    Kamran Shaukat, Suhuai Luo, Vijay Varadharajan, Ibrahim A. Hameed, and Min Xu. A Survey on Machine Learning Techniques for Cyber Security in the Last Decade . IEEE Access, 8: 0 222310--222354, 2020. ISSN 2169-3536. doi:10.1109/ACCESS.2020.3041951. Conference Name: IEEE Access

    2020

  15. [23]

    Mastering Chess and Shogi by Self - Play with a General Reinforcement Learning Algorithm , December 2017

    David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, Timothy Lillicrap, Karen Simonyan, and Demis Hassabis. Mastering Chess and Shogi by Self - Play with a General Reinfor...

    2017 arXiv

  16. [24]

    Reinforcement Learning for Automatic Test Case Prioritization and Selection in Continuous Integration

    Helge Spieker, Arnaud Gotlieb, Dusica Marijan, and Morten Mossige. Reinforcement Learning for Automatic Test Case Prioritization and Selection in Continuous Integration . Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis, pages 12--22...

    2017

  17. [25]

    Sutton and Andrew G

    Richard S. Sutton and Andrew G. Barto. Reinforcement Learning , second edition: An Introduction . MIT Press, November 2018. ISBN 978-0-262-03924-6. Google-Books-ID: sWV0DwAAQBAJ

    2018

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.