novelty
Novelty is an MCP security toolkit that plugs into coding agents to hunt vulnerabilities in web apps and source code. It provides:
HTTP proxy & traffic tools — Send, log, replay, and fuzz HTTP requests (like Burp Repeater + Intruder).
Reconnaissance — Map the attack surface: discover tech stack, parameters, endpoints, and leaked secrets.
AI-driven vulnerability hunting — Automated scans for BOLA/BFLA, XSS, SQLi, business logic, RCE, and auth flaws.
Source code review — Audit source files for vulnerabilities with line‑referenced findings.
Memory & persistence — Save target dossiers, notes, and hunt logs; resume hunts across sessions.
Scope enforcement — Restrict testing to authorized hosts.
Disposable inboxes — Create throwaway email addresses for testing registration/verification flows.
Planning & methodology — Load playbooks (doctrine, recon, pentest catalogues), generate tailored plans, and consult a library of bypass techniques.
Reporting — Generate polished Markdown/HTML security reports for web targets or source code.
Autopilot harness — Run a governed, budget‑capped autonomous hunt via a standalone CLI.
Health & meta — Check server status, reasoning model, and available tools.
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., "@novelty hunt example.com for vulnerabilities"
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.
Novelty
Burp inside your AI harness. An MCP security toolkit that plugs into your coding agent — Claude Code, Codex, OpenCode — and hunts real vulnerabilities in web apps and source code.
Add it once and your agent gains a Burp-style HTTP proxy (Repeater + Logger), an AI-driven vulnerability hunt, a whole-file source auditor, and a disposable-inbox helper for testing authenticated flows. Every finding is reasoned on Claude, not matched by a regex.
Novelty weights the classes that actually pay out: BOLA/IDOR · BFLA · XSS · SQLi · business logic · RCE · broken auth.
The brain
The reasoning layer runs on the official Anthropic SDK with intelligent
routing — default claude-opus-4-6, and for a 5-family model an automatic
server-side fallback to claude-opus-4-8 so a cyber-safeguard refusal on an
authorized assessment still completes. Swap the model with one env var
(ANTHROPIC_MODEL).
Related MCP server: pentestMCP
Install (works in any MCP harness)
Novelty ships as a package — no clone, no venv. uvx downloads and runs it. You
only need uv installed and your ANTHROPIC_API_KEY.
The one command every harness runs under the hood:
uvx --from git+https://github.com/GOJO-SENPA1/novelty.git novelty-mcpClaude Code (one-liner):
claude mcp add novelty --env ANTHROPIC_API_KEY=sk-ant-YOUR_KEY_HERE \
-- uvx --from git+https://github.com/GOJO-SENPA1/novelty.git novelty-mcpCodex — add to ~/.codex/config.toml:
[mcp_servers.novelty]
command = "uvx"
args = ["--from", "git+https://github.com/GOJO-SENPA1/novelty.git", "novelty-mcp"]
env = { ANTHROPIC_API_KEY = "sk-ant-YOUR_KEY_HERE" }OpenCode — add to opencode.json:
{
"mcp": {
"novelty": {
"type": "local",
"command": ["uvx", "--from", "git+https://github.com/GOJO-SENPA1/novelty.git", "novelty-mcp"],
"environment": { "ANTHROPIC_API_KEY": "sk-ant-YOUR_KEY_HERE" },
"enabled": true
}
}
}Cursor / Claude Desktop / Windsurf / Cline — add to the harness's mcp.json:
{
"mcpServers": {
"novelty": {
"command": "uvx",
"args": ["--from", "git+https://github.com/GOJO-SENPA1/novelty.git", "novelty-mcp"],
"env": { "ANTHROPIC_API_KEY": "sk-ant-YOUR_KEY_HERE" }
}
}
}Then just ask your agent: "use novelty to hunt example.com and write a report", or "review this file with novelty".
No
uv? Install withcurl -LsSf https://astral.sh/uv/install.sh | sh, or swapuvxforpipx run --spec git+https://github.com/GOJO-SENPA1/novelty.git novelty-mcp.
Tools (31)
Group | Tools |
Plan |
|
Scope |
|
Recon |
|
Hunt |
|
Source |
|
Analyst |
|
Report |
|
Memory |
|
Auth |
|
Meta |
|
Memory
Novelty remembers across sessions. It keeps its own writable store at
~/.novelty/memory/ (target dossiers + wins, plus the append-only hunt-log.jsonl,
secrets redacted), and connects your existing memory read-only — auto-discovered
Claude project-memory dirs and a ~/tools/bugbounty workspace (curate the exact list
in ~/.novelty/sources.json).
recallsearches everything (own + connected), deduped.pickup(target)merges every layer about a target — prior dossiers, hunt-log, audit entries — so you resume a hunt cold;planauto-loads it.rememberwrites a new dossier note / win to Novelty's own store (never your connected files);memory_sourcesconnects/disconnects sources.
Point Novelty at a target and it already knows what you found last time.
Autopilot harness — novelty hunt
Novelty is an MCP, so it runs inside any harness. It also ships its own — a Claude-Code-class hunting cockpit built on the Claude Agent SDK (Claude Code's engine as a library, so we don't rebuild the loop/context/subagents):
# install globally (needs uv + Node.js + the `claude` CLI):
uv tool install "novelty-mcp[harness] @ git+https://github.com/GOJO-SENPA1/novelty.git"
export ANTHROPIC_API_KEY=sk-ant-YOUR_KEY # the MCP brain's key (the harness itself uses your `claude` login)
novelty-hunt http://target --budget 100 # one governed, autonomous hunt(pipx install "novelty-mcp[harness] @ git+…" works too. Plain pip install fails on
externally-managed systems like Arch, and the package isn't on PyPI — install from git.)
It runs the whole hunt end to end and owns the impact + severity call, calibrated by memory of what your past reports landed at — you're the reviewer who counters:
Doctrine as system prompt → hunts like a senior operator, not a scanner.
Scope-gated & non-destructive —
scope_setfirst, and the autopilot toolset omits Bash/Write/exec entirely; it runs on Novelty's own scope-guarded tools.Hard
$budget cap (--budget, default $100) — the SDK's nativemax_budget_usdstops the loop at the cap; live cost is printed.Memory-driven —
pickupat start, findings auto-save, your severity counters feed back into memory so its judgement sharpens over time.
The MCP stays usable in Claude Code / Codex / Cursor too — the harness is just a dedicated cockpit.
The mind — methodology + arsenal
Novelty carries a senior operator's playbooks, shipped in the package and consulted
by the brain. plan fingerprints a target and lays out a phased hunt — naming the
exact tool to drive at each step: Novelty's own tools, Claude-in-Chrome for
browser-only work (SPA/JS mining, DOM-XSS proof, network-waterfall capture,
authenticated surface mapping, console-secrets), and CLI recon
(subfinder/httpx/katana/jsluice/nuclei) where the harness has it. methodology
loads any playbook:
Page | What it is |
| the hunting law — scope, impact bar, negative controls, honest severity |
| nothing → mapped attack surface (JS-mining first) |
| systematic sweep of every web vuln category, with FP-killers |
| per-class encyclopedia: root cause → test → confirm → report |
| what actually lands per bug type (from disclosed reports) |
| the 7-question gate + impact-first report craft |
| combine findings into higher-impact chains |
| exhaust every control bypass before walking |
Plus the arsenal — a HackTricks-style bypass library across 9 vuln classes,
auto-primed into every hunt and pulled by arsenal / bypass_hunter when a control blocks you.
Memory & arsenal
Novelty ships a persistent brain modelled on a real bug-bounty workspace:
arsenal/— a HackTricks-style bypass/technique reference per class (SQLi, XSS, IDOR/BOLA/BFLA, auth/JWT, RCE/SSTI, SSRF, traversal/LFI/upload, business logic/race, WAF bypass). Thearsenaltool pulls a page when a hunt is blocked by a control, and its cues auto-prime the hunt brain.hunt log —
recon/hunt/reportappend milestones (~/.novelty/hunt-log.jsonl, secrets scrubbed);hunt_log/rememberread and add to it so a later session picks up.doctrine — an impact-first, non-destructive, chain-relentlessly creed baked into every AI prompt.
Reports
report_web, report_source, and report turn findings into a polished
security-assessment report — an AI-written executive summary, an overall risk
rating, a severity tally, and per-finding detail (exploitation, impact, evidence,
a non-destructive confirm step, and remediation). You get clean Markdown back,
and passing save_html writes a self-contained, print-ready HTML report in the
Novelty aesthetic. report builds a report from findings you already collected
(e.g. hunt output plus your own http_send/intruder evidence).
Run the site / API locally
The product is the MCP server. The Flask app just serves the product page and a health check the page reads for the live brain badge.
cd backend
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env # paste your key into ANTHROPIC_API_KEY
python app.py # serves the showcase page on http://127.0.0.1:5000Deploy
The static product page (frontend/) deploys to Netlify — see
DEPLOY.md. The MCP server and its brain run locally beside your
agent; nothing about your traffic or code leaves the machine except the model calls.
⚠ Authorized use only
Point these tools at targets you own or have explicit, written permission to test. They are non-destructive and do not defeat CAPTCHAs or bot-detection. Secrets are never stored or logged.
Available Tools
24 toolsarsenalA
Consult Novelty's arsenal — a HackTricks-style bypass/technique reference — when a hunt is blocked by a control. Pull a class page or search all pages. Args: vuln_class: one of sqli, xss, idor-bola-bfla, auth-jwt, rce, ssrf, traversal, logic, waf (aliases like "idor","jwt","lfi" also work) query: free-text search across the arsenal if you don't know the class Call with neither to list the available pages.
Inputs: query, vuln_class. Returns: result
chainA
Reason across findings for exploit CHAINS that raise impact (self-XSS + login-CSRF = ATO, info-leak + SSRF = cloud creds, …). Args: findings_json: a JSON array of finding objects (from hunt/review/report)
Inputs: findings_json (required). Returns: result
healthA
Show Novelty MCP status: which reasoning model is wired in and the tools available.
Inputs: no named parameters. Returns: result
http_getA
Show the full request and response (headers + body) for one logged entry.
Inputs: request_id (required). Returns: result
http_historyA
List recently logged requests (the HTTP history / Logger view).
Inputs: limit. Returns: result
http_replayA
Re-send a logged request with optional edits (Repeater tweak-and-resend).
Any argument left blank keeps the original request's value. Supplied headers are merged onto the original. Logs a new history entry.
Inputs: request_id (required), url, body, method, +1 more. Returns: result
http_sendA
Send an HTTP(S) request and log it to history (like Burp Repeater + Logger).
Args: method: GET, POST, PUT, DELETE, … url: full target URL (a target you're authorized to test) headers_json: optional JSON object of request headers body: optional request body (for POST/PUT) Returns the logged entry id, status, timing, and a response preview.
Inputs: url (required), method (required), body, headers_json. Returns: result
huntA
Run recon then an AI vulnerability hunt over the high-value classes (BOLA/BFLA/XSS/SQLi/business logic/RCE/auth). Non-destructive; authorized targets only. Returns findings with exploit scenarios, impact, a confirm test, and a fix.
Inputs: url (required). Returns: result
hunt_logA
Read Novelty's persistent hunt memory — recent milestones (recon/hunt/ finding/report), optionally filtered to a target. Secrets are never logged.
Inputs: limit, target. Returns: result
intruderA
Replay a logged request substituting marker with each payload (Intruder-lite).
Bounded to a small list — for enumeration/IDOR/auth checks, not stress testing. Args: request_id: a logged request to base the attack on marker: the placeholder string to replace (put it in the URL/body first) payloads_json: a JSON array of payload strings (e.g. ["1","2","3"])
Inputs: marker (required), request_id (required), payloads_json (required). Returns: result
mail_inboxA
Poll a throwaway inbox created by mail_new(). Returns messages and any links found (e.g. the verification link to finish signup).
Inputs: address (required). Returns: result
mail_newA
Create a throwaway inbox (mail.tm) for registering a test account on an app you're authorized to test. Returns an address to poll with mail_inbox().
Inputs: no named parameters. Returns: result
param_discoverA
Mine parameters, endpoints, and forms from a target's HTML + JS — the attack surface you then probe with http_send / intruder. Read-only.
Inputs: url (required). Returns: result
reconA
Read-only recon of a web target: tech stack, headers, forms, script bundles, backend/third-party services, missing security headers, and exposed-file checks.
Inputs: url (required). Returns: result
rememberA
Append a milestone/lead to Novelty's hunt memory so a later session can pick it up. Do NOT put credentials/tokens here (they'd be scrubbed anyway).
Inputs: note (required), lead, target. Returns: result
reportA
Render a report from findings you have ALREADY collected — e.g. the output of hunt/review combined with your own http_send/intruder evidence.
Args: findings_json: a JSON array of finding objects (Novelty or your own shape: title, severity, vuln_class, endpoint/file, exploit, impact, confirm_test, fix) target: the assessed target's name/URL (for the report header) kind: "web" or "source" save_html: optional path for the styled HTML report
Inputs: findings_json (required), kind, target, save_html. Returns: result
report_sourceA
Security-review a source file and produce a polished report (Markdown + optional HTML).
Args: path: local source file to review save_html: optional path for the styled HTML report
Inputs: path (required), save_html. Returns: result
report_webA
Hunt a web target and produce a polished security-assessment report.
Runs recon + the AI hunt, then renders a Markdown report (returned) and, if save_html is given, a styled self-contained HTML report written to that path. Authorized, non-destructive; authorized targets only. Args: url: the target to assess save_html: optional path for the styled HTML report (e.g. "reports/dvwa.html")
Inputs: url (required), save_html. Returns: result
review_codeA
Security-review a source file's contents with Claude (BOLA/BFLA/XSS/SQLi/ business-logic/RCE/auth). Pass the file text you have open; returns line-referenced findings with exploit + fix. Whole-file reasoning, not regex.
Inputs: code (required), filename. Returns: result
review_fileB
Same as review_code, but reads the file from a local path first.
Inputs: path (required). Returns: result
scope_setA
Set the authorized testing scope — an allowlist of hosts. Once set, the traffic tools (http_send, recon, hunt, secrets_hunt, param_discover) refuse anything out of scope. Supports wildcards, e.g. ["*.example.com","api.foo.io"]. Args: hosts_json: a JSON array of hostnames/domains (or a plain comma list)
Inputs: hosts_json (required). Returns: result
scope_showA
Show the current authorized scope (empty = not enforced).
Inputs: no named parameters. Returns: result
secrets_huntA
Pull a target's page + JS bundles and flag leaked secrets (cloud keys, tokens, JWTs, private keys, provider keys). Read-only, non-destructive.
Inputs: url (required). Returns: result
triageA
Adversarially triage ONE finding: is it real, exploitable and non-duplicate? Returns a verdict, dup-likelihood, adjusted severity, and the SAFE negative control to run to confirm or kill it. Args: finding_json: a single finding object as JSON
Inputs: finding_json (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 24 tools
Some tools overlap in purpose: recon is a subset of hunt, and report_web wraps hunt; similarly review_file vs review_code vs report_source overlap heavily. However, descriptions clarify the distinctions (e.g., review_file reads from path, review_code takes content, report_source adds report generation), and most HTTP/memory tools are clearly distinct.
The naming convention is inconsistent. Some tools use bare verbs (recon, hunt, remember, chain, triage), some use noun_verb (http_send, scope_show, secrets_hunt, param_discover), and others use noun_noun (http_history, hunt_log, mail_inbox). There is no single predictable pattern, making it harder to guess tool names.
24 tools is on the high side and borders on the 'heavy' range. The server covers a broad security testing domain, but there is some redundancy (three report tools, three code-review tools, three recon/hunt tools) that could be consolidated. Still, each tool has a role and the count is not excessive for a full-featured security toolkit.
The toolset covers the core security testing lifecycle well: recon (recon, param_discover), active testing (http_send, intruder), vulnerability analysis (hunt, review_code), reporting (report, report_web, report_source), and auxiliary support (arsenal, mail, memory, triage). Minor gaps exist (e.g., no dedicated session/cookie management, no tool for comparing HTTP responses), but these are workarounds.
Related MCP Connectors
Zero-config MCP security scanner for AI-generated apps. 25K+ vulnerability patterns.
Security scanner for MCP servers. Detect vulnerabilities, prompt injection, and tool poisoning.
AI-security knowledge as MCP: standards-mapped tools (OWASP, NIST, MITRE) for AI agents.
Zero-install security baseline for AI coding agents — OWASP/CWE-cited rules over MCP.
Related MCP Servers
- AlicenseNot gradedqualityFmaintenanceA lightweight, extensible cybersecurity toolkit that connects AI assistants to security tools through the Model Context Protocol (MCP), enabling AI-assisted security research, scanning, and analysis.15MIT
- FlicenseNot gradedqualityCmaintenanceAn MCP server that exposes over 20 standard penetration testing utilities, such as Nmap, SQLMap, and OWASP ZAP, as callable tools for AI agents. It enables natural language control over complex security workflows for automated and interactive penetration testing.120-
- AlicenseAqualityBmaintenanceMCP security server for AI coding agents. 12 tools: pre-install guardian, vulnerability audit, supply-chain attack detection via static code analysis, and CycloneDX 1.6 SBOM generation. Zero runtime dependencies.15109 npm15Apache 2.0
- AlicenseNot gradedqualityDmaintenanceA lightweight, extensible cybersecurity toolkit that connects AI assistants to security tools through MCP, enabling AI-assisted security research, scanning, and analysis.MIT