vuln-intel

io.github.rozetypPublished by GitHub account rozetypv1.0.2Updated Oct 24, 2026

Free hosted CVE intel for bug-bounty agents: CVE fact-check, attack approaches from paid H1 reports

The publisher's own server: vulntel

Overview

AI-generated overview

Hosted CVE intelligence server that lets an assistant look up, rank, search and fact-check vulnerabilities, and borrow attack mechanics from disclosed…

What you can do
  • Look up and enrich single CVEs with CVSS, KEV, EPSS, SSVC priority, affected versions and public exploit signals
  • Check a product or server banner for ranked, de-duplicated vulnerabilities, and turn a recon'd stack into a ranked dig-order
  • Search the corpus by concept, seed CVE or recent time window, and search public code for exact strings
  • Verify claims about a CVE (existence, product, version, severity, exploitation) and report corpus size and freshness
  • Retrieve attack approaches, mid-hunt continuations, submission briefs and program outcome priors from disclosed bug-bounty reports
  • Scan a host's public pages and JS bundles to fingerprint its stack and join it to the corpus
When to use it
Useful when an assistant needs grounded CVE facts instead of training-data recall, especially to catch invented or misattributed CVE claims before they reach a report. Also aimed at authorized bug-bounty and pentest work: prioritizing a known stack, choosing what to probe first, and reusing approaches that worked on similar bugs.
Requirements
Remote streamable HTTP endpoint; no local package. An Authorization bearer token is required to call tools, obtained by signing up with an email; the handshake and tool list work without one. Without a key, a limited subset of tools runs under a per-IP daily call cap.
Before you install
The bearer token is a per-user credential and should be kept private; keys are described as attributable and revocable. The observe tool fetches a host's public pages and JS bundles, so the target host is disclosed to the service. Output is decision support only, and the server states it returns facts and precedent rather than exploits; use it only on targets you are authorized to test.

Installation

In SourceWeft

  1. Open vuln-intel in the dashboard and add it to a workspace.
  2. Connect Authorization token credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.rozetyp%2Fvuln-intel/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "vuln-intel": {
      "type": "http",
      "url": "https://mcp.rozetyp.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      }
    }
  }
}

README

[vulntel logo]

vulntel

[try it: no key needed] [MCP server] [corpus: 422k CVEs]

Most CVE tools hand your agent raw data. This one ranks it by what's actually being exploited, finds bugs by mechanism, catches the CVEs your agent invents — and transfers attack mechanics from ~14,000 disclosed bug-bounty reports.

A curated, hosted MCP corpus: ~422,000 CVEs, fused from NVD + CISA KEV + FIRST EPSS + OSV/GHSA + CISA Vulnrichment (SSVC), plus a mechanic layer distilled from ~14,000 disclosed, paid bug-bounty reports — refreshed daily. Not another live-API wrapper.

Free. Try it with no key (nine tools, 25 calls a day per IP address), then get a key: enter your email and your personal key is sent over. Tell me what you are hunting.


Why this, and not the next CVE wrapper

Most CVE MCP servers are thin wrappers: at query time they fan out to the same free public APIs and hand back whatever comes out. This is different in six concrete ways.

  • A curated, embedded corpus, not a live proxy. One record per vulnerability, fused across NVD, OSV/GHSA and KEV through an identity graph, with roughly 2,100 vendor-qualified product aliases and embeddings for semantic search. Queried locally, ranked consistently.
  • SSVC as priority, not just CVSS. Priority is exploitation-first: CISA SSVC (active / automatable / total impact), KEV and EPSS drive a P1 to P4 ranking. The wrapper MCPs do not carry SSVC at all.
  • Search by mechanism, not keywords. Semantic search finds the same bug class across different products. Keyword tools structurally cannot.
  • It fact-checks the agent. verify_cve_claim catches invented CVEs and wrong attributes. This is the one that matters most right now, with hallucinated AI bug reports flooding triage, and effectively no other CVE MCP does it.
  • Backport-aware. Paste a server banner (OpenSSH_8.9p1 Ubuntu-3ubuntu0.10, Apache/2.4.62 (Debian)) and each CVE carries the Debian / Ubuntu / Alpine tracker's verdict for that exact build next to the upstream one. Upstream-only tools call a patched distro host vulnerable.
  • Right vendor, and no false zeros. "GitHub Enterprise" resolves to the right vendor, not every product that ships an "enterprise_server." A product it cannot resolve returns resolved: false with suggestions, never a silent 0 that reads as "not affected." A false zero is the worst answer a security tool can give.

The hard part of AI-assisted security is not finding CVEs. It is triage, prioritization, and false positives. That is what this targets.

Everything below is real output from the live server, trimmed only for length.


It fact-checks your agent

The differentiator that matters most. Your agent cites CVE-2025-99999:

verify_cve_claim("CVE-2025-99999")  ->  exists: false    "No record in NVD / OSV / GHSA. Likely hallucinated or not-yet-published."

Or it gets the details wrong. Claim: "CVE-2021-44228 is a medium-severity Apache Struts bug, and it is not exploited."

verify_cve_claim("CVE-2021-44228", product="Apache Struts", severity="medium", exploited=false)  refuted  "not exploited"          ->  in CISA KEV (added 2021-12-10)  refuted  "severity medium"        ->  actual CVSS 10.0, P1  refuted  "affects Apache Struts"  ->  no product matching "Apache Struts"

The other feeds hand your agent data. This one tells you when the agent is wrong, before it reaches a report.

Priority is exploitation-first (SSVC, KEV, EPSS), not CVSS

check_technology("GitLab") returns 792 CVEs for the product, de-duped and ranked so the exploited ones float to the top:

P1  KEV  EPSS 99.8   CVE-2023-7028   account-takeover: password-reset email sent to an attacker address (CVSS 10)P2  KEV  EPSS 98.5   CVE-2021-39935  unauthenticated SSRF via the CI Lint APIP3       EPSS 99.7   CVE-2023-2825   unauthenticated path traversal, arbitrary file read (CVSS 10)P3       EPSS 99.7   CVE-2022-2992   authenticated RCE via the GitHub import API (CVSS 9.9)

Names that map to more than one vendor are flagged ambiguous (here, gitlab vs a jenkins plugin) and kept separate, never silently merged. enrich_cve then gives you the full SSVC picture for any one of them:

enrich_cve("CVE-2024-3400")   PAN-OS GlobalProtect  P1  KEV  CVSS 10.0  EPSS 99.95    unauthenticated command injection -> root RCE  SSVC          exploitation=active   automatable=yes   technical_impact=total  Metasploit    exploit/linux/http/panos_telemetry_cmd_exec  (rank: excellent)  Public PoC    44 repos   (h4x0r-dz 162 stars, W01fh4cker 90 stars, ...)

Turn recon into a dig-order

hunt_plan(["craftcms 4.4", "nginx", "keycloak"]) ranks your stack by its most-exploitable bug and names where each component historically bleeds:

#1  craftcms 4.4    97 CVEs, 12 high-risk    recurring_loci   CWE-94 code injection x7 (2 exploited in the wild)  ->  probe template / eval surfaces first    dig here       P1 KEV EPSS 99.8   CVE-2025-32432   unauthenticated RCE (CVSS 10)        your 4.4 is AFFECTED, fixed in 4.14.15       P1 KEV EPSS 99.9   CVE-2024-56145   RCE when register_argc_argv is on    AFFECTED, fixed in 4.13.2
#2  nginx           HTTP/2 Rapid Reset CVE-2023-44487 (KEV)#3  keycloak        recurring_loci CWE-287 auth x12.  OIDC request_uri SSRF CVE-2020-10770

It does not just list CVEs. It names the bug class a product family keeps failing at, ranked by real exploitation, and tells you whether your version is in range. Where to look, and what shape to expect.

Search by mechanism, across products

search_vulns(cve_id="CVE-2021-44228"), "what else works like Log4Shell":

sim 0.88   CVE-2021-44832   Log4j2 JDBC Appender, JNDI LDAP RCEsim 0.82   CVE-2022-40145   Apache Karaf, code injection via an attacker-controlled JNDI URLsim 0.79   CVE-2022-34916   Apache Flume, JNDI LDAP RCE via a JMS source

The same JNDI-injection mechanism, surfaced across different products. A keyword search for "log4j" never finds Karaf or Flume. Or search a concept directly, search_vulns("SAML SSO authentication bypass"):

P3      CVSS 9.1  CVE-2024-9487   GitHub Enterprise: SAML SSO bypass via signature verificationP3      CVSS 9.8  CVE-2025-25291  ruby-saml: auth bypass via a ReXML / Nokogiri parser differentialP1 KEV  CVSS 9.8  CVE-2025-59718  Fortinet FortiOS / FortiProxy: signature-verification bypass

See what is being exploited right now

search_vulns(days=7), run live today:

P1 KEV CVSS 10.0  CVE-2026-10520  Ivanti Sentry: unauthenticated OS command injection -> root RCEP1 KEV CVSS 9.3   CVE-2026-50751  Check Point: IKEv1 auth bypass, remote-access VPN without a passwordP2 KEV CVSS 8.8   CVE-2026-11645  Chrome V8: out-of-bounds read/write -> sandbox escape RCE

Median time from disclosure to in-the-wild exploitation is now days, not months. The Ivanti bug above carried a CISA remediation deadline in the same week it landed. corpus_stats on 2026-11-03: ~422,800 CVEs, ~1,770 KEV entries, data under a day old. These figures are point-in-time and drift daily, so call corpus_stats yourself for the live count rather than trusting the numbers on this page.

Transfer attack mechanics from disclosed bug-bounty reports

Beyond CVEs, the corpus distills ~14,000 disclosed, paid HackerOne reports into product-agnostic attack mechanics — each bug's source → sink → trigger → preconditions, de-anchored from the product it was filed against. The premise: a vulnerability is a transferable mechanism, not a property of one product — so a move that paid on one stack is a checklist item on the next.

find_attack_approaches(query="ssrf reaching cloud metadata") — the human moves that transferred, novelty-ranked, each tagged with live program-actionability:

Reddit         SSRF   preview_url fetches an unfiltered URL → returns metadata    program_active, paysU.S. DoD       SSRF   /download-url?url= fetches AWS instance metadata            program_activeConcrete CMS   SSRF   DNS-rebind bypass → AWS IAM creds from the metadata svc     program_active
  • find_continuations(position=...) — matches your accumulated attacker position mid-hunt to the next moves real reports played from a similar spot. Every move is status: UNVERIFIED with a decisive_check to run on the target — a legal move, never a confirmed bug.
  • assist_submission(finding=...) — a grounded submission brief from the closest paid precedents (validity, what's novel, an escalation playbook), with every cited report validated against the corpus (citations_grounded) so it can't smuggle a fabricated precedent.
  • program_outcome_prior("hackerone:gitlab") — the bug classes that historically landed on a program, with lift over base rate (GitLab: SSRF 3.4×, SQLi ~never).

Honest about what this is: it primes and grounds a human hunter — it surfaces the move and the precedent. It does not find the bug for you; the target decides whether the move survives, and that's a step you still run.


The whole point: a memory of mechanics to borrow and run — not a CVE lookup

The moat is three things a stateless model cannot self-generate, and this corpus holds all three:

  • Watched over time — priors, temporal drift (Log4Shell's affected set kept growing +1,200 days after publish), score stability. Your model has a training-cutoff snapshot; this has the trajectory.
  • Seen many — every disclosed mechanic and CVE mechanism, embedded, so the same bug class transfers across products a model would never connect: Log4Shell's JNDI lookup → Apache Karaf, Flume; an SSRF that paid on Reddit → the move to try on the next target.
  • Live-fused recon — observe recovers a host's real backend from its JS bundles and joins it to the corpus on the spot.

The cardinal sin is treating it as a severity-number checker. The job is to transfer a proven mechanic onto your target and run it — or read a fix to falsify an option before you spend a probe on it.

Force your agent to reach for it — it won't on its own

Left alone, an agent answers from training data: stale, and it invents CVE ids under pressure. Paste this operating loop into your agent's rules (CLAUDE.md, Cursor/Windsurf, a system prompt):

text
You have the vulntel MCP. Your own CVE knowledge is a guess to be verified — prefer the corpus.Operating loop, in order:1. Choosing / scoping a bounty program → new_in_scope (what just entered a program's scope, re-adds filtered) and program_outcome_prior (which bug classes have actually PAID here).2. A live host → observe (a cache miss returns status="scanning"; call again with the same host until "ready"). Mine endpoints[], recurring_loci, the CVE join, not just two fields.3. A product + version → check_technology / hunt_plan (dig-order + the recurring CWE loci).4. Before asserting ANY CVE / "affects X" / "severity Y" / "exploited" → verify_cve_claim. Never cite from memory.5. Feasibility of one CVE → enrich_cve; read the MECHANISM (POST vs GET, auth-required) to judge whether it chains. How it was fixed in the wild, or who vendored the vulnerable line → search_public_code (raw hits; read them).6. Hunting a class → find_attack_approaches for the transferable move; RUN it on the target, don't cite it. Loop with a growing tried=.7. Stuck / messy position → find_continuations(position) for the by-step move; then search_vulns that class to see whether it recurs in this stack.8. Submitting → assist_submission; EXECUTE the techniques it transfers (referrer differential, key-reuse breadth), then file.9. Before trusting a "nothing found" → corpus_stats (corpus size and data age).Above all: a finding isn't a finding until a cheap check that would kill it has failed to.

It surfaces the move and the precedent; the target decides what survives. That last rule is the product's whole ethos — every tool ships its own kill-check (verify_cve_claim refutations, UNVERIFIED + a decisive_check, ambiguous, citations_grounded), so an agent can never read a narrow signal as a green light.


Connect, free

claude mcp add --transport http vulntel https://mcp.vulntel.com/mcp \  --header "Authorization: Bearer <YOUR_KEY>"

Or any MCP client (mcp.json):

json
{  "mcpServers": {    "vulntel": {      "type": "http",      "url": "https://mcp.vulntel.com/mcp",      "headers": { "Authorization": "Bearer <YOUR_KEY>" }    }  }}

Try it first with no key: claude mcp add --transport http vulntel https://mcp.vulntel.com/mcp. Nine of the 13 tools run 25 times a day per IP address, and each answer says how many calls are left. A free key lifts that to 60 calls a minute and adds observe, new_in_scope, assist_submission and search_public_code. See Get a key below.

The 13 tools

CVE intelligence:

ToolInputReturns
check_technologya product (+ version, vendor), or a server bannerranked CVEs de-duped across NVD CPE + OSV, ambiguity-flagged; distro build verdicts for Debian / Ubuntu / Alpine banners
hunt_plana recon'd stackper-component dig-order + the recurring bug-class (CWE) loci
enrich_cvea CVE idfull dossier: CVSS, KEV, EPSS, SSVC, affected, Metasploit + live PoC repos
verify_cve_claima CVE + asserted attributesper-claim supported / refuted / unverifiable + evidence
search_vulnsa concept, a seed CVE, or a window (+ product)keyword + semantic fused search; a seed CVE's mechanism-siblings across products; or the newly dangerous window (published or added to KEV)
observea hostlive recon: stack + endpoints from the homepage and JS bundles, joined to the corpus as a dig-order
search_public_codean exact code stringpublic repos where it appears (repo / file / url)
corpus_stats—corpus size and data freshness

Bug-bounty mechanic transfer (from ~14k disclosed reports):

ToolInputReturns
find_attack_approachesa target / CVE / bug-classtransferable attack mechanics, novelty-ranked + live program-actionability
find_continuationsyour mid-hunt attacker positionthe next moves real reports played from there, each UNVERIFIED + a decisive check
assist_submissiona draft findinggrounded submission brief + escalation playbook, citation-guarded (citations_grounded)
program_outcome_priora bug-bounty programthe bug classes that historically landed on it + lift over base rate
new_in_scopea window (+ platform, program, asset type)assets that just entered a program's scope (HackerOne, Bugcrowd, Intigriti, YesWeHack), re-adds and renames filtered out, with the cached stack, repo advisories and the program's disclosed history

It lays out facts, ranked context, and transferable precedent — never an exploit or a payload. Your agent does the reasoning; the target decides what survives.

Full reference — every argument, response field, and a live example per tool — in TOOLS.md.

Hunt with it: the skill + playbook

Two MIT-licensed companion docs turn the corpus into landed findings, not CVE lookups: a self-contained Claude bug-bounty-hunting skill (drop the folder into ~/.claude/skills/ and it loads on "hunt for bugs" / "is this exploitable") and the deeper on-demand MCP playbook (per-tool gotchas, the ideation loop, the verification patterns). Both stand alone: see bug-bounty-hunting/.

What it is not

Not a scanner, not an exploit tool, not an SBOM / SCA replacement. A grounding, prioritization and fact-check layer for AI-assisted security work.

Get a key

It is free. Go to mcp.vulntel.com/signup, enter your email, and your personal key is sent over. Prefer to ask directly? Email [email protected] with what you are working on (bounty, pentest, research). Keys are per-user, attributable and revocable.


For authorized security research and bug-bounty work, only on targets you are permitted to test. The server returns facts, not attacks; output is decision support, not a substitute for your own verification.

© 2026 rozetyp. All rights reserved. This is not open source; see LICENSE.

Source: README.md at commit 0fef685

Tools

12

enrich_cve

Enrich a CVE

Full intelligence for a single CVE: CVSS, KEV status, EPSS, CISA SSVC (exploitation/automatable/technical_impact), P1-P4 priority with rationale, affected products/versions, and (live) public-exploit signal. Args: cve_id: e.g. "CVE-2025-12345". include_poc: also query GitHub for public PoC/exploit repos (live).

Parameterscve_idrequiredinclude_poc

check_technology

CVEs for a product and version

Find vulnerabilities affecting a product across NVD (CPE) and OSV (package ecosystems), de-duplicated and ranked by priority/EPSS/CVSS. Distinct products that share a name are kept distinct. If one name maps to several VENDORS' unrelated products (e.g. "Sentry" → sentry, mobileiron, apache; "Envoy" → envoyproxy, enphase), the result is flagged `ambiguous` with `distinct_vendors` — pass `vendor=` to disambiguate. Always check each result's `match.products` (vendor:product) before trusting a hit. Args: product: product or package name, e.g. "nginx", "Keycloak", "mlflow", "lodash". version: optional exact version (e.g. "1.18.0") — filters to vulns whose affected range (CPE or package) actually includes it. ecosystem: optional package ecosystem filter, e.g. "PyPI", "npm", "Maven", "Go". vendor: optional CPE vendor filter to disambiguate a shared product name, e.g. vendor="sentry" (not mobileiron), vendor="envoyproxy". limit: max results.

Parameterslimitvendorproductrequiredversionecosystem

hunt_plan

Rank a recon'd stack into a dig order

Turn a recon'd stack into a ranked dig-order for authorized bug-hunting. For each discovered component, returns its top high-risk CVEs (KEV / CISA-SSVC- active / high-EPSS first) AND its `recurring_loci` — the bug classes (CWE) this product family repeatedly fails at, ranked by real in-the-wild exploitation — i.e. WHERE to look first and WHAT shape to expect. Components are ordered by their most-exploitable bug (`dig_rank`). Grounded in exploitation data, not model guesses; lays out facts for triage/where-to-look, never a payload. Args: technologies: discovered stack, e.g. ["craftcms 4.4", "nginx", "keycloak"]. per_tech: how many top CVEs to surface per component (default 4).

Parametersper_techtechnologiesrequired

observe

Scan a host's exposed stack

Scan a host's exposed stack and join it to the CVE corpus — the recon workhorse. Fingerprints the homepage + JS bundles (recovering the backend identity and API endpoints homepage detection misses on SPAs), then ranks against live KEV / SSVC-active / high-EPSS into a dig-order. Fetches only public pages — authorized targets only. NON-BLOCKING: a scan takes ~1-4 min, so observe() never waits on it. A recent scan (<24h) returns status="ready" instantly. A cache miss KICKS a background scan and returns status="scanning" immediately — POLL by calling observe() again with the same host until it returns status="ready". Returns: - status="ready": host stack + endpoints + dig_order + top_across_stack (the scan result), plus bounty_programs: public programs whose current scope lists this host. - status="scanning": retry_after_seconds + last_scanned_at (call again after that delay). - status="error": a guard/validation error. Args: host: hostname or URL in an authorized bounty scope, e.g. "auth.example.com". fresh: force a re-scan (kicks a new background scan even if a recent one exists). per_tech: top CVEs to surface per component (default 4).

Parametershostrequiredfreshper_tech

search_vulns

Search CVEs by concept, keyword or seed CVE

Search the CVE corpus — one entry point, three retrieval modes picked from your arguments: - query= a concept / technique / weakness (e.g. "SSO SAML assertion replay", "deserialization gadget chain", "server-side request forgery cloud metadata"). By default it FUSES full-text keyword search AND semantic mechanism-search, so you don't have to guess whether your phrasing is lexical or conceptual. order='relevance' = keyword only; order='similarity' = semantic only; order='severity' = fuse then rank P1>P4. - cve_id= a seed CVE (e.g. "CVE-2021-44228") -> its mechanism-siblings across OTHER products (the "what else looks like this?" move). - days= and/or product= (with NO query) -> the recent high-risk window (KEV / P1-P2 / high-EPSS); product= is CPE-name-resolved and each hit carries match.products. Returns ranked cards (each with priority/KEV/EPSS/CWE) + total_matches for coverage; the 'mode' field reports which retrieval ran. You decide which matches matter. (For a specific product's version-resolved vulns use hunt_plan; for how bugs like this were FOUND in disclosed reports use find_attack_approaches.) Args: query: free-text concept / keyword / CWE. cve_id: seed CVE for semantic mechanism-sibling search. cwe: optional weakness filter, e.g. "CWE-502" or "502". days: recency filter on publication date. product: product filter for the recent-window mode (CPE-name-resolved, carries provenance). order: relevance | similarity | severity (default: fused when query is text). limit: max results.

Parameterscwedayslimitorderquerycve_idproduct

find_attack_approaches

Find attack approaches from disclosed bounty reports

Find how bugs *like this* were actually FOUND — retrieve real disclosed bug-bounty report mechanic-cards whose approach is closest (by mechanism) to your query or a seed CVE. The "what approach worked on a bug like this, on which program, and what did it pay" layer: grounded in real publicly-disclosed, paid HackerOne reports, each distilled to a transferable mechanic (bug_class / source / sink / trigger / impact) and embedded in the same space as the corpus. Use it to BORROW a proven attack approach for a target or CVE you're working — especially to get UNSTUCK: results are novelty-ranked to surface non-obvious moves over the common playbook. Give EITHER: query: a free-text approach/bug description, e.g. "SSRF via webhook URL to cloud metadata", "IDOR swapping an object id to read another tenant's data". cve_id: a seed CVE you're working — returns the human attack approaches that transfer to it. Optional: bug_class filter (e.g. "SSRF") sharpens precision; days filters by disclosure recency; tried=["IDOR","XSS","SSRF"] = bug-classes you've ALREADY attempted, pushed down so you get the approaches you HAVEN'T thought of (the "I've exhausted the obvious, what else?" move). capec="CAPEC-664" = constrain to a canonical attack-pattern class (CAPEC). Pass it ALONE (no query/cve) to pull the real disclosed mechanics for that pattern, ranked by bounty — the coverage-driven "give me proven moves for this attack class" retrieval. Each result carries its canonical 'capec' class(es), the transferable 'trigger', the program, the bounty paid, and whether that program is still active/in-scope. Complements find_similar_vulns.

Parametersdayscapeclimitquerytriedcve_idbug_class

find_continuations

Next moves from a hunt position

When you're STUCK mid-hunt: describe your POSITION — the attacker state/capabilities you hold, stripped of product names — and get the CONTINUATIONS that worked from positions like it, matched against the full disclosed-report BODIES (the concrete step/payload/precondition), not just the distilled card. This is the "I have a messy pile of capabilities, what are my legal moves?" layer. position: a product-free statement of what you can already do, e.g. "a backend fetches a user-supplied URL during import/webhook and I can't read the response (blind)", or "I hold a low-priv token and can store config that is later rendered to an admin". The richer/sharper the position, the better — vague positions retrieve generic moves. Optional program: restrict to one program's reports (substring match on handle). Returns concrete 'move_step' techniques from real reports — including non-obvious cross-class moves the by-card layer can't surface (e.g. credential-leak-on-redirect, request-smuggling desync). HARD CONTRACT: every result is status=UNVERIFIED — a LEGAL MOVE, never a confirmed bug. Each carries a 'decisive_check' you must verify against the target (read its code / fire a test) before claiming anything; the corpus generates the move, the TARGET decides if it survives. Complements find_attack_approaches (by-card mechanism) — this is the by-step, full-body layer.

Parameterslimitprogrampositionrequired

assist_submission

Strengthen a bug-bounty submission

Submission & escalation co-pilot for a bug-bounty finding. Paste your DRAFT finding (and what you already tried / couldn't achieve) and get a grounded brief built from the closest REAL disclosed reports: (1) precedent & validity — is this an accepted class, with citable reports (ammunition if it was disputed/closed); (2) what's novel/stronger about yours — what to lead with; (3) an escalation playbook INCLUDING moves you may NOT have tried, each with honest feasibility; (4) submission-framing tips. Every cited report URL is validated against the retrieved corpus — ungrounded citations are flagged in 'citations.ungrounded' with 'citations_grounded=false', so the brief can't smuggle in a fabricated precedent (this guards the citations only — never read it as a verdict on whether your finding itself is real). Optional 'query' overrides the retrieval text (default: the finding itself). Complements find_attack_approaches (which returns the raw prior-art cards).

Parameterslimitqueryfindingrequired

program_outcome_prior

What lands on a bounty program

At the START of an engagement on a bug-bounty PROGRAM, get a grounded prior over what bug classes have historically LANDED there — to decide what to look at first and what to skip. Built from real HackerOne disclosed reports: the class distribution for this program, each with LIFT over the global base-rate, sample size, and cited example reports; plus `lands_rarely` — the classes that land broadly across programs but almost never here (where NOT to spend the first hour). DESCRIPTIVE, not predictive: it reports what *landed*, never claims what you *will* find. It's a disclosure-selected sample, HackerOne-only (~379 programs with public disclosures), models bug-class not payout, and withholds a prior when the program has too few reports (an anecdote isn't a distribution). Pass a program handle or name, e.g. "gitlab", "shopify". Complements find_attack_approaches (mechanism transfer) and hunt_plan (CVE dig-order) — this is the minute-zero "where to start" prior an agent has no tacit target knowledge to form on its own.

Parametersprogramrequired

verify_cve_claim

Fact-check a CVE claim

Fact-check a claim about a CVE against the corpus — catch hallucinations before they ship. Verifies: does the CVE exist; does it affect the claimed product at the claimed version; is the severity right; is it actually KEV-exploited. Returns per-assertion verdicts (supported / refuted / unverifiable) with cited evidence. Use it to check what another agent (or a draft report) asserted, e.g. "CVE-2021-44228 is a critical RCE in Log4j 2.17, actively exploited" → verify_cve_claim("CVE-2021-44228", product="log4j", version="2.17.0", severity="critical", exploited=True). Args: cve_id: the CVE/GHSA/PYSEC id being claimed about. product / version: optional — checks the affected-version claim in range. severity: optional — a CVSS number ("9.8") or label ("critical"/"high"/…). exploited: optional bool — the "actively exploited / in KEV" claim. claim: optional free text — returns evidence (summary, CWE) for you to judge.

Parametersclaimcve_idrequiredproductversionseverityexploited

corpus_stats

Corpus size and freshness

Corpus size and data freshness (CVE / KEV / EPSS counts and latest timestamps).

Takes no parameters.

search_public_code

Find public copies of a code string

Search public repositories for an exact code string; return WHERE it appears. Use it to hunt vendored / copy-pasted copies of known-vulnerable code: search a distinctive line or symbol from the vulnerable function, then FETCH AND READ the hits to judge which copies are still unpatched, reachable, or just fossils/forks. Returns RAW search results only -- it makes no vulnerability judgment; that reasoning is yours. Args: code: an exact code string, e.g. "VP8LBuildHuffmanTable" or a distinctive line. lang: language filter for the code search (default "c"). limit: max hits to return.

Parameterscoderequiredlanglimit

Version history

2
  1. v1.0.2LatestOct 10, 2026
  2. v1.0.1Sep 16, 2026

Score

90% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.

Other Vulntel integrations