Why 52% of MCP Servers Die Within 90 Days
10,000+ servers. 97 million SDK downloads per month. 900% year-over-year growth. The Model Context Protocol is the fastest-adopted AI standard in history. But more than half of the servers built on it are already dead. Here's what the data shows — and what it means for anyone building AI agents.
52%
MCP servers abandoned
97M
SDK downloads/month
17%
production-ready
6
median lifetime commits
1. The adoption is real: MCP by the numbers
The Model Context Protocol, launched by Anthropic in November 2024 and donated to the Linux Foundation in December 2025, has become the de facto standard for how AI agents interact with tools and data. Every major AI client now supports it natively.
| Metric | Value | Source |
|---|---|---|
| Active public MCP servers | 10,000+ | Anthropic, April 2026 |
| Monthly SDK downloads | 97M+ | Anthropic, April 2026 |
| Year-over-year growth | 900% | Synvestable |
| GitHub repos (mcp-server topic) | 15,926 | GitHub Search, May 2026 |
| Fortune 500 adoption | 28% | Synvestable |
| Official registry records | 9,652 | Registry API, May 2026 |
| AAIF governance members | 25+ | Linux Foundation |
Platinum members of the Agentic AI Foundation governing MCP include Amazon, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI. Native MCP support ships in Claude Desktop, ChatGPT, Gemini, Cursor, VS Code, Windsurf, and every major AI coding tool.
This is not a niche protocol. MCP is infrastructure — with adoption curves faster than React or gRPC ever achieved. The question is no longer whether MCP matters. The question is why so many servers built on it fail.
2. The quality crisis: 66% have critical code smells
An arXiv study of MCP server code quality found systemic problems across the ecosystem:
66%
critical or blocker-level code smells
14.4%
critical or blocker-level bugs
38.7%
require no authentication
A separate audit of 201 popular MCP servers by DEV Community found that even high-star servers perform poorly on efficiency and correctness. Grafana's MCP server (2,600+ GitHub stars) scored an F grade — 21.9 out of 100. AWS's MCP monorepo (8,500+ stars) scored 52.2, with chaotic naming and deprecated tools still in the schema.
74% of the AgentRank indexscores in the “Avoid” tier (0–39 out of 100). Only one in six servers meets a reasonable production bar.
The pattern mirrors npm in 2014: explosive growth, wildly inconsistent quality, a small number of essential packages rising to dominance while thousands languish. The difference is that MCP servers are not passive libraries — they are live services that AI agents call in real time. A broken MCP server doesn't just fail silently. It produces wrong answers, wasted tokens, and degraded user experiences.
Is your MCP server alive or dying?
FetchLens tracks every tool call, content gap, and error pattern across your MCP server. Know what's working before your users tell you what isn't.
Free AI readiness scan3. The dead-beat pattern: why servers stop working
RapidClaw audited 1,847 publicly listed MCP servers. The results confirm what builders already suspect: MCP servers become static sites.
| Status | % of servers | Description |
|---|---|---|
| Dead / Abandoned | 52% | No commits in 90+ days, broken builds, unpatched CVEs, 5xx endpoints |
| Lightly maintained | 31% | Some activity but not production-grade |
| Production-ready | 17% | Active maintenance, typed schemas, error handling, monitoring |
The median MCP server has 6 commits in its entire lifetime and was last touched 142 days ago. These are not works in progress. They are abandoned endpoints that AI agents still try to call.
Stress testing by DigitalApplied across 100 production servers (12,000 trials) found a massive reliability gap:
95%+
Top decile pass rate
71%
Median pass rate
38%
Bottom decile pass rate
The gap is structural. Top-decile servers share three traits: typed schemas, idempotent tool handlers, and explicit cancellation handling. Bottom-decile servers almost never have any of these. But even the top decile lacks something critical: lifecycle tooling— analytics on what's being called, content freshness tracking, and feedback loops that tell you when queries are returning bad results.
4. Context window bloat: the silent killer
MCP servers are eager-loaded — every tool definition gets dumped into the AI client's context window at session start, whether you use those tools or not.
| MCP Server | Tools loaded | Tokens consumed |
|---|---|---|
| GitLab | 78 | 58,000 |
| GitHub | 27 | ~12,000 |
| Cloudflare Radar | 66 | 21,723 |
| Playwright | 21 | ~8,500 |
One developer measured 81,986 tokens consumed across their MCP servers before asking a single question. Nearly 80% of pre-conversation overhead is tool definition schemas.
MCP operations cost 10–32x more tokens than CLI equivalents. A simple git status via CLI uses minimal tokens. Via MCP: schema definition + call overhead + response parsing = significantly more.
Lazy loading and dynamic tool discovery can achieve a 160x token reduction(Speakeasy benchmark). But it isn't standardized, and most servers don't implement it. This is a solvable problem — but it requires monitoring to know which tools are actually used and which are consuming budget for nothing.
Stop flying blind. See your MCP server's real health.
FetchLens gives you analytics, content freshness alerts, and tool-call monitoring for MCP servers — the lifecycle layer that keeps the 52% from becoming your server.
5. The missing logic layer: what separates survivors from the dead
The MCP protocol works. Hosting is commodity. Auth has multiple solutions. So why do 52% of servers die?
Because the protocol is plumbing, not intelligence. An MCP server without a logic layer is a JSON-RPC endpoint that answers the same way forever — a static site with a fancier transport. The servers that survive have something the dead ones don't: a content layer that stays fresh, tools that work together as a system, and feedback loops that improve the server over time.
What infrastructure players solve (commoditized)
What nobody solves yet (the logic layer)
We built an MCP-powered LMS from scratch — turning a static website into a fully agentic learning platform with personalized progress tracking, step validation, and an embeddable AI chat widget. It took 6,800 lines of code and 6 weeks of full-time work.
Infrastructure (protocol, auth, database, deployment) accounted for about 40% of that effort. The other 60% — the part that made the server actually useful — was the logic layer:
- Content curation — scraping a site, structuring it for LLM consumption, failing, restructuring, adding more content, redeploying. The content files look simple in final form but represent dozens of failed iterations.
- Tool orchestration — making six independent tools share state through a common database, merging progress across devices, injecting user context into LLM prompts, building state machines for progression.
- Validation rubrics— defining what “done” means for each step, authoring pass/fail criteria, tuning an LLM judge at temperature 0.0, bridging deterministic CLI checks with server-side LLM evaluation.
Every team building a production MCP server repeats this work. The patterns are the same: take content and make it AI-queryable, add tools that do things, wire up identity, build surfaces, connect side effects. The logic layer is 60% of the effort but 100% of what keeps a server alive.
6. Who is building MCP servers (and why half have never built an API)
An analysis of 1,400 MCP servers by Bloomberry revealed a counterintuitive builder profile:
| Finding | Implication |
|---|---|
| 81% have fewer than 200 employees | Small teams, limited DevOps resources |
| 50% have no public-facing API | MCP is their first integration surface |
| 86% have no Zapier integration | Not integration-savvy teams |
| 70% are B2B companies | Building for enterprise or developer users |
MCP is creating a new class of integrators — teams with proprietary internal tooling that can finally expose functionality to AI clients without standing up full API infrastructure. For half of them, this is their first public-facing integration.
These builders need more than an SDK. They need higher-level abstractions that handle content management, analytics, and maintenance — not more YAML configuration files. Without lifecycle tooling, these first-time API builders are the most likely to produce servers that join the 52%.
7. What this means for teams building MCP servers today
Monitor tool call patterns from day one.
Most MCP servers have zero visibility into which tools are called, how often, and what fails. Without this data, you can't know what's working. FetchLens provides this out of the box.
Keep your content layer fresh.
An MCP server's content is its intelligence. If it goes stale — outdated FAQs, missing new features, dead links — the LLM produces wrong answers and users leave. Automate content sync or set up freshness alerts.
Tie your tools together with shared state.
Independent tools produce independent results. If your “ask” tool doesn't know what your “do” tool just completed, you have six dead endpoints, not a system. Share session state and user context across tools.
Implement lazy loading to manage context budget.
Don't dump all tool schemas into the context window at once. Dynamic discovery can achieve 160x token reduction. Only load what the user's current intent requires.
Track AI readiness on your origin site.
AI crawlers spend one third of their fetches on 404 pages. They can't follow JavaScript redirects. If your MCP server ingests content from a site that AI agents can't read, the whole chain breaks. Run a free AI readiness scan to check.
Stop flying blind. See your MCP server's real health.
FetchLens gives you analytics, content freshness alerts, and tool-call monitoring for MCP servers — the lifecycle layer that keeps the 52% from becoming your server.
Frequently asked questions
What percentage of MCP servers are abandoned?
52% of publicly listed MCP servers show no commits in 90+ days, have broken builds, or return 5xx errors. The median MCP server has just 6 commits in its lifetime and was last touched 142 days ago.
Why do MCP servers stop working?
MCP servers die because they lack a logic layer — content curation, tool orchestration, validation systems, and lifecycle maintenance. The protocol itself works fine. What kills servers is stale content, disconnected tools, no feedback on what queries fail, and no analytics on usage patterns.
How many MCP servers exist in 2026?
As of mid-2026, there are 10,000+ active public MCP servers (Anthropic), 14,000+ including unofficial ones, 9,652 in the official registry, and 15,926 GitHub repos with the mcp-server topic. Monthly SDK downloads exceed 97 million.
What is the Model Context Protocol (MCP)?
MCP is an open standard for AI agents to interact with tools and data sources. Governed by the Linux Foundation's Agentic AI Foundation, it is supported by every major AI client including Claude, ChatGPT, Gemini, Cursor, and VS Code. MCP uses JSON-RPC 2.0 over HTTP.
How can I monitor my MCP server?
FetchLens provides analytics and monitoring for MCP servers — tracking tool call volume, error rates, content freshness, and user engagement. You can also use OpenTelemetry spans per tool invocation for latency and error tracking. Start with a free scan to check your site's AI readiness.
What makes a production-ready MCP server?
Production-ready MCP servers (only 17% of the ecosystem) share key traits: typed schemas, idempotent tool handlers, explicit cancellation handling, content that stays synced with source data, analytics on usage patterns, and orchestration logic that ties tools into coherent workflows rather than isolated endpoints.
Is MCP replacing REST APIs?
Not directly. MCP serves a different purpose — it's a protocol for AI agents to interact with tools, not a general-purpose API standard. However, for many teams, MCP is their first public integration surface. 50% of MCP builders had no public API before building their MCP server. Gartner projects 75% of API gateway vendors will have MCP features by end of 2026.
About this research
This analysis synthesizes publicly available data from Anthropic, Bloomberry (1,400 servers), RapidClaw (1,847 servers), DigitalApplied (100 servers, 12,000 trials), the arXiv MCP code quality study, DEV Community (201 servers), AgentRank, Synvestable, Vercel, Cloudflare, and the Linux Foundation. All numbers are sourced from research published between January and June 2026. FetchLens is an AI agent traffic intelligence platform built by AIEDX Private Limited.