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:
- Auth. How does the server know who’s calling, and is scoping enforced server-side or client-side?
- Read-only. Is there a real one, and at what layer does it hold?
- Scoping. Can you bound the blast radius to one project, one directory, one org?
- Tool filtering. Can you remove tools from the surface entirely?
- Approvals. Does anything natively require a human before a call fires?
- Audit. What record exists of what the agent did?
- 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-onlyenforces as a read-only Postgres role (not just a hidden tool),--project-reflimits the blast radius to one project, and--featuresprunes 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_CONSENTon 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/readonlyonly 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.
--autoConnectattaches to your real Chrome behind one Allow dialog, andevaluate_scriptsurvives 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.
- 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.
- 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.
- 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.
- 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:
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
irm https://agenticcontrolplane.com/install.ps1 | iex