← All guides

Guide · AI agents

Run your status page and incidents from your AI assistant with MCP

Your status page usually lives in a browser tab you open only when something is already on fire. With an MCP server, the assistant you already code with can do the routine parts — put a new service on the page, say what's down, draft and post the incident updates — while you stay in the terminal. This guide covers what that looks like, how to connect it, and the guardrails that matter when a model can write to a page your customers read.

Published 2026-11-04 · ~7 min read · By · AI-assisted

Why put a status page behind MCP?

The Model Context Protocol is an open standard for giving an AI assistant tools: a server describes what it can do, and any client that speaks the protocol — Claude Code, Cursor, VS Code and a growing list of others — can call those tools when you ask in plain words. A remote server speaks it over Streamable HTTP, so there is nothing to install on your machine.

Two moments make a status page a good fit. The first is shipping: the person who just deployed api.example.com is the one who knows it exists, and they are in a terminal, not in your monitoring dashboard. If adding it to the status page is one sentence to the assistant they are already talking to, it gets done; if it is a ticket for later, it often doesn't. The second is an outage: the first public update is late at most companies because writing it competes with fixing the problem. An assistant that can read what's failing and draft the update for you to approve takes that step off the critical path.

What the StatusPulse MCP server can do

StatusPulse runs an MCP server at https://statuspulse.ai/mcp, on every plan. It exposes twelve tools; the assistant picks which ones to call from what you ask:

You ask it to…Tools it calls
Tell you what's down right nowget_status (every page, failing probes with their last error, open incidents), list_probes
Put a service on a status pagecreate_status_page, create_probe
Set up monitoring for a new domainscan_domain (proposes probes, creates nothing), apply_setup
Tell customers about an outage, then resolve itopen_incident, post_incident_update
Find the probable cause (Pro and Business)analyze_incident
Review or tidy uplist_status_pages, list_incidents, delete_probe

create_probe handles seven probe types: HTTP, ping, TCP port, SSL certificate, DNS record, domain expiry and heartbeat. For a heartbeat it returns the URL your cron job has to call, and the assistant tells you where to put it. Database, gRPC, WebSocket and email probes need credentials or protocol options, so they stay in the dashboard. The same tools are also a REST API under /agent/v1, and the reference an agent reads is at statuspulse.ai/agent.

Connecting Claude Code, Cursor or VS Code

The server authenticates with an agent token (it starts with sp_agent_). Only a workspace Owner or Admin can create one. The shortest way is the setup prompt: under Pages → API tokens, Create setup prompt makes a token and wraps it in a prompt you paste into your assistant. It adds the server to its own user-level settings, checks the connection and offers to set up your monitoring. If you'd rather do it by hand, these are the formats each client documents for a remote server with a header.

Claude Code (docs):

claude mcp add --transport http --scope user statuspulse \
  https://statuspulse.ai/mcp \
  --header "Authorization: Bearer sp_agent_…"

Cursor (docs), in ~/.cursor/mcp.json:

{
  "mcpServers": {
    "statuspulse": {
      "url": "https://statuspulse.ai/mcp",
      "headers": { "Authorization": "Bearer sp_agent_…" }
    }
  }
}

VS Code with GitHub Copilot (docs), in the user mcp.json (command MCP: Open User Configuration):

{
  "servers": {
    "statuspulse": {
      "type": "http",
      "url": "https://statuspulse.ai/mcp",
      "headers": { "Authorization": "Bearer sp_agent_…" }
    }
  }
}

Use the user-level configuration, not a file inside a repository: the token is a password. A client that can only run local servers can reach it through the mcp-remote bridge. Once connected, a good first question is “what's down right now?” — it exercises get_status and shows you the workspace the token belongs to.

Three workflows worth handing over

1. Ship a service, put it on the page

“We're launching api.example.com today — put its health endpoint on our status page and watch the certificate.” The assistant calls create_probe twice: an HTTP probe on /health, public, and an SSL probe, which belongs off the public page (the tool's own guidance says so). For a whole new domain, ask it to run the Setup Agent instead: scan_domain looks at public DNS, certificates, the usual subdomains and health endpoints, the assistant shows you the proposal, and apply_setup creates only what you keep.

2. An outage, from first update to resolved

“Checkout is throwing errors — tell customers we're on it.” The assistant calls get_status, sees which probes are failing and with what error, drafts a title, a severity and a first update, and asks you before it calls open_incident: the incident goes on the public page and your subscribers are notified. As you learn more, “we've found it, it's the payment provider” becomes a post_incident_update moving the incident to Identified, and “fixed, close it” resolves it. On Pro and Business, “what's the likely cause?” calls analyze_incident, the incident copilot, which ranks up to three causes with the probe evidence for each.

3. The morning check

“Anything down, and any incidents still open?” is one get_status call. Because it returns the last error of every failing probe, the follow-up — “is the certificate on app about to expire?”, “which probes haven't been green this week?” — usually needs no dashboard at all.

Guardrails: what stops it going wrong

A model that can post to a page your customers read needs limits that don't depend on the model behaving. These are the ones StatusPulse enforces on the server:

  • One workspace, Editor rights. An agent token acts in the workspace it was created in, with the rights of an Editor: it can't change billing, the team, single sign-on or the workspace itself.
  • Your plan's limits. Probe counts, probe types, check intervals and the AI quotas apply exactly as in the dashboard; a call past a limit is refused, or stops at the limit, and says why.
  • Every change is audited. Each write lands in the audit log under the token's name, so “who opened this incident?” has an answer.
  • Revocable at once. Revoking the token under Pages → API tokens stops it on the next request. The read-only API tokens (sp_live_) don't work here, and agent tokens don't work on the public read API.
  • Rate-limited. 120 requests a minute per token and address, which is plenty for a person and a ceiling for a loop.

On top of that, the tools tell the assistant to show you the text and wait for your yes before it opens an incident, posts an update or deletes a probe. That is guidance to the model, not a server-side lock, so keep your client's own approval prompt switched on for those tools — Claude Code, Cursor and VS Code all ask before running a tool unless you tell them not to.

What it can't do

The agent API covers pages, probes and incidents. It doesn't delete status pages, edit branding or custom domains, manage subscribers, watchers or on-call schedules, schedule maintenance, or write post-mortems; those stay in the dashboard, where the person changing them is signed in. It also can't create the four probe types that need credentials or protocol options (see above).

Wrap-up

The case for running a status page from an AI assistant isn't novelty; it's latency. New services reach the page the day they ship, because adding them costs one sentence. The first public update goes out minutes earlier, because the draft is waiting for your approval instead of your attention. Keep the token at user level, keep your client's approval prompts on for anything that notifies customers, and let the audit log tell you what it did.

Connect your assistant to StatusPulse

The MCP server is on every plan, including Free: 10 probes.

AI agents for monitoring and incidents Probe catalogue