Skip to content
Agentic Control Plane

Which MCP servers have the best native controls?

People often say: you don’t need a separate control layer, the MCP servers already have controls. That’s half true. First-party servers did grow real control surfaces in the last year: read-only flags, toolsets, scoped keys, admin allowlists. They differ a lot, their docs rarely say who can change them or what they can’t express, and two of the most-used servers went the other way entirely.

This page compares the native controls of sixteen widely used MCP servers as of August 2026. It asks seven questions of each:

  1. Auth. How does the server know who’s calling, and is scoping enforced server-side or client-side?
  2. Read-only. Is there a real one, and at what layer does it hold?
  3. Scoping. Can you bound the blast radius to one project, one directory, one org?
  4. Tool filtering. Can you remove tools from the surface entirely?
  5. Approvals. Does anything natively require a human before a call fires?
  6. Audit. What record exists of what the agent did?
  7. Who holds the keys. Where does the control live, and who can rewrite it?

This is the server-side companion to our harness controls comparison (what the agent side ships) and the coverage matrix (what our layer intercepts). Each row links to a deep page. Corrections are welcome. Every claim links to its source, and this page changes when the servers do.

The summary

  • Richest control surface: the GitHub MCP server. Read-only via flag, env var, header, or URL path. 23 toolsets plus per-tool selection. A lockdown mode for untrusted-contributor content. GitHub is also clear about the limits: lockdown is explicitly “not an authorization boundary”, and a June 2026 advisory found a cross-user bug in the lockdown control itself.
  • Best-documented security model: Sentry. Dual-token OAuth so the client never holds the raw credential, a skills system that gates which tools exist per grant, path constraints enforced per request, and fail-closed handling of stale grants. This is the page where we mostly grade up.
  • Cleanest server-side enforcement: Stripe. Restricted API keys are checked by Stripe, not by the local process. A read-only key cannot issue a refund whatever the agent or its config says. It has no amount thresholds or approval rules. Stripe’s own docs leave human confirmation to the client.
  • Strongest database story: Supabase. --read-only enforces as a read-only Postgres role (not just a hidden tool), --project-ref limits the blast radius to one project, and --features prunes tool groups. All three are launch flags in the client config. The lethal-trifecta incident started from a config where none were set.
  • Most candid vendor: Playwright. The top server by usage deleted its origin filters in v0.0.47 as not a real boundary, restored them a week later after community pushback, and still labels them “not a security boundary” (redirects walk through). The README’s security section opens with “Playwright MCP is not a security boundary.” There is no native way to say “browse, but never submit a form.”
  • The zombie: the archived Postgres reference server. Deprecated July 2025, still pulling roughly 312k npm downloads a month, with a SQL injection fixed in git but never published to npm or Docker. The maintained community successor defaults to unrestricted.
  • The zero: Notion’s hosted server. No read-only mode, no tool filtering, no scoping. Tools act with your full Notion permissions, and the read-only-capable open-source server is maintenance-only. The only native control on the hosted path is which human logs in.
  • Good admin controls, no call policy: Atlassian and Slack. Domain and IP allowlists, connection approval, and per-call audit logs of tool invocations. But those controls decide which clients may connect, and the per-call logs are records, not rules. Nothing decides which calls may fire.
  • The one native ask, already being retired: AWS. REQUIRE_MUTATION_CONSENT on the AWS API server is the only native per-call human approval in the set, verified fail-closed at both layers. AWS’s managed successor deprecates it back to IAM (“Not needed — use IAM policies”).
  • Posture as a URL: Linear. The control Notion lacks, shipped as a dedicated endpoint. /mcp/readonly only ever serves read tools, enforced by the server and visible at a glance in any config. It’s the best read-only UX in the set, and the only lever Linear has.
  • The aggregator: Zapier. One endpoint in front of 9,000+ apps, so the lethal trifecta can assemble inside a single server. It has the finest tool selection in the set (per-action, per-field locking), but that is no longer the default. In dynamic mode the agent can enable its own actions. It also has the fullest per-call audit record in the table, useful for forensics only.
  • The inverse page: Context7. Read-only by design. The risk flows into the agent, not out: open library submission, no review step, and a disclosed injection-via-docs channel (patched, though the submission model is the product).
  • The rawest surface: Chrome DevTools MCP. 57 tools over the DevTools protocol. --autoConnect attaches to your real Chrome behind one Allow dialog, and evaluate_script survives every subtraction. The vendor gets default-on telemetry and the operator gets no record.

The comparison

Server Auth Read-only Scoping Tool filtering Approvals Audit Who holds the keys
GitHub (deep page) PAT or OAuth (remote) --read-only / GITHUB_READ_ONLY=1 / X-MCP-Readonly header. Strict filter, takes precedence Token scopes + toolsets 23 toolsets, per-tool --tools, dynamic toolsets (the model can enable more); lockdown mode for untrusted content None None at the server Launch flags + headers in client config; token scopes at GitHub
Playwright (deep page) None (local browser). --isolated / --storage-state control which sessions it holds None --allowed-origins / --blocked-origins, removed in v0.0.47 and restored a week later; docs: “not a security boundary,” redirects bypass --caps gates extras only (vision, pdf, devtools); core act tools not subtractable None --save-trace (off by default; forensics, not control) Launch flags in client config
Supabase (deep page) PAT or OAuth --read-only: enforced as a read-only Postgres role and hides mutating tools --project-ref (unscoped = every project in the account) --features groups None None Launch flags in client config
Filesystem (deep page) None None (Docker ro mount as a workaround) Allowed directories, but client-supplied MCP roots silently replace them None None None The connected client: the boundary is client-writable at runtime
Stripe (deep page) OAuth (remote, sessions revocable in Dashboard) or restricted API keys Read-only restricted key, enforced by Stripe server-side Per-resource key permissions (binary read/write; no amounts, no velocity) --tools (local); remote writes concentrate in one stripe_api_write meta-tool, so name-level filtering collapses “Recommended,” delegated entirely to the client Stripe Dashboard API logs (not agent-attributed) Key permissions at Stripe; tool selection in client config
Postgres (archived + Pro) (deep page) Connection string Archived: bypassable read-only transaction (unpatched SQLi in published build); Pro: --access-mode=restricted, but the default is unrestricted Whatever the DB role allows None None None Client config + DB role
Notion (hosted) (deep page) OAuth None: “MCP tools act with your full Notion permissions” None below the logged-in identity None None Enterprise-only: connection auditing, approved-app list The vendor; operators get nothing below identity
Atlassian (deep page) OAuth 2.1 / API tokens, user-permission mirroring None per connection (revoking write permission-groups = org-wide coarse version) Org-admin domain allowlist; IP allowlist evaluated per tool call; API-token path bypasses the domain check (separate toggle) Permission groups (read/write/search per product); grain stops at the group None Yes, per-call (tool name, action, user) in Atlassian admin audit logs Org admins, at connection level. The record is per-call, the rules aren’t
Sentry (deep page) Dual-token OAuth (hosted): client never holds the raw Sentry token Default posture: write skills (triage, project-management) disabled by default Org/project path constraints, enforced per request Skills gate which tools exist per grant (--skills / --disable-skills local) Grant-time consent only None operator-facing Grant-time skills at the vendor; fail-closed on stale grants
Slack (deep page) User-token OAuth behind workspace-admin approval; Marketplace/internal apps only Scope-level only (app without chat:write etc. exposes no write tools) Workspace + granted scopes; chat:write is one bit, no per-channel grain None Admin approves the connection, then nothing Yes, per-call (*_tool_called events with acting user), Enterprise Grid only, no arguments Workspace admins, at connection level
AWS API (deep page) IAM credential chain, the richest vendor-side floor in the set READ_OPERATIONS_ONLY=true (default false); fail-closed if its index can’t load IAM policies + condition keys (the real boundary) denyList / elicitList security-policy JSON (exact-match, no wildcards) Yes, the only native ask: REQUIRE_MUTATION_CONSENT elicitation, fail-closed without client support, deprecated by AWS’s managed successor Local rotating log (→ CloudWatch); CloudTrail = account-plane, principal-attributed, not agent-attributed Env vars + JSON on the agent’s machine; IAM at AWS
Linear (deep page) OAuth 2.1 + DCR (hosted); Okta-managed access on Enterprise Dedicated endpoint /mcp/readonly (server-side tool exposure); read scope blocks at the token None below the user; no team/project grain None (read vs read-write is the only selector) None None documented Endpoint choice in client config; enforcement at Linear
Zapier (deep page) OAuth (listed clients) or one-time connection token. Header recommended, token-in-URL fallback survives No; action selection is the lever Account-wide app restrictions (can’t be MCP-only); enterprise per-user quotas + vendor kill switch Manual mode: per-action + per-field locking (finest in the set); default dynamic mode: agent enables its own actions, two execute_* meta-tools None Yes, fullest per-call record in the set (instructions, field values, output); forensic, deletable with its subject Surface chosen at mcp.zapier.com; calls converge at Zapier with no policy at the point
Honeycomb (deep page) OAuth (preferred) or Management API key; only team owners can mint keys Scope-level: omit mcp:write and all 9 mutating tools are refused server-side; OAuth grants write automatically at consent Regional endpoints; key’s Environments access bounds write targets Read/write scope split only; no per-tool grain below it None None documented for MCP calls. AI conversations are captured as telemetry the agent itself can read back Key scopes at Honeycomb; OAuth consent per user
Context7 (deep page) None required; API key = rate tier, not scope Read-only by design: two tools, no writes exist n/a n/a n/a None Open library submission, no review step; the input is the attack surface
Chrome DevTools (deep page) None; the profile is the credential. Dedicated persistent profile by default, --autoConnect reaches the real Chrome behind one Allow dialog None; evaluate_script survives even --slim --blockedUrlPattern / --allowedUrlPattern, in-process guardrails Category flags (network/perf/emulation removable; input core + evaluate_script welded on) None (Chrome’s dialog approves the connection, once) None for the operator; usage telemetry to Google on by default Launch flags in client config; the strongest controls are Chrome’s, not the server’s

Sources: each server’s official docs and repos, linked from its deep page. Adoption context: the GitHub server is at ~30k stars with 23 toolsets. Playwright MCP ranks first in community usage surveys at ~36k stars. The filesystem reference server pulls ~233k npm downloads a week and Context7 ~554k. Honeycomb joined the table in August 2026. All figures are as of August 2026.

This table is the per-server follow-up to our March 2026 registry-wide scans, where the ecosystem-level numbers live: 74.9% of 8,216 servers document no audit capability, and 85% of paid-API proxies ship no rate limits.

A note on where our read comes from. We run both ends of this wire. ACP has its own MCP server (OAuth with dynamic client registration) and an MCP client that mounts external servers behind one chokepoint, with namespaced tool names, SSRF checks at registration and again when tools are built, and a per-call record. The first security review of our own client found the pattern this page describes: with no explicit rule, an attached server with a delete_database tool could be called by a background agent from day one, because the default mode only records. We found these gaps in our own client first.

What the table says

The best controls in the ecosystem are launch-time flags in a file the agent can often edit. GitHub’s read-only mode, Supabase’s project scoping, and Playwright’s capability gates are all real, and all set in the client’s MCP config at connection time. That is the wrong side of the trust boundary twice over. A flag is static, so it can’t tell one call from another. And the config is frequently agent-writable, since it lives in the workspace the agent edits. The filesystem server goes further: a connected client can replace the allowed-directories boundary at runtime, by design. A control the governed process can loosen is a preference.

Server-side enforcement is the standard to hold everything else to. Stripe’s restricted keys and Supabase’s Postgres-role read-only hold whatever the client config says. GitHub token scopes work similarly. Where the vendor enforces, the control is real. Where the local process enforces, it’s best-effort: Playwright’s docs label its origin filters “not a security boundary” (redirects walk straight through them), and GitHub says the same about lockdown mode.

Approvals are missing from the category, with one exception that is being retired. Of sixteen servers, one has a native per-call approval: the AWS API server’s REQUIRE_MUTATION_CONSENT. It holds every mutation behind an MCP elicitation prompt and fails closed when the client can’t render one. It’s well built, off by default, and deprecated by AWS’s own managed successor, whose migration guide says to use IAM policies instead.

Stripe moves actual money, and it recommends human confirmation but leaves it to the client. Everything else assumes the harness or something in between will ask. If the harness is in yolo mode and nothing sits in between, nothing asks. And the one vendor that built the ask is walking it back.

Audit exists in three rows, at three levels of detail, all in vendor silos. Atlassian records tool, action, and user. Slack records *_tool_called events behind Enterprise Grid. Zapier records the most (instructions, field values, and output) in a History tab that is deleted along with the server it describes. All three deserve credit. Each record is written after the call, nothing consults it before one, and it lives in one vendor’s console.

Now ask the question customers ask: prove exactly what every agent did across every connector last Tuesday, and why it was allowed. No combination of these rows can answer it.

Where every native model ends

Even if you grade every row generously, four gaps remain. They are structural, not missing features.

  1. The wrong party owns the controls. Server-side controls belong to the service’s admins. Client-side controls live in config the agent can reach. The operator who answers for what the agent did often holds neither.
  2. Every server is its own dialect. Read-only is a flag here, a Postgres role there, a key permission somewhere else, and absent entirely on five of the sixteen (six, counting Atlassian’s org-wide-only version). Every connector you add is another vocabulary, and a rule you wrote for one doesn’t exist for the rest.
  3. No server can see across servers. The GitHub private-repo leak and the Supabase lethal trifecta were each a sequence: read untrusted content on one surface, act on another. Every individual call looked fine to the server that received it. The dangerous thing was the sequence, and no per-server control can express a rule about it.
  4. Almost nothing asks, and almost nothing writes it down. One approval mechanism in sixteen servers, deprecated by its own vendor’s successor. Three vendor-console records in sixteen, none consulted before a call, and no record an operator can query across surfaces.

A layer that sits where the calls converge can cover these. That is what we build: policy, approvals, and the record live at a gateway, and a hook in each harness sends tool calls to it, including MCP tool calls where the harness exposes them to hooks (see the coverage matrix).

It has limits. ACP’s built-in safety floor reads shell commands only, so MCP calls are governed by the rules you write, not by the floor. In the default audit mode it records calls and holds nothing apart from the floor. And the hook is harness configuration, so pin it with managed settings on machines you don’t trust.

The native controls are getting better, and every deep page below starts with how to configure them well. None of them try to be one policy, one approval path, and one record across every server your agents touch. Each deep page says where the native controls end and where a layer like ours takes over.

Running coding agents? ACP records each tool call its hook sees and makes the dangerous shell commands (a force-push, destructive SQL, curl | sh) wait for you. One command, free up to 5 agents:

macOS · Linux · WSL
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
Windows · PowerShell
irm https://agenticcontrolplane.com/install.ps1 | iex

What the installer writes  ·  Getting started