Skip to main content
Glama

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-mcp

Claude 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-mcp

Codex — 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 with curl -LsSf https://astral.sh/uv/install.sh | sh, or swap uvx for pipx run --spec git+https://github.com/GOJO-SENPA1/novelty.git novelty-mcp.

Tools (31)

Group

Tools

Plan

plan (tailored phased hunt plan, memory-aware), methodology (load a playbook)

Scope

scope_set, scope_show — authorization allowlist, enforced across traffic tools

Recon

recon, param_discover, secrets_hunt

Hunt

hunt, http_send, http_replay, http_history, http_get, intruder, bypass_hunter

Source

review_code, review_file

Analyst

arsenal (bypass helper), chain, triage

Report

report_web, report_source, report

Memory

recall, pickup, remember, memory_index, memory_sources, hunt_log

Auth

mail_new, mail_inbox

Meta

health

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).

  • recall searches everything (own + connected), deduped.

  • pickup(target) merges every layer about a target — prior dossiers, hunt-log, audit entries — so you resume a hunt cold; plan auto-loads it.

  • remember writes a new dossier note / win to Novelty's own store (never your connected files); memory_sources connects/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_set first, 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 native max_budget_usd stops the loop at the cap; live cost is printed.

  • Memory-driven — pickup at 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

doctrine

the hunting law — scope, impact bar, negative controls, honest severity

recon-methodology

nothing → mapped attack surface (JS-mining first)

pentest-catalogue

systematic sweep of every web vuln category, with FP-killers

vuln-classes

per-class encyclopedia: root cause → test → confirm → report

hackerone-patterns

what actually lands per bug type (from disclosed reports)

reporting-and-triage

the 7-question gate + impact-first report craft

chaining

combine findings into higher-impact chains

bypass-hunter

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). The arsenal tool pulls a page when a hunt is blocked by a control, and its cues auto-prime the hunt brain.

  • hunt log — recon/hunt/report append milestones (~/.novelty/hunt-log.jsonl, secrets scrubbed); hunt_log/remember read 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:5000

Deploy

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 tools
arsenalA

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

    A3.5/5.0

    Scored across 24 tools

    Disambiguation3/5

    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.

    Naming Consistency2/5

    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.

    Tool Count3/5

    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.

    Completeness4/5

    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

    Related MCP Servers

    • A
      license
      Not graded
      quality
      F
      maintenance
      A 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.
      15
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      An 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
      -
    • A
      license
      A
      quality
      B
      maintenance
      MCP 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.
      15
      109 npm
      15
      Apache 2.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      A lightweight, extensible cybersecurity toolkit that connects AI assistants to security tools through MCP, enabling AI-assisted security research, scanning, and analysis.
      MIT