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.
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 now | get_status (every page, failing probes with their last error, open incidents), list_probes |
| Put a service on a status page | create_status_page, create_probe |
| Set up monitoring for a new domain | scan_domain (proposes probes, creates nothing), apply_setup |
| Tell customers about an outage, then resolve it | open_incident, post_incident_update |
| Find the probable cause (Pro and Business) | analyze_incident |
| Review or tidy up | list_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.