AgentStatus
We tested every public MCP server we could find. Calling is solved. Delivery is not.
Read the reportYour agent works. Your model provider is up. Your prompt evals pass. Your dashboard is green.
Then a customer pings you: "The 'lookup_order' tool keeps failing."
You check the agent endpoint, 200 OK. You check the LLM API, green. You check your retrieval store, fine. Two hours later you discover the problem wasn't in any of those layers. The Model Context Protocol (MCP) server that exposes your tools to the agent had silently changed transports during a deploy. The agent was reaching it. The handshake was failing. Every tool call was returning an error wrapped in a perfectly valid agent response.
This is the layer almost no monitoring stack covers, and the one most likely to break next.
MCP is the protocol that exposes tools, resources, and prompts to LLM agents. In 2025 it was a curiosity. By mid-2026 it's everywhere, Claude Desktop, Cursor, agentic IDEs, internal LLM gateways, and most production agent stacks now sit on top of one or more MCP servers.
Three properties make MCP failures uniquely invisible to traditional monitoring:
tools/list, resources/list, prompts/list, plus per-tool tools/call. None of those show up in URL-level uptime checks.If you're monitoring MCP servers the way you monitor REST APIs, you're not monitoring them at all.
What happens: A server upgrade switches from HTTP+JSON-RPC to SSE (Server-Sent Events) or Streamable HTTP. Old clients stop working. New clients work. Your reachability check still passes because something responds at the URL.
Why it happens:
Real example: A team deployed a routine MCP server upgrade. The server now responded with Content-Type: text/event-stream. Their agent's SDK didn't support SSE. Tool calls hung for 30 seconds, then timed out, then the agent returned, "I'm having trouble accessing your account information right now." Customers thought it was an outage. The dashboard was green for 11 hours.
How to prevent it:
Content-Type is what your client supports.transport_supported = false as a first-class verdict, not as "degraded latency."In the Agent Status validate path, this is the difference between:
result['error'] = 'transport_not_supported: sse'
result['transport_type'] = 'sse'
result['transport_supported'] = Falseand the silent-200 your dashboard would otherwise report.
What happens: A tool gets renamed, removed, or temporarily disabled in the MCP server's tools/list response. The agent now silently can't access it. Responses degrade. No HTTP error fires.
Why it happens:
Real example: A travel agent depended on search_flights. A backend team renamed it to flights_search. Both teams reviewed the diff. Neither noticed the agent's system prompt still said search_flights. For four days the agent told customers, "I can help with hotels but not flights right now." Bookings dropped 18%. Nobody alerted on it.
How to prevent it:
tools/call per critical tool, discovery alone isn't enough.A real validate should answer three distinct questions:
| Question | Validation |
|---|---|
| Is the server reachable? | tools/list returns 200 with valid JSON-RPC |
| Are the right tools present? | Diff result.tools against expected set |
| Do the tools actually work? | tools/call with a known input then assert known output |
A tool that exists in the listing but errors on every call is the most expensive kind of broken: it looks healthy and acts dead.
What happens: tools/list returns in 800ms instead of 80ms. The agent's first turn now takes 4 seconds longer because every cold session pays the discovery tax. Users churn. No threshold trips because nobody alerted on discovery latency.
Why it happens:
Real example: A code-assistant team added 60 new MCP tools to their server in Q1. By Q2, the IDE plugin's "first reply" latency had crept from 1.2s to 4.7s. Eng blamed the model. The model wasn't the problem, discovery was. They fixed it by paginating tool listings and caching at the gateway.
How to prevent it:
latency_ms on tools/list, resources/list, prompts/list as separate SLAs.What happens: The MCP server requires a token. Your agent has the token. Your monitoring doesn't. Validations pass anonymously, returning a smaller (or empty) tool catalog. The "agent" experience is completely different from what you measure.
Why it happens:
Real example: A customer-support agent could call refund_order only when authenticated. The team's monitoring was anonymous. For six months, monitoring proved the server was up, but it was up as a stranger. The first time they actually tested the authenticated path, three tools had been broken for weeks.
How to prevent it:
What happens: Your MCP server isn't direct, it's behind a hosted gateway (Smithery, an internal proxy, or a multi-tenant connector). The gateway's connection state can be pending, failed, expired, or degraded independent of your server's actual health.
Why it happens:
Real example: A team using a popular MCP hosting provider had perfect server-side metrics. The provider's connection layer was returning connection_state: error on 12% of calls during a peak window. Server logs showed nothing because the calls never reached the server. They only caught it by validating through the gateway with the same flow real agents used.
How to prevent it:
Smithery Connect PUT failed: HTTP <code> and connection state: error as actionable verdicts, not noise.A complete MCP validate answers six questions on every cycle:
tools/list succeed?tools/call per critical tool return the expected output for a known input?A failure of any one is a customer-visible defect, even when the URL still returns 200.
This is exactly the validate surface Agent Status runs against your MCP servers. The verdict isn't UP/DOWN based on HTTP. It's:
UP, reachable, transport supported, all tool validations passDEGRADED (mcp_tool_fail), reachable but one or more tool calls failDEGRADED (mcp_transport_unsupported: <type>), server changed transports out from under your clientDOWN (mcp_unreachable), handshake failed entirelyEach verdict is attributable, alertable, and actionable.
Different MCP servers need different validate depths. We use four:
| Profile | What it does | When to use |
|---|---|---|
health_only | tools/list only | Public servers, cheap continuous checks |
full_discovery | tools + resources + prompts | Servers exposing more than just tools |
tool_contract | Discovery + named tools/call validations | Production servers with known critical tools |
full_validation | Discovery + auto-generated validations from listings | Servers under active development |
Most teams default to health_only, which is roughly equivalent to a TCP ping. It's better than nothing, and it misses everything that matters.
If you only do three things this week:
Snapshot tools/list once a day. Diff against yesterday. Alert on any change you didn't ship.
Pick the single MCP tool whose failure would hurt customers most. Call it on every validate cycle with a known input. Assert known output. This catches 80% of "broken in a way nobody notices" cases.
If your agent calls MCP through a gateway, validate through the gateway. If it authenticates, your validate authenticates. The validate's job is to be indistinguishable from the agent, anything else is theater.
Your MCP server is one renamed tool away from a customer-visible regression.
When MCP breaks, your agent doesn't fail — it lies. Traditional uptime monitoring catches none of it. You need monitoring designed for the protocol, not the URL it lives behind. The only question is whether you'll find out from a validate or a support ticket.