Skip to content
Agentic Control Plane

The Sentry MCP server control model, explained

Sentry is the page in this series where we mostly grade up. The server is first-party and hosted at https://mcp.sentry.dev/mcp on Cloudflare Workers, with a local stdio fallback (@sentry/mcp-server). It works with Claude Code, Cursor, and VS Code for error triage.

It also ships a security document that states its threat model and enforcement points. Most servers make us rebuild the control model from their flags. Sentry wrote it down.

This page covers what ships, how each mechanism behaves, and where even this model ends. The project now lives in the getsentry/toolkit repo (the old sentry-mcp name redirects there). Sources: the repo, the security doc, and the skill registry source. We last checked the security doc in November 2026.

This page covers the server’s own controls. For the cross-server picture, see the MCP server controls comparison. For what a control layer adds on top, see the coverage matrix.

What’s at stake

The surface is read-heavy, and the reads are the point: issue details, event stack traces, breadcrumbs, replays, attachments, source context. A coding agent needs exactly that to fix a bug, and an exfiltration attempt wants exactly that too. Stack traces carry file paths, variable values, request data, and sometimes secrets your app leaked into an error.

The write side is narrower, with one sleeper: DSN creation. A DSN is the address an application sends its telemetry to. An agent that can mint DSNs (create_dsn, under the project-management skill) and also edits application code can repoint where events flow. That is a standing-configuration write, the same shape as Stripe’s webhook-endpoint creation.

The rest of the write surface (resolve, assign, and update issues; create projects and teams; create and delete uptime monitors) is recoverable but noisy. An agent that mass-resolves issues has blinded your on-call.

One note, because it circulated as scarier than it is. The June 2026 “agentjacking” discussion around monitoring MCP servers was about deployment defaults, not a code vulnerability. A third-party hardening guide from July 2026 puts it this way: “The attack vector isn’t in Sentry MCP’s code; it’s in the default configuration.” Read it as commentary on how people wire the server up, not as an incident in the server.

Dual-token OAuth: the client never holds the credential

No other server in the series does this. The hosted deployment runs two authorization layers. The MCP client authenticates to the MCP server’s own OAuth provider and receives a downstream MCP token. The server obtains the upstream Sentry token, stores it in the grant’s encrypted props, and, in the doc’s words, never sends it “directly to the MCP client.” On each request the worker validates the MCP token, rebuilds the session context, and makes the Sentry API call itself.

Compare the two strong ownership stories in this series. Stripe’s restricted keys put the scoping at the vendor: the client holds a credential, and the vendor enforces what it can do. Sentry keeps the credential itself away from the client. If the config file, the agent’s context, or the harness is compromised, there is no raw Sentry token there to steal.

Someone who gets the MCP token gets a wrapper bound to one grant’s skills and path constraints, not the org-scoped upstream credential. Refresh doesn’t widen it, because the doc says refresh reuses the stored grant props.

The one escape valve is opt-in: a Sentry-Bearer header mode, where the client supplies its own raw token and the worker stores nothing.

Skills: grant-time authorization done well

Tools are grouped into skills:

  • inspect: read-only issues, events, traces, replays, releases, monitors. Enabled by default.
  • seer: the AI debugger. Enabled by default.
  • triage: “Resolve, assign, and update issues.” Disabled by default.
  • project-management: “Create and modify projects, teams, DSNs, and uptime monitors.” Disabled by default.

The security doc calls the granted skills “the primary authorization mechanism for tool exposure.” Tools are registered only when a skill they declare is enabled, so ungranted tools don’t exist on the surface. That is the subtraction-not-denial property we credit GitHub’s toolsets for. The difference is that Sentry binds it to the OAuth grant instead of a launch flag in the agent’s config. The session’s grantedSkills ride in the token’s encrypted props and are checked at runtime.

Write skills defaulting to off is a chosen posture. The read path is the product, and writes are opt-in.

The doc also says a grantedScopes field remains on tokens for backward compatibility with older clients, and calls it transitional. Skills are the primary model. Sentry’s own scope checks upstream still apply underneath, because Sentry decides whether the user can perform the underlying API operation.

Path constraints, fail-closed grants, SSRF validation

Three mechanisms that would each be the headline on a lesser page:

  • Org and project path constraints, enforced per request. Connect at /mcp/{org} or /mcp/{org}/{project} and the constraint is stored in the grant and checked on every request. In the doc’s words, “a token minted for one scoped MCP URL cannot be reused against a broader path.” This is the closest thing in the series to a resource boundary that travels with the credential.
  • Fail-closed on stale grants. The doc says: “Stale or invalid grants fail closed: missing props, invalid skills, or rejected upstream tokens are revoked or require re-authentication.” Most servers can’t write that sentence.
  • SSRF validation on regionUrl. A tool argument that names a host invites SSRF. Sentry validates it: HTTPS is required, and only the base host is accepted unless the domain is in an explicit SENTRY_ALLOWED_REGION_DOMAINS allowlist. Most servers in this series don’t validate argument-supplied URLs at all.

Add a consent screen for first-time clients (remembered in signed cookies) and multi-tenant checks that verify org access upstream, and you have the most complete defensive checklist we’ve reviewed.

The local server: the strong design stays home

The stdio server (npx @sentry/mcp-server@latest --access-token=..., per the README) reverses the headline property. It takes a raw Sentry user auth token, with org read plus project, team, and event writes, via flag or SENTRY_ACCESS_TOKEN, on the same machine as the agent.

Skill filtering carries over: --skills=inspect,triage narrows, --disable-skills=seer subtracts, and ?skills= query parameters do the same on direct remote auth. But now it’s a launch flag in a config the agent can usually read and often write, and the credential it filters is the real one.

The dual-token design belongs to the hosted deployment, not to the server itself. If you have the choice, the hosted server with a project-scoped URL is the stronger setup.

What’s missing: the call-time layer

None of this is a flaw in what Sentry built. It is the limit of what grant-time design can express.

  • Skills gate which tools exist, not when they may fire. A grant with triage enabled has authorized every resolve, assignment, and issue update for the life of the grant. Nothing native tells the first update_issue from the five-hundredth, or a resolve on a test project from a resolve on the payments project’s top crash.
  • No approvals. The consent screen fires once, at grant time, for the person connecting the client. After that, no tool call can be held for a human. There is no native way to say “DSN creation needs a yes.”
  • No budgets or velocity limits. The security doc describes no per-session rate or count limits. A runaway loop resolving issues is processed call by call like any other client.
  • No operator-facing audit. Server-side diagnostic logging exists, with deliberate secret redaction. There is no queryable record of which tools an agent called, with what arguments, under which grant (the general MCP audit gap). The grant decides what can happen, and nothing records what did.

Where the native model ends

Sentry shows what a vendor taking the MCP-server side of the problem seriously looks like. The credential stays out of the client’s reach. Authorization is bound to the grant, not the config file. Resource constraints are checked on every request. Failures close instead of open. We grade it at the top of the comparison table.

The limit is one line: every decision this design makes, it makes at grant time. Which skills exist, which org is reachable, which client is approved are all settled before the session’s first tool call, and none is revisited during it. Even the best grant-time design in the series can’t say “this call, right now, needs a human,” and it writes nothing down.

What to do now:

  • Use the hosted server and scope the URL to one project.
  • Leave triage and project-management off until a task needs them.
  • Treat create_dsn as the write to watch.
  • Keep the local stdio server for self-hosted Sentry only.

Then add per-call policy, a hold on the writes, and a record of what ran. ACP does this with a hook in your agent’s harness that sends each tool call to a gateway, so the decision happens at call time, outside the server. The hook itself is harness configuration, so pin it with managed settings on machines you don’t trust.

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