Developers favoring the open MCP standard over vendor-specific AI agents

MCP launched in November 2024 as an Anthropic project - the company wrote the spec, shipped the SDKs, and built the first reference servers for Google Drive, Slack, GitHub, and Postgres ^[1]. Just over a year later, Anthropic did something companies rarely do with a strategic asset: it gave up control. On December 9, 2025, MCP's trademarks and governance moved to the Agentic AI Foundation, a directed fund under the Linux Foundation, with Anthropic explicitly stating the maintainers would keep prioritizing community input over any single donor's roadmap ^[2]. The platinum members bankrolling that foundation, Google, Microsoft, AWS, Cloudflare, and Bloomberg, are now co-invested in a standard that no single one of them, including Anthropic, controls outright ^[2]. By the time of the donation, the numbers already showed why developers cared: more than 10,000 active public MCP servers and over 97 million monthly SDK downloads ^[2]. The timeline of buy-in actually ran the opposite direction from what that donation might suggest: OpenAI, a direct competitor, adopted the protocol across its Agents SDK, ChatGPT desktop app, and Responses API back in March 2025, roughly nine months before the Agentic AI Foundation existed to donate MCP into ^[3]. Only after Anthropic ceded control in December 2025 did OpenAI go a step further and become a co-founder of the foundation now governing the protocol it had already adopted ^[2].

Underneath the governance story is a simpler mechanical reason developers keep choosing MCP over building against any single vendor's agent framework: without a shared protocol, connecting many models to many tools and data sources means writing bespoke, per-vendor integration code for every pairing, an N-by-M problem that grows fast as either side adds a new model or a new tool. A shared protocol turns that into an N-plus-M problem instead, since a tool only needs to implement the protocol once and every compliant model can use it. That is close to the argument David Soria Parra, one of MCP's creators at Anthropic, has made in describing the pre-MCP status quo: integrations had to be rewritten from scratch for each model provider, copy-pasted and re-wired every time a team wanted to connect a new model to the same tool. He has likened MCP's write-once, use-everywhere pattern to USB-C, and described what it gives a model as limbs into the world instead of forcing manual copy-paste integration for every new connection. Builders have picked up a similar framing from the other direction: Avi Chawla, discussing the ongoing split between agent frameworks like LangGraph, CrewAI, and Agno, argued that picking a framework is becoming beside the point now that the industry has converged on a small set of open protocols that work across all of them, since a protocol-level standard means the framework underneath stops being a lock-in decision.

Every vendor-side data point in this story points the same direction: nearly half of surveyed software organizations already run MCP in production, and 49% rank MCP adoption as a top-five company initiative, the highest of any industry surveyed ^[4]. But the developers actually wiring MCP servers into their agents sound far less triumphant. On Reddit, the recurring complaint isn't philosophical, it's arithmetic: an MCP server's tool list sits in the model's context on every single turn whether it's called or not, so servers with tools that fire rarely become a permanent token tax. Several practitioners argue a plain CLI, or Anthropic's own newer 'skill' pattern that only loads into context on demand, beats an MCP server for exactly that reason. That skepticism tracks with the survey data too: 64% of organizations still cite security concerns as their top barrier to MCP adoption even as production usage climbs ^[4]. A related tension shows up in how enterprise infrastructure operators talk about the protocol: Randy Bias, of the cloud infrastructure company Mirantis, points to SaaS vendors standing up their own dedicated endpoints, such as github.com/mcp, in place of proprietary connectors as evidence MCP is becoming the de facto interoperability layer, and credits Anthropic's fast, community-responsive iteration, adding auth, adding a registry, for earning that trust. But he also flags an obvious asymmetry: even as the protocol's governance goes fully open, the proprietary agent SDKs that OpenAI and Anthropic each sell on top of MCP have not themselves joined the open foundation. The open-standard story and the token-bloat story aren't really in conflict, they describe two different adoption curves: buyers are choosing MCP over a proprietary alternative at the platform level, while builders are still deciding, tool by tool, whether MCP is worth the standing context cost.

The clearest evidence that practitioner complaints were being heard, not just tolerated, showed up in July 2026, when MCP shipped its largest spec update since launch ^[5]. The protocol's core moved to a stateless request/response model, meaning a request no longer has to land on the same server instance it started on, removing a scaling constraint that mattered once organizations tried running MCP behind a load balancer ^[5]. The same update added Enterprise-Managed Authorization, letting an organization centrally manage login across every connected MCP server instead of forcing a fresh consent prompt per server ^[6]. Both fixes map directly onto the barriers organizations had actually flagged, and enterprise SaaS vendors including Asana, Atlassian, Figma, and Linear shipped support for the new Enterprise-Managed Authorization extension, with Slack support in progress ^[6].

The version of MCP that won developer mindshare in 2024 and 2025 was a simple one: call a tool, wait for a response. Builder chatter on X suggests that's already the old version. MCP's newer roadmap is aimed at long-running agent work, servers pushing streamed results back mid-task, humans steering a job while it's still in flight, and agents carrying delegated identity instead of a shared, permanent API key, alongside an explicit push to cut down on tool bloat. That's a meaningfully different piece of infrastructure than the 'read a file, hit an API' pattern most current MCP servers implement, and it's arriving at the same time enterprises are being told write-actions and billing-adjacent tool calls need scoped permissions, schema validation, and audit logging rather than an agent freelancing raw API calls. The protocol that started as a way to avoid rewriting integrations per model is quietly becoming the identity and permissions layer for autonomous agents, which raises the stakes on the security concerns Reddit and industry surveys have already flagged.