Pentest-Swarm-AI

module
v0.2.2 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 13, 2026 License: AGPL-3.0

README ΒΆ

The first open-source pentesting tool built on a real swarm β€” not just multiple agents in a row.

Quick Start Β· Swarm vs. Multi-Agent Β· How It Works Β· Compare Β· Roadmap

Discord Stars Go License AI Status

Attackers automate. Most pentests don't.

Security teams are stuck between scanners that flag thousands of unverified "maybes" and consultants who actually exploit β€” but cost five figures and show up once a year. Neither keeps pace with an attack surface that changes every day.

Pentest Swarm AI is the only open-source pentester built on a real swarm. Not a single planner LLM calling recon β†’ classify β†’ exploit β†’ report down a fixed line β€” dozens of agents work your surface concurrently, coordinating through a shared stigmergic blackboard. The moment a finding lands it wakes whichever agent it's relevant to, so a 1,000-subdomain target gets worked in parallel, at machine speed. And unlike a scanner, the swarm exploits what it finds and proves it with captured evidence β€” then writes the report.

Run it on any model β€” Claude, anything OpenAI-compatible, the new security-tuned open models (Pentest-R1 and the wave behind it), or fully local Ollama / LM Studio. We don't compete with those models β€” we're the harness that gives them hands: real tools, swarm coordination, scope safety, and evidence-backed reports. Air-gapped, zero API cost, and not one byte of your data leaving your box.

For authorized testing only β€” see the disclaimer below.


Credits & Inspiration

This project stands on the shoulders of giants. We credit and thank these projects for pioneering AI-powered offensive security:

  • PentestGPT β€” the OG that proved LLMs can pentest
  • PentAGI β€” fully autonomous agent architecture
  • Strix β€” AI hackers that find and fix vulns
  • CAI β€” cybersecurity AI framework, 3600x faster than humans
  • HackingBuddyGPT β€” LLM hacking in 50 lines of code
  • Shannon β€” white-box AI pentester
  • BlacksmithAI β€” multi-agent pentest framework
  • PentestAgent β€” black-box AI security testing

Their open-source contributions made tools like this possible.

Legal Disclaimer: Pentest Swarm AI is designed exclusively for authorized security testing, bug bounty programs, CTF competitions, and educational research. You must obtain explicit written permission from the target system owner before running any scan. Unauthorized access to computer systems is illegal under the Computer Fraud and Abuse Act (CFAA), the Computer Misuse Act, and equivalent laws worldwide. The authors and contributors of this project accept no liability for misuse, damage, or any illegal activity conducted with this tool. By using this software, you agree that you are solely responsible for ensuring your use complies with all applicable laws and regulations. Do not use this tool against systems you do not own or have explicit authorization to test.


What makes this a swarm?

Most "multi-agent" pentesting tools are a single planner LLM dispatching to specialist agents in a fixed order β€” recon β†’ classify β†’ exploit β†’ report. That's a pipeline, not a swarm.

Pentest Swarm AI is built around three swarm-intelligence primitives:

  • Stigmergy β€” agents coordinate by reading and writing findings on a shared blackboard, not by a central planner telling them what to do. A finding's pheromone weight biases other agents toward it and decays over time, so stale paths die naturally.
  • Emergence β€” attack chains appear that no single agent planned. A recon finding wakes the classifier; a high-severity classification wakes the exploit agent; exploit results feed back into the board and wake the report agent. Order isn't prescribed β€” it emerges from the blackboard state.
  • Decentralization β€” each agent runs its own trigger predicate. Add a new agent with its own predicate and it joins the swarm without anyone rewriting the orchestrator.

We built this because the category was empty. Every tool marketed as "swarm" was actually a pipeline. If you find a counter-example, open an issue β€” we'll add them to the comparison table.

See the architecture diagrams in docs/ for stigmergy, pheromone decay, and the Postgres-backed blackboard. A deeper technical write-up is coming β€” ask in Discord.


Quick Start

Start free β€” no API key, no cloud, no bill.

# install (pick one)
curl -fsSL https://raw.githubusercontent.com/Armur-Ai/Pentest-Swarm-AI/main/scripts/install.sh | sh   # any macOS/Linux
npm install -g @armurai/pentestswarm                                       # npm (Node β‰₯16)
brew install Armur-Ai/tap/pentestswarm                                     # Homebrew
go install github.com/Armur-Ai/Pentest-Swarm-AI/cmd/pentestswarm@latest    # Go toolchain
docker run --rm ghcr.io/armur-ai/pentestswarm:latest --help                # Docker

Watch it find a real vuln in 2 minutes β€” no target, no key, all local. --lab spins up a bundled, intentionally-vulnerable app (OWASP Juice Shop) on your machine, points the swarm at it, and tears it down after. Legal, safe, zero setup:

pentestswarm scan --lab --provider ollama --swarm --follow

Ready for a real target? Same command, your model:

# local model β€” 100% on your box, zero API key
pentestswarm scan <authorized-target> --scope <target> --provider ollama --swarm --follow

# or a cloud model for max quality
export PENTESTSWARM_ORCHESTRATOR_API_KEY=sk-ant-your-key-here
pentestswarm scan <target> --scope <target> --swarm --follow

One command. Your model, your infra, your rules. New here? pentestswarm demo plays the whole campaign offline β€” that's the GIF above.

Running inside a GitHub Actions workflow? There's an action for that β€” see deploy/github-action/example-workflow.yml.


How the swarm works

Key behaviours:

  1. Agents are independent. Any one of them can be removed, replaced, or added without rewiring the others.
  2. Pheromones decay per-finding-type. A PORT_OPEN stays hot for hours; a SESSION for minutes. Config-driven half-lives.
  3. Scope is enforced at the tool layer and again at the executor. Defence in depth β€” --scope is not bypassable.
  4. Cleanup is always registered before execution. SIGINT, crashes, and budget exhaustion all trigger reverse-order cleanup. See internal/pipeline/cleanup_memory.go and cleanup.go.
  5. Prompt caching on Claude cuts cost and latency on repeated system prompts (enabled by default for recon + classifier).


Comparison

How we position vs. the rest of the ecosystem. We'll ship real benchmark numbers in a future release (see the benchmarks roadmap).

Tool Architecture Executes vs. suggests Memory Tools wired MCP Swarm?
Pentest Swarm AI Stigmergic blackboard Executes pgvector + pheromones 8 ProjectDiscovery + nmap; sqlmap / Burp MCP / Metasploit in roadmap Yes βœ… real
PentestGPT Single-agent ReAct Suggests None None native No No
HackingBuddyGPT Single-agent Executes Run logs Shell passthrough No No
PentAGI 4 agents + planner Executes pgvector 40+ via MCP/shell Partial Pipeline
Shannon White-box + browser Executes Session state Browser DOM No Pipeline
HexStrike MCP tool wrapper Delegates to client LLM None (stateless) 150+ via MCP Yes No
Pentest-R1 RL-tuned LLM Executes Trajectory CTF-scope No No

If any entry here is wrong or out of date, please open a PR β€” we want this table to stay honest.


Feature status

Honesty labels: stable means shipped + tested, beta means works but rough edges, alpha means experimental, planned means in the roadmap.

Feature Status Notes
Sequential 5-phase runner stable Default mode; battle-tested core
Stigmergic swarm scheduler alpha --swarm flag; memory-backed blackboard wired
ProjectDiscovery toolchain stable subfinder, httpx, nuclei, naabu, katana, dnsx, gau
nmap adapter stable XML parsed; scope-validated
Cleanup registry stable Always runs on SIGINT / exit / budget-cancel
Claude prompt caching stable Enabled for recon + classifier by default
--strict LLM mode stable Promotes LLM errors to fatal
CVSS v3.1 scoring stable FIRST spec
Postgres blackboard backend beta Migration shipped; runner uses memory-board for now
MCP server beta pentestswarm mcp serve
VS Code extension beta deploy/vscode/
GitHub Action beta deploy/github-action/action.yml with SARIF
Swarm playbooks (5) beta playbooks/{bug-bounty,external-asm,ci-cd,internal-network,ctf-solver}.yaml
Live dashboard alpha web/; UI built, wiring to live campaigns in progress
Burp MCP bridge planned Wave 2
Metasploit / ZAP / sqlmap adapters planned Wave 2
Fine-tuned Pentest-Swarm model planned Wave 3 (Pentest-R1 recipe)
Cybench / AutoPenBench benchmarks planned Wave 3

CLI

pentestswarm scan <target> --scope <scope>              # Launch the swarm
pentestswarm scan <target> --scope <scope> --swarm      # Use the stigmergic scheduler
pentestswarm scan <target> --scope <scope> --strict     # Fail on LLM errors
pentestswarm campaign watch <id>                        # Live TUI β€” watch agents work
pentestswarm campaign explore <id>                      # Browse attack surface interactively
pentestswarm playbook run <name> --target <t>           # Run a community playbook
pentestswarm doctor                                     # 8-point system health check
pentestswarm mcp serve                                  # MCP server for Claude/Cursor
pentestswarm serve                                      # Start API server + dashboard

LLM Providers

All agents inherit from a single provider config. Set one key, the entire swarm works.

Bring your own model β€” we're the harness, not the model. A new wave of open models is topping the cyber-offense benchmarks β€” GLM (5.3), Qwen (3.x), DeepSeek, and security-tuned fine-tunes like Pentest-R1. Pentest Swarm turns any of them β€” or a frontier model, or a fully-local one β€” into an operating pentester: real tools, swarm coordination, scope enforcement, and evidence-backed reports. The model does the reasoning; the swarm does the work.

Any OpenAI-API-compatible endpoint works with a single base-URL change β€” that covers Together AI (GLM / Qwen / DeepSeek / Kimi), OpenAI, DeepSeek, Groq, and more β€” plus first-party Gemini. The only hard requirement is native tool/function calling, which GLM, Qwen, and DeepSeek all support.

Provider provider: Setup Privacy Best for
Claude (default) claude export PENTESTSWARM_ORCHESTRATOR_API_KEY=... Cloud Best quality, zero setup, prompt caching
Together AI openai Set key + endpoint https://api.together.xyz/v1 Cloud Open cyber-benchmark leaders: GLM zai-org/GLM-5.3, Qwen Qwen/..., DeepSeek, Kimi
OpenAI-compatible openai Set key + the vendor's /v1 endpoint Cloud OpenAI, DeepSeek, Groq, or any Chat-Completions API
Gemini gemini export PENTESTSWARM_ORCHESTRATOR_API_KEY=AIza... Cloud Large context, free tier
Ollama ollama Install Ollama + pull models 100% local Full privacy, air-gapped (GLM / Qwen builds available)
LM Studio lmstudio Load model, enable server 100% local GUI model management
OrcaRouter orcarouter export PENTESTSWARM_ORCHESTRATOR_API_KEY=sk-orca-... Cloud One endpoint for Claude/GPT + other frontier models, gateway-level security

Together AI example β€” run the whole swarm on GLM 5.3:

orchestrator:
  provider: "openai"
  endpoint: "https://api.together.xyz/v1"
  model: "zai-org/GLM-5.3"        # or Qwen/..., deepseek-ai/..., etc. β€” see together.ai/models
  api_key: ""                      # or export PENTESTSWARM_ORCHESTRATOR_API_KEY
  context_window: 128000

Tech Stack

Component Technology Why
Platform Go 1.24 Single binary, goroutine concurrency, native security tools
CLI Cobra + bubbletea Beautiful TUI with multi-panel agent view
LLM Claude / Together AI (GLM Β· Qwen Β· DeepSeek) / Gemini / OrcaRouter / Ollama / LM Studio Best quality cloud + open cyber-bench leaders + full privacy local
Security Tools subfinder Β· httpx Β· nuclei Β· naabu Β· katana Β· dnsx Β· gau Β· nmap ProjectDiscovery Go libs + nmap subprocess
Blackboard Postgres 16 + pgvector Transactional writes, vector similarity, pheromone decay in SQL
Cache Redis 7 Rate limiting, session state
Dashboard Next.js 15 + shadcn/ui + tremor Dark-first, chart-heavy
MCP JSON-RPC stdio Claude Desktop + Cursor integration

Development

git clone https://github.com/Armur-Ai/Pentest-Swarm-AI.git
cd Pentest-Swarm-AI
./scripts/setup.sh    # Install tools, start Postgres/Redis/Ollama
make build            # Compile binary
make test             # Run tests
make dev              # Hot-reload development

Regenerate the demo GIF after any CLI change:

brew install vhs      # one-off
vhs docs/demo-flashy.tape

Roadmap

  • Wave 1 (in flight): real swarm architecture (done), dashboard wire-up, Burp MCP
  • Wave 2: sqlmap / Metasploit / ZAP adapters, bug-bounty + ASM + CI/CD playbook polish, official GitHub Action in Marketplace
  • Wave 3: fine-tuned Pentest-Swarm model (Pentest-R1 recipe), Cybench / AutoPenBench / CVE-Bench numbers, agent-memory poisoning hardening (MINJA / MemoryGraft defences)

🧠 The Adaptive Swarm β€” headline releases

Today the swarm reacts to findings and runs verified attack playbooks (BOLA/IDOR, mass assignment, NoSQL injection, excessive data exposure) end-to-end. Next, we make it think β€” three major capabilities, each shipping as its own release:

  • β‘  Runtime reaction to discoveries (planned) β€” stigmergic emergence: the swarm mines every response for object references (ids, UUIDs, emails), writes them to the blackboard, and other agents react by probing those objects across endpoints. Find one leaked id and the swarm turns it into cross-user BOLA/IDOR attacks nobody scripted.
  • β‘‘ Self-correcting attacks (planned) β€” closed-loop replanning: a failed step (401/403/415, an odd response body) feeds back into the planner, which adjusts the request and retries. Attacks heal themselves instead of dead-ending.
  • β‘’ On-demand specialist sub-agents (planned) β€” the swarm spawns purpose-built agents at runtime (an auth agent to hold a session, a fuzzing agent for a discovered parameter, a chain-builder for a specific API) and tears them down when done.

Together these turn a reactive swarm into an adaptive one β€” attack surface it has never seen, handled without anyone writing a plan. Generalization beyond curated targets and full LLM-driven chaining ride on top of these.

Follow the GitHub Project board for live status.


Why "Swarm"?

Single agents are tools. Pipelines dressed up as agents are slightly fancier tools. A swarm is different: agents share an environment, each agent's writes influence other agents' behaviour, and the useful work is emergent rather than prescribed. That's what lets a swarm handle a 1,000-subdomain target without anyone writing a plan for it.

One agent is a tool. A swarm is a platform.


Community

Join the swarm on Discord β†’ 🐝

We're building the first real open-source pentest swarm in the open β€” come build it with us. In Discord you can share findings, request a tool adapter, argue about stigmergy and pheromone decay, get help running your first scan, or grab a good first issue and ship a PR. Researchers, red-teamers, and the AI-security-curious all welcome.

⭐ If a real open-source swarm is something you want to exist, drop a star. Star velocity is the fuel that keeps this shipping β€” it's the single biggest thing you can do in ten seconds.


Who's using Pentest Swarm?

Running Pentest Swarm β€” internally, on client engagements, in CI, or embedded in your own workflow? Add your org to ADOPTERS.md with a quick PR β€” it helps others trust the project and helps us prioritize what to build. Not ready to be listed publicly? A hello in Discord still helps.


Enterprise & Commercial Support

Pentest Swarm AI is free and open source (AGPL-3.0), and always will be. If your team wants a hand getting it into production, Armur AI β€” the team behind the project β€” offers commercial services:

  • Managed deployment on your infrastructure β€” cloud, on-prem, or fully air-gapped (no data leaves your environment)
  • Integration & customization β€” wire it into your SIEM, ticketing, and CI, or build custom tools and playbooks for your stack
  • Priority support & SLAs β€” a direct line to the maintainers
  • Training & onboarding β€” get your security team productive fast

Especially useful for startups and enterprises that want the control of self-hosting without doing the plumbing themselves.

πŸ“§ akhil@armur.ai β€” tell us your setup and what you're trying to do.


License

GNU Affero General Public License v3.0 (AGPL-3.0) β€” see LICENSE.

What this means for you

Use case Allowed?
Run Pentest Swarm on your own infrastructure (CI, laptop, internal red team) βœ… yes, no obligations
Use it on authorized bug-bounty programs / pentests βœ… yes, no obligations
Fork it for your own private experiments βœ… yes, no obligations
Distribute a modified binary βœ… yes β€” must share your modifications under AGPL
Run a modified version as a paid SaaS or network service βœ… yes β€” must share your modifications under AGPL

The AGPL exists specifically to prevent the SaaS-fork loophole: anyone who improves Pentest Swarm and offers it commercially must share their improvements with the community. We made it open source; we want it to stay open source even as it scales.

If you have a use case the table doesn't cover, open an issue and ask.

Built by Armur AI.

Directories ΒΆ

Path Synopsis
cli
ui
cmd
pentestswarm command
deploy
metrics command
internal
agent/prompts
Package prompts provides offensive-security prompt scaffolding for the swarm β€” curated system-prompt templates, a few-shot example library, and a refusal-detector + retry/fallback wrapper around llm.Provider.
Package prompts provides offensive-security prompt scaffolding for the swarm β€” curated system-prompt templates, a few-shot example library, and a refusal-detector + retry/fallback wrapper around llm.Provider.
agent/report/bounty
Package bounty estimates a dollar range for a finding based on its severity and (optionally) the target program's published bounty stats.
Package bounty estimates a dollar range for a finding based on its severity and (optionally) the target program's published bounty stats.
agent/report/dedup
Package dedup detects likely duplicate submissions by comparing a new finding's title (+ optional target) against a corpus of prior reports.
Package dedup detects likely duplicate submissions by comparing a new finding's title (+ optional target) against a corpus of prior reports.
agent/report/evidence
Package evidence captures report-ready artifacts from a finding's Reproduction block:
Package evidence captures report-ready artifacts from a finding's Reproduction block:
agent/report/qualitygate
Package qualitygate runs a generated submission draft through a second LLM call that grades it on clarity, impact framing, and reproducibility.
Package qualitygate runs a generated submission draft through a second LLM call that grades it on clarity, impact framing, and reproducibility.
agent/report/roi
Package roi computes the return-on-investment footer that lands at the bottom of every campaign report: expected bounty value vs.
Package roi computes the return-on-investment footer that lands at the bottom of every campaign report: expected bounty value vs.
api
asm
compliance
Package compliance maps a finding's already-resolved standard labels (its OWASP Top 10 2021 category, with CWE as a refinement) onto the specific governance-framework controls it touches: PCI DSS v4.0, SOC 2 (AICPA Trust Services Criteria), ISO/IEC 27001:2022 Annex A, and NIST CSF 2.0.
Package compliance maps a finding's already-resolved standard labels (its OWASP Top 10 2021 category, with CWE as a refinement) onto the specific governance-framework controls it touches: PCI DSS v4.0, SOC 2 (AICPA Trust Services Criteria), ISO/IEC 27001:2022 Annex A, and NIST CSF 2.0.
ctf
dashboard
Package dashboard serves a live, self-contained web view of a running swarm campaign.
Package dashboard serves a live, self-contained web view of a running swarm campaign.
db
integrations/burp
Package burp is a thin MCP client that talks to PortSwigger's Burp Suite MCP server.
Package burp is a thin MCP client that talks to PortSwigger's Burp Suite MCP server.
integrations/jira
Package jira sends pentest findings to Atlassian Jira as issues.
Package jira sends pentest findings to Atlassian Jira as issues.
integrations/metasploit
Package metasploit is a thin HTTP/JSON client for msfrpcd, the daemon that ships with Metasploit.
Package metasploit is a thin HTTP/JSON client for msfrpcd, the daemon that ships with Metasploit.
integrations/slack
Package slack posts findings + campaign events to Slack.
Package slack posts findings + campaign events to Slack.
integrations/webhook
Package webhook dispatches campaign events to a customer-configured endpoint with HMAC-SHA256 request signing and exponential-backoff retry.
Package webhook dispatches campaign events to a customer-configured endpoint with HMAC-SHA256 request signing and exponential-backoff retry.
integrations/zap
Package zap is a minimal REST client for OWASP ZAP.
Package zap is a minimal REST client for OWASP ZAP.
keychain
Package keychain stores secrets in the operating system's native secret store (macOS Keychain, linux-secret-service, Windows Credential Manager).
Package keychain stores secrets in the operating system's native secret store (macOS Keychain, linux-secret-service, Windows Credential Manager).
llm
mcp
osint
Package osint holds passive intelligence clients β€” Shodan, Censys, GitHub code search, etc.
Package osint holds passive intelligence clients β€” Shodan, Censys, GitHub code search, etc.
pipeline/fpcache
Package fpcache persists a researcher's "this was a false positive" marks so future scans can suppress the same pattern automatically.
Package fpcache persists a researcher's "this was a false positive" marks so future scans can suppress the same pattern automatically.
pipeline/nvdcheck
Package nvdcheck cross-references the classifier's CVSS score against NVD's canonical score for the same CVE.
Package nvdcheck cross-references the classifier's CVSS score against NVD's canonical score for the same CVE.
scope/importer
Package importer adapts bug-bounty platform APIs into our scope.yaml shape.
Package importer adapts bug-bounty platform APIs into our scope.yaml shape.
scope/importer/bugcrowd
Package bugcrowd imports scope from Bugcrowd programs via the v4 API.
Package bugcrowd imports scope from Bugcrowd programs via the v4 API.
scope/importer/hackerone
Package hackerone imports scope from HackerOne programs.
Package hackerone imports scope from HackerOne programs.
scope/importer/intigriti
Package intigriti imports scope from Intigriti programs via the external researcher API (https://api.intigriti.com/external/researcher/v1).
Package intigriti imports scope from Intigriti programs via the external researcher API (https://api.intigriti.com/external/researcher/v1).
scope/programterms
Package programterms parses a bug-bounty program's rules-of-engagement text and extracts machine-readable constraints (rate limits, banned paths, required headers, prohibited techniques).
Package programterms parses a bug-bounty program's rules-of-engagement text and extracts machine-readable constraints (rate limits, banned paths, required headers, prohibited techniques).
shellsafe
Package shellsafe provides a quote-aware command parser that rejects shell metacharacters outside of quoted regions.
Package shellsafe provides a quote-aware command parser that rejects shell metacharacters outside of quoted regions.
swarm
Package swarm contains the scheduler and agent contract that together replace the sequential 5-phase runner with a stigmergic swarm.
Package swarm contains the scheduler and agent contract that together replace the sequential 5-phase runner with a stigmergic swarm.
swarm/agents
Package agents contains the swarm adapters that bridge the existing specialist agents (recon, classifier, exploit, report) into the blackboard + scheduler model.
Package agents contains the swarm adapters that bridge the existing specialist agents (recon, classifier, exploit, report) into the blackboard + scheduler model.
swarm/blackboard
Package blackboard implements the stigmergic shared state for the swarm.
Package blackboard implements the stigmergic shared state for the swarm.
swarm/memorygraft
Package memorygraft scans the blackboard for patterns characteristic of memory-graft attacks (MemoryGraft, arXiv:2512.16962).
Package memorygraft scans the blackboard for patterns characteristic of memory-graft attacks (MemoryGraft, arXiv:2512.16962).
swarm/provenance
Package provenance signs blackboard findings with an Ed25519 keypair per agent so that any read can detect tampering.
Package provenance signs blackboard findings with an Ed25519 keypair per agent so that any read can detect tampering.
swarm/ratelimit
Package ratelimit caps the rate at which an agent processes findings off the blackboard.
Package ratelimit caps the rate at which an agent processes findings off the blackboard.
swarm/tuning
Package tuning loads per-finding-type pheromone settings (base weight + half-life) from YAML and applies a global exploration-bias multiplier.
Package tuning loads per-finding-type pheromone settings (base weight + half-life) from YAML and applies a global exploration-bias multiplier.
taxonomy
Package taxonomy maps a finding's (free-form) attack category and title onto the industry-standard labels security teams triage by: an OWASP Top 10 (2021) category and a CWE id.
Package taxonomy maps a finding's (free-form) attack category and title onto the industry-standard labels security teams triage by: an OWASP Top 10 (2021) category and a CWE id.
toolpath
Package toolpath makes pentestswarm self-sufficient at finding the external security binaries it shells out to (httpx, nuclei, ffuf, ...) without requiring the user to add GOPATH/bin (or anything else) to their shell PATH.
Package toolpath makes pentestswarm self-sufficient at finding the external security binaries it shells out to (httpx, nuclei, ffuf, ...) without requiring the user to add GOPATH/bin (or anything else) to their shell PATH.
toolprobe
Package toolprobe reports which external security tools are installed on the current host.
Package toolprobe reports which external security tools are installed on the current host.
tests
bench/cybench
Package cybench is the harness for running Pentest Swarm AI against the Cybench benchmark (arXiv:2408.08926) β€” 40 CTF-style challenges covering web, crypto, pwn, forensics.
Package cybench is the harness for running Pentest Swarm AI against the Cybench benchmark (arXiv:2408.08926) β€” 40 CTF-style challenges covering web, crypto, pwn, forensics.
bench/speed
Package speed is the harness for Pentest Swarm AI's most on-brand, easiest-to-produce benchmark: swarm mode vs.
Package speed is the harness for Pentest Swarm AI's most on-brand, easiest-to-produce benchmark: swarm mode vs.
llm_eval
Package llm_eval holds the evaluation harness for classifier / recon / exploit agent prompts.
Package llm_eval holds the evaluation harness for classifier / recon / exploit agent prompts.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL