Scepter
Checks GitHub-hosted MCP servers by reading repository metadata such as last push, archived status, license, releases, stars, maintainers, and open issues to assess health and maintenance.
Checks npm-published MCP servers by reading package registry metadata such as last publish, maintainers, releases, and links back to source to assess health and maintenance.
Generates a copy-paste Markdown health badge for an MCP server using Shields.io badge URLs.
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., "@Scepter scan my mcp.json for risky or abandoned servers"
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.
Scepter
Is this MCP server alive, maintained, and safe to use?
(Scepter checking itself:
scepter badge scepter-mcp --npm)

More than half of published MCP servers are already dead, and only a fraction of the tens of thousands out there are actively maintained. Developers wire them into their AI agents without knowing which ones are abandoned, unmaintained, or risky. Scepter answers that question in one command.
npx scepter-mcp check owner/repoInstall
# run without installing
npx scepter-mcp check <server>
# or install the command globally
npm install -g scepter-mcp
scepter check <server>Requires Node 18 or newer. No runtime dependencies.
Related MCP server: MCP Security Gateway
Usage
Check one server, by GitHub repo or npm package:
scepter check owner/repo
scepter check https://github.com/owner/repo
scepter check some-mcp-server
scepter check @scope/nameScan every server in an MCP config file:
scepter scan ./mcp.json HEALTHY 88 owner/weather-mcp
CAUTION 61 another/mcp-thing
RISKY 22 abandoned/old-mcp
1 healthy 1 caution 1 riskyOptions:
Flag | Effect |
| read the target as a GitHub repo |
| read the target as an npm package |
| print JSON instead of a report |
| show help |
Set GITHUB_TOKEN in your environment to raise the GitHub API rate limit.
Exit code is 1 when the verdict is risky, so you can use Scepter in CI.
Track health over time, not just a snapshot
Every check logs its score to ~/.scepter/history. The next time you check
the same target, the report shows what changed:
SCORE 92/100 · HEALTHY
▲ +6 pts since last check (3d ago, was 86/100)
▁▃▅▆▇▇ 6 checks recordedIf the verdict itself flips (healthy → caution, say), that's called out explicitly, not left for you to notice by comparing two numbers.
Watch a server instead of remembering to re-check it
scepter watch owner/repo --interval=60Re-checks the target on a schedule (default every 30 minutes) and prints one
line per tick, same history file check reads its trend from. When a verdict
actually changes, it's flagged inline instead of scrolling past silently:
Watching owner/repo every 60m. Ctrl+C to stop.
14:02:11 HEALTHY 92/100
15:02:14 HEALTHY 90/100
16:02:09 CAUTION 61/100 ← changed
owner/repo moved from healthy to caution (90 → 61/100).Useful for a server you've already wired into an agent and want to know the moment it starts to rot, instead of finding out when a tool call fails.
Add a health badge to your README
scepter badge owner/repoPrints a copy-paste Markdown badge:
[](https://github.com/owner/repo)See what your agent actually calls
Static checks tell you if a server looks healthy. wrap tells you how it really
behaves. Put Scepter in front of the real server in your MCP client config:
{
"mcpServers": {
"weather": {
"command": "npx",
"args": ["-y", "scepter-mcp", "wrap", "--", "npx", "-y", "@scope/weather-mcp"]
}
}
}Scepter forwards every byte unchanged, so your agent works exactly as before,
while recording each tool call, its result, timing, and any error locally under
~/.scepter. Then:
scepter report Recent MCP sessions (2)
SERVER CALLS ERR AVG SLOW
weather-mcp 42 3 88ms 310ms
files-mcp 17 0 12ms 40ms
Heads up
- weather-mcp failed 3 of 42 calls (last: "upstream timeout"). Check it: scepter check weather-mcpNothing leaves your machine.
Inspect what a server actually hands your agent
check reads metadata. inspect starts the server, completes the MCP handshake and audits the live tool list, the exact text your agent will read:
scepter inspect -- npx -y @playwright/mcp@latest @playwright/mcp (live, MCP 2025-06-18)
✓ Tools 25 tools, 25 with safety annotations
✓ Context ~5,072 tokens of tool definitions on every turn
✓ Pinned first inspection, tool list pinned for next time
✓ Tool audit no poisoned or unmarked destructive tools
HEALTHYCheck | What it catches |
Tool poisoning | descriptions or parameter docs that tell the model to hide things from you, ignore earlier instructions, read SSH or cloud keys, or redirect other tools |
Hidden text | invisible Unicode (format and control characters); a message smuggled in Unicode tag characters is decoded and shown to you |
Unmarked destructive tools | tools named like |
Context cost | how many tokens the tool definitions take on every turn, before you type anything; over 50,000 is flagged |
Runtime reach | for Node servers, which powerful built-ins the server actually loads while starting: process spawning, networking, file system. What it brought along, not just what its tool list claims |
Rug pulls | every tool is pinned to a hash in |
Measured on 11 Oct 2026:
Server | Tools | Annotated | Context per turn |
| 14 | 14 | ~3,300 tokens |
| 25 | 25 | ~5,100 tokens |
| 30 | 30 | ~6,600 tokens |
| 26 | 26 | ~14,400 tokens |
Remote servers work the same way, over Streamable HTTP:
scepter inspect https://mcp.deepwiki.com/mcp
scepter inspect https://example.com/mcp --header "Authorization: Bearer $TOKEN"The audit is pattern-based and runs entirely on your machine: no account, no API, nothing uploaded. Exit code is 1 on a risky verdict, so it works in CI.
Audit your whole MCP setup
One server can look fine on its own and still be dangerous next to another. audit starts every server in a config (stdio and remote, with their own env and headers), inspects each one, then looks for toxic flows: one tool that reads untrusted content, one that reads private data, and one that can send data out. Together they let a malicious web page or issue steer your agent into leaking your files.
scepter audit ~/.cursor/mcp.json
scepter audit # no path: finds the MCP configs of the common desktop and coding clients itselfA real setup of six popular servers, 11 Oct 2026:
HEALTHY filesystem 14 tools, ~3,279 tokens
HEALTHY playwright 25 tools, ~5,072 tokens
HEALTHY chrome-devtools 30 tools, ~6,597 tokens
HEALTHY desktop-commander 26 tools, ~14,396 tokens
HEALTHY deepwiki 3 tools, ~385 tokens
HEALTHY context7 2 tools, ~1,307 tokens
Together: 100 tools, ~31,036 tokens of context on every turn
! Toxic flow content from outside can steer the agent to read private data and send it out
reads untrusted content: playwright/browser_navigate, playwright/browser_navigate_back, chrome-devtools/navigate_page
reads private data: filesystem/read_file, filesystem/read_text_file, filesystem/read_media_file +10
can send it out: playwright/browser_file_upload, chrome-devtools/upload_file
CAUTIONEvery server here is well built. The risk only exists in the combination, which is exactly what a per-server scanner can't see.
audit also flags cross-server shadowing: a tool whose description names another server's tool (say, a calculator that mentions send_email) is trying to steer how your agent uses a tool it doesn't own.
Let your agent check servers itself
Scepter also runs as an MCP server, so your agent or any MCP client can check a server before wiring it in:
{
"mcpServers": {
"scepter": { "command": "npx", "args": ["-y", "scepter-mcp", "serve"] }
}
}It exposes four tools, each with a title, safety annotations and a structured output schema:
Tool | Input | Returns |
|
| score, verdict and signals for one server |
|
| the same for every server in that config |
|
| live tool audit: poisoning, unmarked destructive tools, context cost, changes |
|
| every server inspected, plus toxic flows across them |
inspect_server and audit_config start the servers they examine, so they are not marked read-only: your client will ask before the agent launches anything.
What it checks
Signal | Weight | Reads |
Activity | 35 | last publish (npm) or last push (GitHub) |
Maintained | 20 | archived flag, license, releases, link back to source |
Provenance | 15 | stars, maintainers, open issues, description |
MCP fit | 10 | whether it declares itself an MCP server |
Security | 20 | known advisories, via GitHub's advisory database |
A known critical advisory overrides everything else: the verdict is risky
regardless of how well-maintained the project otherwise looks. Couldn't reach
the advisory API? That's reported as "could not check", not silently treated
as "no advisories" -- Scepter never claims more certainty than it has.
What it does not do (yet)
Scepter does not sandbox the server, watch its network calls, or judge what a tool does at runtime beyond its declared description and annotations. Pattern checks can miss a cleverly worded poisoned description. Scepter never claims a server is "safe" or "undetectable", only what it can observe.
Roadmap
v1: health and trust check from metadata (
check,scan,badge)v2: see which servers your agent actually calls, and their failures (
wrap,report)v2.5: live audit of the tool list: poisoning, unmarked destructive tools, context cost, rug-pull pins (
inspect)v2.7: whole-setup audit with toxic flows, remote HTTP servers, and every check available to agents as an annotated MCP tool (
audit)v2.8: config auto-discovery, runtime reach, decoded hidden messages, cross-server shadowing, context-cost warnings (this release)
v3: full traces, per-task cost, and replay, with the health check as one view
License
MIT
Available Tools
4 toolsaudit_configAudit a whole MCP setupA
Start every server in an MCP config file, audit each one like inspect_server, and report toxic flows: combinations of tools that read untrusted content, read private data, and send data out.
Inputs: path (required). Returns: flow, servers, verdict
check_serverCheck an MCP server's healthARead-only
Check whether one MCP server is alive, maintained, and safe to use, from its npm package or GitHub repo. Returns a 0-100 score, a verdict (healthy, caution, risky), and the signals behind it.
Inputs: target (required), source. Returns: score, reasons, verdict
inspect_serverAudit a live MCP serverA
Start an MCP server (stdio command, or a Streamable HTTP url), read its tool list, and audit it: poisoned tool descriptions, destructive tools without a destructiveHint, context cost in tokens, and tools that changed since the last inspection.
Inputs: url, args, command. Returns: tools, server, verdict, findings, +1 more
scan_configCheck every server in a configARead-only
Run check_server on every npm-launched MCP server listed in an MCP config file (for example mcp.json).
Inputs: path (required), source. Returns: results
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
audit_config, check_server, and scan_config overlap somewhat: audit_config and scan_config both operate on config files and spawn servers, but audit_config focuses on toxic flows while scan_config runs check_server. check_server and inspect_server are fairly distinct (npm/repo health vs. live server tool-list audit) but both 'audit' a server, which could cause some confusion.
Two patterns coexist: <verb>_config (audit_config, scan_config) and <verb>_server (check_server, inspect_server). Within groups it's consistent, but the mix of _config and _server targets alongside two different verbs for auditing makes the scheme only partially predictable.
Four tools for a focused audit/scanning domain is lean but reasonable, each earning a place. It sits at the lower boundary of well-scoped rather than heavy.
Core flows—inspecting a single server, checking a package/repo, scanning and auditing a config—are covered. However there's no way to get/review prior inspection reports individually, diff drift over time, or audit a URL-based config comprehensively, leaving some lifecycle gaps.
Maintenance
Related MCP Connectors
Scan any MCP server for tool-poisoning, security, auth & license. Trust score before install.
Runtime behavioral trust scoring for MCP servers. Check reliability before calling unknown tools.
Independent trust scores, tool surfaces and change history for MCP servers.
The MCP server that vets MCP servers: identity, risk grade and per-tool risk before you install.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA continuous, out-of-band trust and reliability layer for the MCP ecosystem. It fingerprints MCP server tool definitions, detects and classifies drift (e.g., rug pulls) via a severity taxonomy, maintains a hash-chained evidence ledger, and gates CI with SARIF—while also acting as an MCP server itself so agents can check a server's safety before binding.Apache 2.0
- FlicenseNot gradedqualityDmaintenanceEnables safe use of any MCP server by proxying and live-scanning all tool requests and responses, blocking or redacting poison descriptions, indirect prompt injection, malicious arguments, and unauthorized destinations.-
- AlicenseNot gradedqualityBmaintenanceThis MCP server lets agents inspect every Model Context Protocol server on the machine, verify tools by running them in a sandbox, and check each call against a human-approved baseline so that changed or newly appeared tools are blocked before they execute. It also surfaces token cost, capability facts, and drift history for each tool entirely locally, without uploading inventory or requiring an account.1,312 PyPI1Apache 2.0

MCP Security scannerofficial
AlicenseAqualityBmaintenanceEnables users to deterministically audit MCP servers for security issues across manifests, source, runtime responses, multi-call state, identity, and install scripts, and to run an inline gateway that gates tool calls and scans responses before returning them.31Apache 2.0