MCP server

Everframe runs a hosted MCP server. Point a coding agent at it and the agent can look up a bug report, a crash’s error group, or a ticket on its own — read the evidence, follow the links between them, and answer “what is actually going on with this bug” without you copy-pasting anything.

It is read-only. There is no tool that files, edits, resolves, or comments on anything. See Security for why that matters more here than it usually does.

Your endpoint

The server lives at /mcp on the same origin you sign in to the dashboard at:

https://your-dashboard-origin.example/mcp

There is no separate MCP host, and the URL is different for every deployment — everframe.dev if you are on the hosted product, your own domain if you self-host. So take it from the address bar: whatever origin you open the dashboard at, add /mcp. If you are reading Settings → Agents right now, the origin in your address bar is the one you want.

Connect your agent

Every client below does the same two things: registers itself with Everframe and opens your browser so you can approve it. You never paste a token.

Claude Code

claude mcp add --transport http everframe https://your-dashboard-origin.example/mcp

Add --scope project to write it to .mcp.json and share it with your team, or --scope user to make it available in every project. Then run /mcp inside Claude Code to start the browser authorization.

Cursor

Create .cursor/mcp.json in your project (or ~/.cursor/mcp.json for all projects):

{
  "mcpServers": {
    "everframe": {
      "url": "https://your-dashboard-origin.example/mcp"
    }
  }
}

VS Code

Create .vscode/mcp.json. Note the top-level key is servers, not mcpServers:

{
  "servers": {
    "everframe": {
      "type": "http",
      "url": "https://your-dashboard-origin.example/mcp"
    }
  }
}

Zed

Add a context_servers entry to settings.json:

{
  "context_servers": {
    "everframe": {
      "url": "https://your-dashboard-origin.example/mcp"
    }
  }
}

With no Authorization header configured, Zed runs the standard MCP OAuth flow — which is what you want.

Any other client

Anything that speaks MCP over Streamable HTTP and supports OAuth works without special handling. Add a remote server at your /mcp URL; the client discovers everything else (RFC 9728 protected-resource metadata, dynamic client registration, authorization code + PKCE) by itself.

What happens when you connect

1. The client discovers that /mcp needs authorization, and where to get it.
2. Your browser opens — first to sign in, if you are not already, then to a consent screen: Connect <client name> to Everframe? It names the org the agent will read from and states plainly that it can only read.
3. Click Allow. The client gets a one-hour access token and a refresh token it renews with on its own, so you are not asked again.

The grant acts as you. It reaches exactly the projects you are a member of and nothing else, and that is re-checked on every call — not frozen at the moment you clicked Allow. Lose access to a project and the agent loses it in the same instant.

What the agent can see

Eight tools, each scoped to one project at a time:

resolve_link is the one to reach for first. Paste any dashboard link — a report, an error group, a ticket, with either a card number or a uuid — and the agent gets back exactly what the matching tool would return, without having to know any ids.

Every tool that names an id also names the tool that opens it, so an agent can walk search → get_error_group → get_report without being told how.

Images are fetched on demand, never dumped into the conversation. get_report and get_ticket list what is attached; the agent calls get_screenshot or get_ticket_attachment only when it actually needs to look.

Disconnect

Settings → Agents lists every agent you have connected, when it connected, and when it last called. Disconnect ends the whole grant — every access and refresh token issued from it dies at once, so the agent’s very next call fails rather than quietly working until an hour-old token runs out. It can reconnect later by going through Allow again.

If your client cannot do OAuth

A CI job or a client that only supports a static header can skip the browser flow and send an API token instead:

Authorization: Bearer evf_api_...

/mcp recognizes an API token by its evf_api_ prefix and accepts it alongside OAuth tokens — no separate endpoint, no flag. Unlike a grant, an API token acts as whatever project access it was created with rather than as a person, and it does not expire on its own. Revoke it from Settings → API tokens.

Security

Report descriptions, console output, network URLs, ticket text and crash messages are user-submitted content, not Everframe’s own words. Anyone who can press the bug-report button in your production app — or trigger a crash — controls that text, and these tools hand it straight to a developer’s coding agent. Prompt injection through report content is the expected case here, not a hypothetical.

Two things bound it:

• The server is read-only. No tool writes, resolves, or comments, so an injected instruction has nothing to act on even if an agent were to follow it.
• Untrusted content is marked. Every response carrying user-submitted text wraps it in an explicit boundary telling the agent that what is inside is data, never instructions. The boundary is hardened against forgery: content that contains something resembling a closing marker is neutralized before wrapping, so it cannot fake its own boundary.

Treat what an agent quotes back to you from a report the same way you would treat any other anonymous internet input, because that is what it is.

Limits

• 120 requests/minute per credential — double the plain API’s limit, because an agent session is chattier than a script.
• Inline images are capped at 2 MiB. Anything larger comes back as a signed URL rather than a truncated image.
• Text responses are capped, with an explicit note when something was cut. Never a silent truncation.
• Refresh tokens are sliding, not absolute: each use issues another good for 30 days. Access ends when you disconnect it, when replay is detected, or when it simply goes unused for 30 days.
• No write tools of any kind, and no session-replay tool yet — resolve_link recognizes a replay URL and tells you to open the dashboard.