← All guides

Give your AI agent eyes on production: uptime monitoring over MCP

Updated 8 August 2026 · by Cassian Wei · 4 min read

Agents ship code, deploy services, and run long unattended loops — and then have no idea whether any of it is still alive. An agent can curl a URL once, but it can't watch it every minute, alert a human at 3am, or notice that its own loop stopped running. That's what a monitoring service is for, and the Model Context Protocol is how an agent gets one as a first-class tool.

Why an agent needs an outside monitor

  • An agent can't see itself die. If the loop crashes, the process that would have noticed the crash is the one that's gone. Detection has to live outside — the same dead-man's-switch logic as cron jobs.
  • One-shot checks aren't monitoring. A URL that answered once at deploy time says nothing about an hour later. Continuous checks with alerting are a service, not a tool call.
  • Humans need to be in the alert path. When the site goes down at 3am, the fix may be an agent's job, but a human should hear about it through channels they actually watch — email, Slack, Discord, phone push.

What MCP gives you

MCP (Model Context Protocol) is an open standard that lets agent runtimes — Claude Desktop, Claude Code, Cursor, and a growing list of others — call external tools over JSON-RPC. Instead of teaching your agent to compose REST calls from docs, you point it at an MCP server and it discovers typed, described tools it can call directly.

Watchpup runs a native MCP server at https://watchpup.watchpup.workers.dev/mcp — Streamable HTTP, stateless, no OAuth dance: authentication is your API key in a header. It exposes 12 tools:

  • Look: check_url (is this URL up right now — works with no account; add kind:“mcp” to handshake-check another MCP server), list_monitors, get_monitor, get_status_page (read any public status page — also keyless), get_account.
  • Act: create_monitor (http, tcp, tls-expiry, domain-expiry, dns, heartbeat — and mcp, see below), update_monitor (incl. pause/resume), delete_monitor.
  • Respond: list_incidents, ack_incident ("someone is on it" — pauses reminder alerts), add_incident_note (postmortems, published to your status page), list_channels.

Monitoring MCP servers themselves

It cuts both ways: if you run an MCP server, Watchpup has a monitor kind that speaks the protocol back at it. A {"kind":"mcp"} monitor POSTs a real JSON-RPC initialize to your server's streamable-HTTP endpoint every minute and only counts a valid initialize reply as up — a 200 from a dead reverse proxy, an error page or a half-broken deploy doesn't pass. It handles both JSON and SSE reply shapes, closes any session the handshake opens, takes an Authorization header for protected servers, and records the server's self-reported name and protocol version. As far as we know no other uptime service speaks MCP at all — the usual advice is "point an HTTP check at it", which can't tell a working protocol endpoint from a reverse proxy answering 200 to everything. Docs.

See it working right now: we run a public MCP server status page — ten popular public MCP servers (Cloudflare Docs, DeepWiki, Context7, Microsoft Learn, Hugging Face, GitMCP and more) checked with real initialize handshakes every 5 minutes. It's an ordinary Watchpup status page; yours would look the same.

Want a one-off answer first? The zero-signup instant check runs the same handshake against any public MCP endpoint right now — no account, shareable result URL: curl 'https://watchpup.watchpup.workers.dev/api/check?kind=mcp&url=https://your-server/mcp'.

Connect it (one config block)

# Claude Code
claude mcp add --transport http watchpup https://watchpup.watchpup.workers.dev/mcp \
  --header "Authorization: Bearer wp_YOUR_KEY"

# Cursor / Claude Desktop / generic mcpServers config
{
  "mcpServers": {
    "watchpup": {
      "url": "https://watchpup.watchpup.workers.dev/mcp",
      "headers": { "Authorization": "Bearer wp_YOUR_KEY" }
    }
  }
}

No key yet? check_url and get_status_page work anyway (30/hour per IP), and every other tool answers with signup instructions — one POST /api/signup — so an agent can bootstrap its own account end to end without a human in the loop.

Patterns worth stealing

  • Heartbeat your agent loop. Create a heartbeat monitor for the agent itself and have it ping after each successful cycle. Loop dies → humans get alerted. This one closes the "who watches the watcher" hole.
  • Monitor what you deploy, at deploy time. End every deploy task with create_monitor on the new endpoint. Monitoring that's part of the deploy step never gets forgotten.
  • Use a read-only key for investigation agents. A read-only API key lets an agent read monitors and incidents but not delete anything — MCP honors the same key rules as the REST API.
  • Ack and annotate through the agent. When your agent starts working an incident, ack_incident silences the reminder spam; when it's fixed, add_incident_note writes the postmortem your status-page visitors see.

Safety notes

Every MCP tool call goes through the exact same validation, rate limits and ownership checks as the REST API — an agent can't do anything your key can't. Mutations are tagged mcp in your account's activity log, so you can always audit what the agent changed. delete_monitor is flagged destructive in its tool annotations, so well-behaved runtimes ask a human first.

Prefer raw HTTP? The same server speaks plain JSON-RPC to curl, and everything MCP does is also on the REST API (OpenAPI spec, llms.txt quickstart). Full details: MCP docs.

Watchpup is free uptime & cron monitoring — 1-minute checks, heartbeats, TLS/domain expiry, status pages, alerts everywhere. Sign up, try the live demo, or read more guides.