keel
Keel is an MCP control plane for coordinating authorized web security scans and proofs, turning scanner output into deduplicated, evidence-driven vulnerability cards.
Engagement scoping:
begin_engagementregisters authorized hosts, exclusions, rate limits, and proof flags.Draft and execute waves:
draft_wavesproposes reachability and template scans;execute_waveruns them behind per-host token buckets.Monitor and cancel scans:
wave_status,cancel_wave(thoughcancel_wavenot in schema,engagement_healthreports status).Query and triage findings:
query_cardsreturns prioritized, semantically deduplicated vulnerability cards;second_lookre-scans a single card URL.Record hunter hypotheses:
state_impactlogs impact class, preconditions, and reasoning.Draft and execute safe proofs:
draft_proofplans GET-only, allowlisted playbooks;execute_proofruns them to prove or refute vulnerabilities (IDOR, XSS, open redirect, authZ) with canary checks.Track engagement health:
engagement_healthshows cooldowns, budgets, and pending waves.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@keel Begin engagement for example.com, scope in *.example.com, max 5 rps, allow safe proofs."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Keel
The MCP control plane that turns scanner noise into hunter-grade, non-destructive proofs
Thirteen MCP tools. Semantic dedup. Per-host rate limits. Safe proofs that show what a hunter can do — without damaging the target.
Why Keel · Install · Clients · Proofs · Tools
Dumping 150 tools on an agent is easy. The hard problems are dedup across tools, exploitable vs noise, and not hammering the target. Keel is the control plane for those three.
An AI client talks to Keel, not to httpx, nuclei, or a shell. Keel drafts one wave at a time, enforces scope and rate limits, merges scanner hits into semantic cards, and runs GET-only playbooks on tester-owned data. When a playbook returns proven, you get a curl replay a hunter can follow — still without writes, shells, or payload spam.
Use it on programs you are authorized to test.
Why Keel
Hard problem | What scanner dumps do | What Keel does |
Dedup across tools | One Nuclei template id per row; the same IDOR appears five times | Semantic key from vulnerability class + normalized route + method + parameter. UUID/id/hex tokens collapse. Compatible observations merge. |
Exploitable vs noise | High severity = "ship it" | Cards move through |
Not hammering the target | Fire every template at once, retry on 429 | One active wave per host, token buckets, Nuclei concurrency 1, no OAST, no redirects, no unsigned templates, no dos/fuzz/bruteforce/intrusive tags. HTTP 429 becomes a cooldown. |
A wrapper that shells out to a huge toolbox does not have that layer. Keel does — in the scheduler, in the adapters, and in the proof broker.
Related MCP server: apex
Architecture
flowchart TD
A[AI coding client] -->|stdio MCP| B[Keel]
B --> C[Scope and rate gate]
C --> W[Background job and wave scheduler]
W --> H[httpx: one target]
W --> N[nuclei: HTTP templates, bounded]
C --> P[Proof broker: GET only]
P --> T[Tester-owned resource]
H --> S[Semantic card store]
N --> S
P --> S
S --> Q[Triage and evidence states]begin_engagementwith the hostname you are authorized to test.draft_wavesproposes reachability plus template micro-waves. No traffic yet.execute_wavereturns a job immediately. Pollwave_status.cancel_wavekills the scanner.query_cardsreturns hunter-relevant cards.assess_exploitabilitysays what would prove it.draft_proofthenexecute_proofrun a GET-only playbook against tester data.provenmeans the invariant held.protectedmeans the control worked.
Installation
macOS (Homebrew). pipx is a separate tool — install it first. Apple's /usr/bin/python3 is often 3.9 and cannot install Keel.
brew install pipx python@3.12
pipx ensurepath
# open a new terminal, then:
pipx install keel-pentest
keel-pentest setup
keel-pentest doctorIf python3.12 is already on the machine and you do not want Homebrew pipx:
python3.12 -m pip install --user pipx
python3.12 -m pipx ensurepath
python3.12 -m pipx install keel-pentestsetup downloads ProjectDiscovery httpx and nuclei into ~/.keel/bin. Keel finds them there even when a GUI client has a thin PATH. No extra KEEL_HTTPX_BIN for a first scan.
Then point your MCP client at the keel-pentest executable:
claude mcp add --scope user --transport stdio keel -- keel-pentest
codex mcp add keel -- keel-pentest
hermes mcp add keel --command keel-pentestOpenCode: "command": ["keel-pentest"].
Python 3.10+. Do not pip install keel — that is a different project. OS notes and pip/venv: INSTALL.md. Client shapes: clients/README.md.
Optional later: KEEL_APPROVAL_FILE for a team manifest that pins scope, template IDs, and proof targets. Default mode is self-attested — begin_engagement is the authorization. Rate limits, one-wave-per-host, signed templates, and sanitized evidence still apply.
Safe proofs that still prove impact
Scanner output is a hypothesis. Keel proves (or refutes) it with disposable tester accounts and a unique canary. Every playbook is GET-only, budgeted, and returns a curl replay. The replay is the report artifact: if this is not fixed, a hunter with a normal account can do this.
Playbook | Proves | How, without damage |
| IDOR / BOLA | Tester A reads its canary; tester B GETs the same A-owned URL. Identical canary + 2xx = |
| Reflected XSS / HTML injection | Inject a unique marker plus a harmless |
| Open redirect | Point the redirect parameter at |
| Missing authZ | Tester A baseline must show the canary; the same URL with no credentials must not. 2xx + canary unauthenticated = |
| Reachability only | A reads its own canary. This is |
execute_proof stores status codes, canary booleans, truncation flags, hashes, hunter impact text, and the repro script. It does not persist response bodies or secrets.
Plant a non-secret canary in a tester-owned object before cross_account_read / unauth_access_probe. Reflected XSS and open redirect inject the marker themselves.
MCP tools
Tool | Role |
| Register scope and traffic ceilings |
| Propose reachability + template micro-waves; no traffic |
| Queue one background job |
| Stage, progress, result; omit |
| Stop a queued or running scanner |
| Prioritized semantic cards |
| Re-run only the originating Nuclei template |
| Candidate impact, missing evidence, negative control, playbooks |
| Record a hunter hypothesis |
| Allowlisted proof plan; no traffic |
| Run the GET-only playbook |
| Cooldowns, budgets, pending waves |
| Append-only application events |
begin_engagement needs engagement_id and scope_hosts (plain hostnames, e.g. target.example). Defaults: 3 req/s, one host at a time, 120s / 120 requests per wave. allow_safe_proof=true enables proofs. Pass tester credential names only; put secrets in KEEL_CREDENTIALS_FILE.
Example prompt
Use only Keel MCP tools. Do not shell out to httpx, nuclei, curl, or exploit tools.
1. begin_engagement for bb-2026-01 with scope_hosts ["target.example"], 3 req/s.
Set allow_safe_proof true if I will run proofs.
2. draft_waves for https://target.example.
3. execute_wave for each wave. Poll wave_status until completed, retryable_failed,
terminal_failed, or cancelled.
4. query_cards (include_noise false), then assess_exploitability on candidates.
5. For a card with a safe playbook, draft_proof then execute_proof using tester
credential names and the canary I planted. Treat protected as refuted.
6. Summarize duplicates, evidence state, hunter_impact, and the repro_script.
Claim exploitable only when Keel reports proven.Traffic controls
Exact scope and exclusions on draft, admit, ingest, and proof
One wave per host; same-host jobs wait
Shared global and per-host token buckets
Persistent request reservations; retries consume a new reservation
Nuclei: signed HTTP templates, no OAST, no redirects, no retries, exclude dos/fuzz/bruteforce/intrusive
Isolated empty scanner configs; proxy and ProjectDiscovery-cloud env vars stripped
HTTP 429 stops the wave and honors Retry-After
Bounded response reads; evidence without raw bodies
Troubleshooting
keel-pentest doctor
keel-pentest setup # if doctor reports missing httpx/nucleibegin_engagement after a client restart restores the SQLite engagement. If you changed scope, use a new engagement_id.
Proofs need allow_safe_proof=true and, for session playbooks, KEEL_CREDENTIALS_FILE mapping names like tester-a to Authorization or Cookie.
License
MIT. Copyright (c) 2026 Lutfi Z.P.
PyPI: keel-pentest. MCP Registry: io.github.lutfizp/keel. Source: github.com/lutfizp/keel.
Available Tools
9 toolsbegin_engagementC
Register scope, rate limits, and proof flags for one engagement.
Inputs: scope_hosts (required), engagement_id (required), exclude_hosts, allow_safe_proof, +4 more.
draft_proofD
Describe an allowlisted proof without sending traffic.
Inputs: card_id (required), playbook_id (required), engagement_id (required).
draft_wavesA
Propose probe_alive then template_scan waves without executing them.
Inputs: seed_url (required), engagement_id (required).
engagement_healthC
Report registered engagements, cooldowns, and pending waves.
Inputs: engagement_id.
execute_proofC
Run an allowlisted proof. Requires allow_safe_proof and operator_confirmed.
Inputs: card_id (required), session_a (required), playbook_id (required), engagement_id (required), +1 more.
execute_waveC
Run one admitted wave behind the per-host token bucket.
Inputs: wave_id (required), engagement_id (required).
query_cardsB
Return hunter-relevant cards. Informational and hardening are hidden by default.
Inputs: engagement_id (required), include_noise.
second_lookC
Re-run a bounded template scan on a single card URL.
Inputs: card_id (required), engagement_id (required).
state_impactC
Record hunter impact_class and preconditions on a card.
Inputs: impact (required), card_id (required), hunter_why (required), engagement_id (required), +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Each tool targets a distinct resource and action: engagements, waves, proofs, and cards are cleanly separated. The two execute tools are disambiguated by proof vs wave, and the two draft tools by waves vs proof, so an agent should not confuse them.
Most tools follow a clear verb_noun snake_case pattern like execute_proof, begin_engagement, draft_waves, and query_cards. engagement_health and second_look break the pattern by using noun phrases, but the overall convention remains readable and predictable.
Nine tools is a well-scoped size for this domain, covering engagement setup, wave and proof execution, and card interaction without unnecessary redundancy or bloat.
The core loop is represented, but there is no explicit admission step for drafted waves before execute_wave, and engagements lack update/close lifecycle operations. These are notable workflow gaps that could stall end-to-end operations.
Maintenance
Related MCP Connectors
MCP server for Pentest-Tools.com: run scans, manage findings and reports via your preffered LLM.
Find, document and execute authenticated API calls across 1000+ apps via one MCP server
Find, vet, and run MCP tools through a secure audited gateway with prompt-injection risk scoring
AI pentesting: run scans, triage vulnerabilities, review PRs, manage schedules and assets.
Related MCP Servers
- AlicenseBqualityDmaintenanceAn MCP server for authorized bug bounty work that enforces an evidence-driven workflow with session management, preflight checks, surface discovery, and verified scanning.12MIT
- AlicenseNot gradedqualityBmaintenanceEnables authorized bug bounty automation via a scope-enforced MCP bridge, supporting web, secrets, mobile, and LLM red-team scanning, with reporting and advisory.MIT
- AlicenseNot gradedqualityBmaintenanceEnables MCP clients to carry out a compliant, non-destructive, auditable authorized security-testing workflow — project intake, scope reading, asset discovery, non-destructive verification, evidence collection, and report-draft generation with manual submission tracking — where every outbound action is gated by scope checks, one-time human confirmation tokens, rate limits, and append-only audit logging.MIT
- AlicenseNot gradedqualityAmaintenanceEnables professional penetration testers to run reconnaissance, network and web scanning, content fuzzing, vulnerability templates, brute-force checks, SQLi extraction, traffic capture, and engagement report generation through MCP clients.164 npmGPL 3.0