How is MCP Evolving from a Toolkit into an Application Protocol?
At its 2024 launch, MCP focused on enabling language models to call functions, allowing them to interact with external systems rather than limiting them to text generation.
But if you’ve been paying attention to the 2026 roadmap and the work shipping since then, you’ve probably noticed the conversation has shifted. While function calling remains central, the focus has moved toward broader integration: MCP is becoming the protocol through which agents operate as increasingly autonomous entities within organizations.
A function-calling protocol is about individual invocations. An application protocol is about sustained, governed, audited, multilayered interaction with organizational infrastructure.
MCP is evolving into a common application protocol that connects agents, specialized servers, enterprise systems, and the identity, security, and audit controls needed to govern them.
What Infrastructure is Already in Place for MCP?
Let’s trace the path from a simple tool-calling API to a broader application protocol.
Phase 1 (2024-2025): Basic Integration
- Tools, Resources, Prompts
- Agents can read and call things
- Primarily one-shot interactions
Phase 2 (2026-27, Arriving Nw): Rich Capabilities
- Tasks for long-running operations
- MRTR for multi-round interactions
- MCP Apps for UI components
- Roots for configurable access scope
- Enterprise authorization for identity and policy
In Phase 2, agents can run operations that span time, request human input mid-operation, work with designed interfaces, operate within policy-defined boundaries, and be audited and authorized centrally.
Phase 3: On the Horizon
The next phase extends that model further with Skills, event-driven MCP, streaming and reference-based results, and deeper security mechanisms such as DPoP and Workload Identity Federation.
That means agents will increasingly be able to execute documented procedures rather than individual functions, react to changes in underlying systems, handle large datasets more efficiently, and operate with stronger machine-to-machine trust.
Why is MCP an Application Protocol Rather Than Just a Tool-Calling API?
Each layer represents a deliberate step toward treating MCP as an application protocol, moving it closer to how software systems actually communicate and operate.
Think about the Web. HTTP started as a way to fetch documents and became the substrate for every kind of application: real-time collaboration, streaming media, complex transactions, IoT. The protocol didn’t need to become an operating system. It needed to be robust and simple enough to support all those uses.
MCP is following a similar trajectory:
- A simple messaging substrate using JSON-RPC over stdio and HTTP
- Basic primitives such as Tools, Resources, and Prompts
- Operational patterns around statelessness, cacheability, and identity
- Richer capabilities such as Tasks, Apps, events, and Skills
- A maturing ecosystem with formal extensions, governance, and deprecation policies
What started as “here’s an API for calling functions” is becoming “here’s a common application protocol for agents.”
What Changes When MCP Becomes an Application Protocol?
Imagine two scenarios.
Scenario A: MCP as a tool-calling API
The agent calls tool X with parameters Y. The tool returns a result. The agent parses the result and decides what to do next.
Simple, but the burden of orchestration is largely on the agent.
Scenario B: MCP as an application protocol
The agent requests a workflow. The MCP server runs a task and returns a task ID, allowing the agent to continue with other work. If the server reaches a decision point, it can request approval through MRTR. The agent provides a decision, the task continues, and the server eventually returns a result with structured context.
Everything is more explicit. The workflow is documented, side effects are managed, and the agent doesn’t have to reinvent orchestration logic each time. Instead, more of that logic can live in the MCP server.
Now scale that across an organization with dozens of agents, hundreds of systems, and compliance requirements. That orchestration burden on the agent becomes a much larger problem, and MCP as an application protocol is positioned to absorb some of that complexity.
What Is the Skills Frontier?
One emerging trend gives us a preview of where this is heading: Skills over MCP.
Skills provide a standard way to distribute agent procedures, including workflows, playbooks, and documented processes, through MCP.
Instead of an agent reasoning from scratch about “call tool A, then tool B, then tool C,” an MCP server could expose a Skill such as “Provision New Data Pipeline,” which packages the instructions and supporting resources needed to carry out that process.
The agent doesn’t have to rediscover the procedure every time. It can invoke a defined Skill and use the MCP layer to access the resources required to perform it.
That moves the model from an agent acting primarily as an orchestrator of individual functions toward one that can invoke reusable procedures while retaining responsibility for the decisions around them.
What Are the Implications for Enterprises?
Today organizations building agent systems create agents that know how to call 50 different systems. In the future MCP envisions, they’ll increasingly build agents that know how to decide and invoke capabilities exposed through a common protocol.
Some of the complexity moves from agent development into MCP server development, where it can be centralized, audited, and versioned.
An agent team can focus on reasoning and decision-making, while a platform team focuses on building MCP servers that encapsulate safe, auditable interaction with organizational systems. Each team can focus on its own concerns, creating more room to scale agent deployments without making systems increasingly brittle.
What Does the Roadmap Tell Us?
The 2026 roadmap gives us visibility into what comes next:
- Agentic messaging for longer-running and server-initiated interactions
- Streaming and reference-based results for more efficient data handling
- Progressive discovery for smarter clients
- Deeper security and stronger agent identity
- Continued evolution of the MCP ecosystem and registry
After reading this blog series, none of these should feel like isolated additions. They are natural extensions of MCP as an application protocol.
What is the Broader Context for MCP?
The MCP maintainers have learned something from production deployments: protocols that try to be everything tend to become unwieldy, while protocols that establish strong foundations can become the substrate for much more.
HTTP isn’t the best protocol for every use case. But it is simple and robust enough that it became the substrate for the Web.
MCP is following a similar pattern. The stateless redesign, extension points, deprecation policy, and work around identity and authorization are all moves toward making MCP robust enough to serve as a common substrate for how agents and systems interact.
How Does This Affect Your Workflow?
If you’re building with agents:
- Learn MCP now. The protocol is moving well beyond basic tool calling.
- Think about how agent operations get audited. Enterprise authorization and audit trails are becoming architectural requirements.
- Invest in MCP server development. More integration and orchestration logic can live in the platform layer agents operate on top of.
- Watch the Skills ecosystem. It could become an important layer for reusable agent procedures.
If you’re building infrastructure for agents:
- Treat MCP as an integration layer. It is increasingly becoming an application protocol for agent operations rather than simply a tool-calling API.
- Design for web-native infrastructure. Statelessness, cacheability, and familiar HTTP infrastructure matter as MCP scales.
- Treat identity and governance as architectural. They are becoming fundamental to how agent systems operate.
The Series in Retrospect
What started as “MCP had a big update” evolved into a five-part exploration of MCP’s evolution:
- Architecture: Stateless and web-native
- Capability: From tools toward broader agent interoperability
- Operations: Commodity infrastructure patterns
- Governance: Enterprise security and audit
- Vision: Agent interoperability and the application protocol
The July 28, 2026 update established much of the plumbing needed for this broader architecture.
And the roadmap shows the evolution is still underway. Skills, agentic messaging, richer results, and deeper security are pushing MCP further beyond its origins as a tool-calling interface.
The question now is not simply what an agent can call through MCP. It is how much of the interaction between agents and enterprise systems will eventually happen through it.
Learn More
- MCP 2026 Roadmap: Full View: https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/
- Skills Over MCP: https://github.com/modelcontextprotocol/ext-skills
- MCP Specification Home: https://modelcontextprotocol.io/specification/
- MCP Official Blog: https://blog.modelcontextprotocol.io/
