The Model Context Protocol (MCP) just turned one year old. And what a year it’s been.
When Anthropic released MCP in November 2024, I leaned in. I’d been working on similar problems at Microsoft—we’d explored stdio-based, JSON-RPC approaches to connect agents with applications (a story for another post). The architecture was remarkably similar.
So what made MCP different? The open source community adopted it and spread it like wildfire. That community momentum is what turned a good technical design into the de facto standard.
What a Year Looks Like
A year ago, MCP was an interesting open source project with a handful of early adopters. Today:
- Major platform adoption: Windows and cloud platforms now have native MCP support
- Enterprise deployment: Organizations are running thousands of MCP servers in production
- Ecosystem explosion: SDKs exist for every major language—TypeScript, Python, .NET, Java, Rust, Go
- Registry infrastructure: The MCP Registry enables discoverability across the ecosystem
- Formal governance: The project operates with a defined governance model and working groups
I’ve been involved in various parts of this evolution—working closely with folks on the MCP protocol and steering committee, filing bugs and feedback on the .NET SDK, contributing to the MCPB packaging specification, and leading the team that’s integrating MCP as platform infrastructure for Windows. Beyond the technical work, one of the things I value most is the opportunity to partner with amazing, talented, and passionate people—both inside Microsoft, at Anthropic, and in the broader MCP contributor community.
The most surprising part wasn’t the technical progress. It was how quickly a community formed around shared problems. Engineers who were independently solving the same challenges started collaborating, sharing patterns, and building together.
The New Spec: What Changed
The anniversary release includes major specification updates that address real-world needs we’ve encountered at scale. Here’s what matters:
Asynchronous Operations
Previously, MCP only supported synchronous tool calls—agents waited for responses. The new async operations capability changes everything for long-running tasks.
Practical impact: Data gathering, ML inference, complex automations—anything that takes more than a few seconds can now run properly. Clients can poll for results rather than timing out.
The UX benefit is significant: users no longer see their agent freeze while waiting for a long-running operation. The agent can acknowledge the request, continue with other tasks, and notify when results are ready.
Human-in-the-Loop Elicitation
Tools can now request additional structured input mid-workflow. If an agent needs clarification (“Which database should I query?”), the protocol supports multi-turn exchanges.
This matters for building production agents that handle ambiguity gracefully. Real-world tasks are rarely fully specified upfront.
OAuth and Security Enhancements
The June 2025 spec added comprehensive OAuth 2.0 support with Resource Indicators (RFC 8707). This prevents tokens from being misused across services and establishes strict audience controls.
Enterprise adoption requires enterprise security. These aren’t optional features—they’re requirements for any organization deploying MCP at scale.
Structured Outputs
MCP now requires formal output schemas (typically JSON Schema). Tool results can be reliably validated and parsed.
The benefit is richer explicit semantics about outputs, enabling models to more accurately reason over tools and the semantics of their output. This leads to better tool selection and more reliable agent behavior.
Statelessness and Scalability
Improved support for stateless operation makes horizontal scaling straightforward. Session management, server startup, and distributed deployments all work better.
Server Identity and Capability Discovery
Remote servers can advertise capabilities via standardized .well-known URLs. Clients can discover what a server offers without connecting first.
This enables automation, improves security (less blind trust), and makes registry integration seamless.
Formal Governance
The protocol now operates with a defined governance model. Specification Enhancement Proposals (SEPs) give the community a voice in protocol evolution. Working groups—including MCPB for packaging standards—drive specific initiatives.
This matters because MCP isn’t just an Anthropic project anymore. It’s community infrastructure, and the governance reflects that.
What I’ve Learned Building MCP Infrastructure
A year of building MCP integrations at the Windows platform level has taught me several things:
Standards unlock velocity. When the packaging question is answered (MCPB), when the protocol is defined (MCP), when security is built-in (OAuth)—teams stop reinventing and start building.
Community matters as much as specification. The spec is important, but the engineers sharing implementation patterns, debugging edge cases together, and contributing improvements—that’s what made MCP succeed.
Enterprise requirements are real. Every feature in the new spec addresses actual pain points from production deployments. Async operations, security, governance—these aren’t theoretical improvements. They’re responses to real problems teams hit at scale.
Open beats proprietary. MCP’s success came from being genuinely open. Organizations can contribute, extend, and build on it without vendor lock-in. That openness created trust, and trust enabled adoption.
What’s Next
Year two will be about maturity. The foundation is solid, and the community will continue to shape what comes next through SEPs and working groups.
I’m continuing to contribute to the MCPB working group and Windows platform integration. The problems we’re solving now—discoverability, security at scale, enterprise governance—are the foundational infrastructure work that enables the next wave of innovation.
The Bottom Line
A year ago, “how do AI agents connect to tools” was a problem without a standard solution. There are still competing approaches like A2A out there, but MCP has at least de facto won. Today, we have a standard that works, an ecosystem that’s thriving, and governance that ensures the protocol evolves with community needs.
The new spec features—async operations, elicitation, security enhancements, structured outputs—aren’t just incremental improvements. They’re what production deployments need.
MCP turned a fragmented landscape into shared infrastructure. That’s what good standards do.
Here’s to year two! 🎉🚀
Read the official anniversary post: MCP First Anniversary
For more on MCP development, check out my previous posts on MCP tooling and MCPB standardization.