MCP Ecosystem 2026: What the Adoption Numbers Actually Show

Model Context Protocol started as an internal Anthropic project in late 2024. It is now governed by the Linux Foundation and shipped by every major AI provider. If you are deciding whether to build on it, that trajectory matters more than any single download figure.

It matters because the figures in circulation are messy. The number you have most likely seen quoted for MCP — 97 million monthly SDK downloads — is real, but it is routinely misdated. It comes from the December 9, 2025 announcement that MCP joined the Agentic AI Foundation, not from spring 2026, and it has since been overtaken. The July 28, 2026 specification post puts Tier 1 SDKs at "close to half-a-billion downloads a month," with the TypeScript and Python SDKs each past a billion downloads in total.

What Effloow added: a claim-to-source matrix#

Rather than repeat the growth curve that circulates in secondary coverage, we checked each widely-quoted MCP statistic against a primary source. Several could not be traced to one. That distinction is the useful artifact here, because an uncited number is not a small problem when you are using it to justify an architecture decision.

The unverified rows were in an earlier version of this article. We removed them rather than keep them with a hedge, and the sections below reflect that.

MCP earned the adoption regardless, by solving a problem the industry had but had not coordinated around: the N × M integration burden. Before MCP, connecting models to tools meant a separate connector per model-tool pair. Five models against ten tools meant fifty integrations. MCP collapses that to fifteen, one implementation per side.

This article traces the adoption milestones that are documented, which servers developers actually install, and where the protocol is heading — with the sourcing shown so you can check it.

For MCP's sibling project under the same foundation, see our review of goose, Block's open-source agent framework. For what happens once agents start calling tools at volume, see our measured work on tool-call token cost.

The Problem MCP Solved#

Before understanding why MCP grew this fast, you need to understand the pain it removed.

Every LLM application that does anything useful needs to connect to the outside world. It needs to read files, query databases, call APIs, interact with services. Before MCP, the standard approach was function calling — each model provider defined their own schema for tools, their own way of passing context, their own format for responses. Claude used one schema. GPT-4 used another. Gemini had its own approach.

This created a compounding tax on developers. Every new model you wanted to support required rewriting your tool layer. Every new tool you built needed a separate implementation per model. Switching model providers meant rebuilding integrations from scratch.

The enterprise cost was even worse. Large organizations might have hundreds of internal tools and dozens of AI deployments. The maintenance burden was enormous, and the security surface area was invisible — nobody had a clear picture of what data each AI could access.

MCP addressed all of this with a single open specification:

• One protocol — JSON-RPC 2.0 over stdio (local) or Streamable HTTP (remote)
• One server spec — build a tool once, it works with any MCP-compatible model
• One client spec — implement MCP once in your model layer, connect to any tool
• Explicit permissions — what each server can access is defined in the manifest, not buried in code

The result was the "USB-C for AI" — a connector standard that made the integration problem boring in the best possible way.

The Adoption Timeline: Month by Month#

The growth of MCP is best understood as a series of inflection points, each triggered by a major player joining the ecosystem. The dates and events below are documented; the download totals between the two published data points are not, so we have left them out.

November 2024: Launch#

Anthropic published the MCP specification and open-sourced official Python and TypeScript SDKs. Claude Desktop became the first MCP client.

The developer community's reaction was cautious but interested. The protocol made sense, the implementations were clean, but it was a single vendor's project. Most developers took a wait-and-see approach.

December 2024 – February 2025: Community Build-Out#

Early adopters started building servers. The GitHub repository for the official MCP servers launched with integrations for filesystem access, web search, GitHub, Slack, PostgreSQL, and a handful of other common tools. Third-party servers began appearing on GitHub.

Adoption in this window came mostly from hobbyists and early-stage AI startups experimenting with agentic workflows.

March 2025: OpenAI Joins#

The inflection point the ecosystem had been waiting for. On March 26, 2025, Sam Altman announced MCP support in the OpenAI Agents SDK, with the ChatGPT desktop app and Responses API to follow. Google DeepMind confirmed Gemini support the following month.

For developers, this was the signal that MCP was not going to be a proprietary Anthropic standard. If both Claude and ChatGPT supported it, building on MCP became a safe bet. The third-party server ecosystem accelerated sharply.

April – June 2025: The IDE Wave#

Cursor, Windsurf, and VS Code all shipped MCP client support within a few weeks of each other. JetBrains IDEs followed in May. For the first time, developers could use MCP servers directly from their editor — not just from chat applications.

This opened a new use case: using MCP as the integration layer for AI coding assistants. Instead of each IDE building its own database connector, GitHub integration, or documentation fetcher, they could all share the growing library of MCP servers.

July 2025: Microsoft and Copilot Studio#

Microsoft integrated MCP into Copilot Studio, giving enterprise developers a supported path to connect Microsoft 365, Azure services, and Dynamics 365 to AI workflows via MCP. Azure OpenAI also added native MCP client support.

This was the moment MCP became an enterprise conversation rather than just a developer one. IT departments that had been building custom integrations for Copilot started migrating to the MCP standard. Remote MCP server deployments began growing sharply — organizations wanted to run servers in their cloud infrastructure, not on developer laptops.

November 2025: AWS Joins#

AWS added MCP support across Bedrock, expanding the addressable market dramatically. Any organization using AWS for AI workloads could now connect Bedrock models to MCP servers without additional middleware.

More significantly, AWS's support brought MCP into environments with strict compliance requirements — healthcare, financial services, government. These sectors had been watching MCP's development carefully but waiting for cloud provider endorsement before committing. AWS's participation was that endorsement.

December 2025: Linux Foundation Governance#

Anthropic, Block, and OpenAI co-founded the Agentic AI Foundation (AAIF) under the Linux Foundation, transferring MCP governance to a neutral body. This addressed one of the last hesitations enterprise procurement teams had about adopting MCP: the risk of a single vendor controlling the specification.

With Linux Foundation governance, MCP joined the same class of infrastructure protocols as HTTP, OAuth, and gRPC — open standards with no single commercial owner.

December 2025: The 97 Million Figure, Correctly Dated#

This is the number most coverage attributes to spring 2026. It was published on December 9, 2025, in the AAIF announcement, which reported "over 97 million monthly SDK downloads, 10,000 active servers and first-class client support across major AI platforms like ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot, Visual Studio Code and many more."

Two things follow. The 97M and 10,000-server figures are official, so you can cite them. But they describe December 2025, and anyone presenting them as the current state of the ecosystem is roughly eight months behind.

July 2026: Roughly Half a Billion Monthly Downloads#

The 2026-07-28 specification post is the most recent official figure at the time of writing: "close to half-a-billion downloads a month" across Tier 1 SDKs, with TypeScript and Python each crossing one billion cumulative downloads.

Other ecosystem counts often quoted alongside these — client totals, the share of servers offering remote deployment, developer intent-to-expand percentages — we could not trace to a primary source, so they are not reproduced here.

Who Is Using MCP in 2026?#

Adoption data reveals a clear pattern: engineers are driving MCP growth from the bottom up, and enterprises are following.

Developer Adoption by Role#

The server categories that dominate public registries are overwhelmingly engineering tools rather than general business software, which tells you where the demand is concentrated. We have seen "42 of the 50 most-searched servers are engineer-facing" quoted for this, but could not locate the underlying dataset, so treat the direction as sound and the precise ratio as unverified. The recurring use cases:

1. AI coding assistance — connecting IDEs to documentation, GitHub, code search
2. Database access — letting AI agents query production and staging databases with defined permissions
3. CI/CD integration — Jira, Linear, GitHub Actions, Kubernetes status checks
4. Observability — Datadog, Grafana, PagerDuty integrations for incident response
5. Data pipelines — connecting AI workflows to dbt, Airflow, Snowflake

Enterprise Deployment Patterns#

Enterprise adoption tends to follow a different pattern from individual developer adoption. Rather than installing community servers, enterprises typically:

• Build private MCP servers for internal tools and proprietary data sources
• Deploy remote servers on internal infrastructure with SSO and audit logging
• Use gateway layers (Zuplo, Kong, AWS API Gateway) to manage MCP traffic, rate limiting, and security

Block, Bloomberg, AWS, Google, Microsoft, and Cloudflare are all named backers of the Agentic AI Foundation in the Linux Foundation announcement, which is a reasonable proxy for serious internal investment. Broader "share of Fortune 500 running AI agents" statistics circulate widely, but we could not tie any of them to a published methodology, so we are not quoting one.

The "Shadow IT" Problem#

The rapid grassroots adoption of MCP has also created governance challenges. Security firm Qualys has documented a new class of risk: "MCP Shadow IT" — cases where individual teams or developers deploy MCP servers with access to sensitive systems without IT's knowledge or approval.

This parallels the SaaS shadow IT wave of the 2010s. The solution is the same: visibility, policy, and governance tooling. Several security-focused MCP gateway products have emerged specifically to address this, offering centralized MCP server discovery, permission auditing, and access controls.

The Server Ecosystem: What Developers Are Actually Installing#

The MCP server ecosystem in 2026 covers virtually every tool category developers work with.

Top Categories by Install Volume#

Developer & DevOps Tools

• GitHub — code search, PR management, issue tracking
• Docker Hub — container management, image search
• Kubernetes — cluster status, deployment management
• Jira / Linear — ticket management and project tracking
• Datadog / Grafana — metrics and observability

Data & Databases

• PostgreSQL / MySQL / SQLite — direct database querying with schema inspection
• Snowflake / BigQuery — cloud data warehouse access
• dbt — data model documentation and query generation

Productivity & Collaboration

• Slack — message search, channel management, notifications
• Notion — knowledge base access and page creation
• Google Workspace — Docs, Sheets, Drive, Calendar, Gmail
• Microsoft 365 — SharePoint, Teams, Outlook

Marketing & Analytics

• HubSpot — CRM access, contact and deal management
• Salesforce — enterprise CRM with full object access
• Google Analytics / GA4 — web analytics queries
• Ahrefs / Semrush — SEO data and keyword research

AI & LLM Tools

• Anthropic Claude — meta-MCP for Claude-in-Claude workflows
• OpenAI — GPT model API access as an MCP tool
• Pinecone / Weaviate — vector database access for RAG workflows

The Remote Server Shift#

One of the most significant trends in the MCP ecosystem is the shift from local stdio servers to remote HTTP servers. The clearest evidence is not a growth statistic but the protocol's own direction: the July 2026 specification removes the session handshake specifically so that requests "can land on any server instance behind a standard load balancer." Specifications do not get rewritten around deployment shapes nobody uses.

The reason is operational: local stdio servers run as child processes on the developer's machine and die when the session ends. Remote HTTP servers can be shared across a team, persist between sessions, handle authentication centrally, and scale independently of the client.

For enterprises, remote servers are not optional — they are the only viable architecture. A remote MCP server sitting in front of a database can enforce row-level security, log every query, rotate credentials, and be updated without touching client configurations. A local stdio server cannot.

The Protocol Itself: What Changed in 18 Months#

The MCP specification has matured significantly since the initial November 2024 release.

Specification Version 2025-11-25#

The current production specification (2025-11-25) introduced several key improvements over the initial draft:

• Streamable HTTP transport — replaced SSE with a more robust HTTP streaming approach, enabling better load balancing and proxy compatibility
• OAuth 2.1 integration — standardized authentication flow for remote servers, with PKCE and dynamic client registration
• Structured output — servers can define typed response schemas, not just text blobs
• Server-sent progress — long-running operations can stream progress updates to the client
• Elicitation — servers can request additional information from users mid-operation, enabling multi-step workflows

Specification Version 2026-07-28#

The 2026-07-28 specification is the significant one for anyone running MCP in production, because it re-architects the protocol around stateless operation:

• Stateless transport — the initialize/initialized handshake and the Mcp-Session-Id header are gone, so any request can land on any server instance behind an ordinary load balancer
• Multi round-trip requests (MRTR) — replaces server-initiated requests that needed a held-open stream, so a tool can ask the user for input mid-operation without a persistent connection
• Header-based routing — Mcp-Method and Mcp-Name HTTP headers let gateways and firewalls route and authorize without parsing the JSON body
• Cacheable list results — list and read responses carry ttlMs and cacheScope for client-side caching
• Authorization changes — RFC 9207 issuer validation, a move away from Dynamic Client Registration toward Client ID Metadata Documents, and issuer-bound credentials
• Extensions framework — tasks and similar features become formal extensions rather than core protocol

Read together, these say MCP has entered its infrastructure-maturity phase. The work is no longer about adding capability; it is about surviving load balancers, corporate proxies, and security review. If you built against the session-based model, the stateless migration is the change to plan for.

MCP vs. Competing Approaches#

MCP's dominance is real, but it is worth understanding what it beat out and what still competes.

OpenAI Function Calling#

Function calling (now called "tools" in the OpenAI API) predates MCP and is still widely used for simple, single-model applications. The key difference: function definitions are defined per-API-call, inline with the prompt. There is no concept of a persistent server, no discovery mechanism, no transport standard.

For applications that use a single model and have simple tool needs, function calling remains appropriate. For anything multi-model, multi-agent, or with persistent tool state, MCP is the better choice.

Google A2A Protocol#

Google introduced the Agent-to-Agent (A2A) protocol in April 2025 alongside MCP support in Gemini. A2A focuses specifically on agent-to-agent communication — how one AI agent delegates work to another. MCP focuses on agent-to-tool communication — how an agent uses a capability.

The two protocols are complementary rather than competing. A2A handles the "how do agents collaborate" question; MCP handles the "how do agents connect to tools" question. Expect both to remain relevant as multi-agent systems mature.

Proprietary Enterprise AI Platforms#

ServiceNow, Salesforce Einstein, and similar enterprise AI platforms have their own integration layers that compete with MCP in their respective ecosystems. These platforms offer MCP compatibility as a bridge, but their native integrations go deeper into their own product surfaces.

For organizations that are heavily invested in a single enterprise platform, the platform's native AI integration may be superior. For organizations that want model flexibility or are building cross-platform workflows, MCP is the better foundation.

The Market Behind the Momentum#

The MCP ecosystem has spawned a new layer of commercial infrastructure:

• MCP registries and marketplaces — directories of verified, maintained MCP servers with installation metrics and security audits
• MCP gateways — proxy layers that add authentication, rate limiting, caching, and observability to MCP traffic
• MCP development platforms — tools for building, testing, and deploying MCP servers without managing infrastructure
• MCP security products — server discovery, permission auditing, and compliance tooling

Dollar-sized market projections for this layer are easy to find and hard to source; the "$10.4 billion by 2026 at 24.7% CAGR" figure that appears in much of the coverage traces back to no methodology we could inspect, so we are not repeating it as fact. The qualitative driver is not in dispute: as organizations move AI agents from experiments to production, they need reliable, secure, auditable tool integration, which is what this infrastructure layer sells.

What Comes Next: The Second Half of 2026#

Several developments are likely to shape the MCP ecosystem through the end of 2026:

Stateless migration — The 2026-07-28 rewrite gives operators something they have wanted since remote servers became the default: MCP traffic that behaves like ordinary HTTP behind ordinary infrastructure. Expect gateway and platform vendors to rebuild around it, and expect session-based deployments to need a migration path.

Enterprise registry consolidation — Today's fragmented registry ecosystem (multiple competing directories of MCP servers) is likely to consolidate around a handful of trusted, enterprise-audited sources. The Linux Foundation governance creates a path for an official canonical registry.

MCP as a hiring requirement — Developer job postings that mention MCP have grown from near-zero in early 2025 to a measurable percentage of AI-adjacent roles. As MCP becomes assumed infrastructure, proficiency with MCP server development will be treated like REST API knowledge — a baseline, not a differentiator.

Edge and embedded MCP — Lightweight MCP server implementations are emerging for edge compute environments, enabling AI workflows that can run on-device or at CDN edge nodes without full cloud infrastructure.

Getting Started with MCP in 2026#

If you haven't integrated MCP into your workflow yet, the barrier to entry is lower than it has ever been.

For individual developers:

1. Install Claude Desktop or Cursor (or any MCP-compatible client)
2. Browse the official MCP server list at modelcontextprotocol.io or a community registry
3. Add servers via your client's configuration — most clients use a JSON config file
4. Start with filesystem, GitHub, and your primary database driver

For teams:

1. Evaluate a remote MCP deployment for shared servers rather than per-developer local installs
2. Consider a gateway layer if you have compliance or audit requirements
3. Inventory what private tools your team uses most frequently — those are the highest-value candidates for MCP server development

For enterprises:

1. Treat MCP servers as internal APIs — apply the same security, documentation, and change management standards
2. Deploy a discovery mechanism so teams can find and reuse MCP servers that others have already built
3. Engage with the AAIF specification process to ensure your requirements are represented in future versions

When to Build on MCP, and When to Skip It#

Build on MCP when: you need the same tool reachable from more than one model or client; you want tool integrations to outlive the app that first needed them; you are in an enterprise setting where a remote server with central auth, audit logging, and row-level security is a requirement rather than a nicety; or you are shipping a developer-facing product and want to meet users inside the editor they already use.

Skip MCP when: you have a single model, a handful of tools, and no plan to change either — plain function calling is less machinery for the same result. Also skip it if your integration is a one-off script, or if you are committed to a single enterprise platform whose native integrations reach deeper into its own surfaces than an MCP bridge will.

The honest caveat on timing: the protocol changed shape in July 2026. If you adopt now, target the stateless 2026-07-28 specification rather than session-based examples, much of which is what you will find in tutorials written during the first eighteen months.

Summary#

MCP went from a November 2024 announcement to an officially reported 97 million monthly SDK downloads by December 2025, and to roughly half a billion a month by July 2026. The growth was not luck. It was a sequence of adoption decisions by the industry's largest players: OpenAI in March 2025, Microsoft in July 2025, AWS in November 2025, and Linux Foundation governance in December 2025.

Each of these moments addressed a specific hesitation. OpenAI's adoption proved it wasn't a proprietary lock-in. Microsoft's integration made it enterprise-credible. AWS's support satisfied compliance teams. Linux Foundation governance removed the single-vendor governance risk.

The result is a protocol that has achieved something rare in infrastructure: genuine consensus. In a world where AI providers compete fiercely for developer adoption, MCP is the standard they all agreed to ship.

That consensus is worth paying attention to. When every major AI provider implements the same protocol, building on top of that protocol becomes a safe architectural bet — perhaps the safest in the current AI tooling landscape.

Primary Sources#

1. MCP joins the Agentic AI Foundation — Model Context Protocol Blog, December 9, 2025. Source for the 97M monthly downloads and ~10,000 active servers figures.
2. The 2026-07-28 Specification — Model Context Protocol Blog, July 28, 2026. Source for the stateless architecture changes and the ~500M monthly / 1B cumulative download figures.
3. Linux Foundation Announces the Formation of the Agentic AI Foundation — Linux Foundation press release, December 2025. Source for founding projects and platinum members.
4. Sam Altman on OpenAI MCP support — March 26, 2025. Source for the OpenAI adoption date and initial scope.

Figures in this article are current as of the August 2026 revision. MCP's download numbers have moved fast enough that any figure here should be re-checked against source 2 before you quote it.

Related reading: our review of goose, the AAIF founding project that ships MCP integration natively; our comparison of AI agent frameworks; and our measured proof runs on tool-call token cost and tool failure recovery.