Agent-native · WebMCP
Let your agent
ask for evidence.
MCP Sentinel speaks WebMCP. A capable client can explicitly request an assessment of a declared tool surface or a published npm/PyPI package through this page's agent-callable tools.
Read the findings and what ran before deciding what to trust. The runtime gate shown below is an isolated browser demonstration, not production enforcement.
Building a WebMCP product yourself? Scan your own tool surface →
document.modelContext) to activate the agent tools. Everything below still works for humans.The two scans your agent can run
Both are readOnlyHint: false and run the live 184-rule engine, on different targets. The first vets a WebMCP tool surface - a page's declared getTools(), the WebMCP-native scan. The second vets an installable npm/PyPI MCP server your agent might add - its source, dependencies and install hooks, not a WebMCP surface. Each card shows an example run; run a real one in the console below.
Scan a page's declared WebMCP tools - plus any resources, prompts, capabilities and roots - before your agent trusts them. Pass a getTools() dump, or omit it to scan the current page. Not listed in the public registry, by design.
args: surface_json?
What it checks for
Reaches up to 59 of the 184 rules - the ones a declared surface can answer (description / schema / annotation / protocol / capability). Source, dependency & runtime rules are out of scope, not "clean".
The deepest scan: fetch the published npm/PyPI artifact, verify registry integrity, then run source taint analysis, dependency CVE audit and sandboxed stdio enumeration - the full engine.
args: ref
What it checks for
The deepest scan: up to 116 of 184 rules from source & dependencies, and up to 180 when the runtime can sandbox-execute the artifact (else that tier is reported as not-observed, never faked). Ceilings, not guarantees: the report shows what ran.
Findings are illustrative - real rule ids the deterministic engine emits for each scan kind, not a specific server's result. A surface scan is honest about coverage: a declared WebMCP surface can only exercise description/schema/annotation/protocol rules; source, dependency and runtime rules are out of scope, not "clean" - which is exactly what the npm/PyPI package scan covers.
What these scans catch
In plain terms - the classes of problem an agent (or a person) can vet for before trusting an MCP server or a WebMCP tool surface. Sentinel flags and ranks these by severity; you decide. A clean surface scan means nothing in scope tripped - not that a tool is safe to run.
- Hidden instructions in a tool's description or schemaText that tries to hijack your agent - "ignore previous instructions...", invisible/zero-width characters, or base64-encoded payloads a human reviewer won't see.
- Tools that lie about what they doLabelled read-only but actually delete, write or overwrite - or a destructive tool missing the warning your agent relies on to auto-approve.
- Dangerous capability combinationsOne server - or a set of tools together - that can read private data, take in untrusted content, and send it out (the "lethal trifecta").
- Unsafe packagesCommand injection, hard-coded secrets and API keys, malicious install hooks, and known CVEs in dependencies (package scan).
- Weak auth, transport & protocol handlingNo auth on a network interface, insecure transport, OAuth and session mistakes an agent shouldn't trust blindly.
Beyond the scan - watch a runtime gate
A static scan reads what a tool declares. Some attacks only appear when the tool actually runs. This isolated, in-browser demo wraps a WebMCP tool surface and judges tools by what they do - it blocks a hidden data-exfiltration attempt and refuses a tool that rewrites itself mid-session. It's the runtime half of the story the two scans above can't see.
- Declared read-only, but phones home → egress blocked at runtime
- Rewrites itself mid-session → overwrite refused at runtime
- Pushy "always use me first" wording → flagged from its declared text
Isolated training-ground demo: the tools live on a private in-memory shim, are not agent-callable, and nothing leaves your tab. Deterministic; no model calls. This is not a scanner - same-origin isolation means a page can't scan another site from the browser.
Run a tool yourself
No WebMCP browser handy? Run any tool right here - it opens on the WebMCP surface scan with an example already filled in, so you can hit Run and read a real, colour-coded result. This invokes the same function an AI agent calls over WebMCP, against the live MCP Sentinel API.
Run a live MCP Sentinel security scan of a WebMCP tool surface - a page's declared tools (and any resources/prompts/capabilities/roots it exposes). Pass the page's document.modelContext.getTools() output as JSON in surface_json; omit it to scan the CURRENT page's own WebMCP surface. Runs the real 184-rule engine against what the surface DECLARES and returns the coverage-aware verdict (safe / caution / risk / insufficient coverage) + findings. NOT read-only: it submits a scan (server-side work); a surface scan is non-publishing by design (no fetch, no socket), so it is NOT added to the public registry. Coverage is honest - a declared surface can only exercise description/schema/annotation/protocol rules; source, dependency and runtime rules are out of scope, NOT "clean". Rate-limited per client per hour; can take up to ~60s.
This calls the exact execute() an AI agent invokes over WebMCP - real MCP Sentinel API, real result. No AI model runs here; it is the deterministic tool call itself.
Try it - ask your agent
These tools call the same public MCP Sentinel REST API this site runs on - real engine, real results, nothing invented. The two shown running above - sentinel_scan_package and sentinel_scan_webmcp_surface - are the archetypes; sentinel_scan_target is the one unified tool that auto-detects any onboarding shape (a package, a launch command, a URL, a config, a GitHub ref, or a WebMCP surface). All submit a scan (readOnlyHint: false) - a successful package/URL scan may add its result to the public registry, while a surface or config scan is not listed in the public registry, by design. Not in a WebMCP browser? The registry, scanner, WebMCP surface scan, and reports all work the normal way too. Prefer the web form? Scan a server →
02 / Inspect the outcome
An agent can ask.
The answer keeps its limits.
A declared WebMCP surface and an installable package supply different evidence. Read the findings with what ran, what was out of scope, and what remains untested.
Keep the assessment boundaries beside the decision your agent makes.
Agent-callable scans require an explicit request. The runtime gate remains an isolated browser demonstration.
Explore the assessment recordTools that make evidence accessible
The decision stays inspectable.
Explore the API, review the scope of each input, and keep the findings and coverage beside your agent's decision.