Tools Were Only Phase One: MCP’s Move Toward Agent Interoperability

Is MCP the Next Operating System?

When the Model Context Protocol (MCP) launched, the value proposition was clear: Give language models a standard way to call external functions.

But if you look at the 2026 roadmap and the stable work shipping since then, you see something more ambitious. MCP is evolving beyond a tool-calling API toward a broader set of primitives for agent workflows, long-running work, interactive experiences, and enterprise deployment.

The evidence is in what’s no longer experimental:

Delegation: Tasks, now an official extension, support long-running work without requiring the original request to remain open. A server can return a task handle from a tool call, which the client can use to check, update, or cancel the task.
Interaction: MCP Apps let servers provide interactive HTML interfaces that hosts can render alongside tool interactions, including interfaces with buttons, forms, and other UI elements.
Enterprise-Managed Authorization: Organizations can say: “This agent can access these systems, under these conditions, with this identity,instead of per-user per-server authorization.”

The Skills Over MCP Working Group is developing an experimental extension for discovering and distributing reusable agent skills through MCP. The proposal is still evolving and is not yet part of the official MCP specification. already have in place.

Are Skills Better than Tools?

This is where the story gets interesting.

In the old model:

Client: “Here are the tools you can call.”
Agent: calls tools, parses results, reasons about them.

In the new model that Skills over MCP is proposing:

Server: “Here’s a procedure, with prerequisites, side effects, expected outcomes, retry logic, and escalation paths.”
Agent: understands the full operational context and can execute with awareness of constraints.

The working group is currently exploring how this works technically – using the Resources mechanism in MCP, defining a schema for skill metadata, and thinking through discovery and composition.

But the conceptual shift is clear: MCP is moving beyond “here are functions you can call” toward “here’s how a safe, effective agent operates in this domain.”

What Does This Change Enable for Organizations Using MCP?

Think about what happens when you combine these pieces:

Auditability + Enterprise-Managed Authorization = a stronger foundation for connecting agent access to enterprise identity and authorization controls.
Tasks + MRTR = long-running work can pause for approvals, clarification, or other input without requiring a continuously open connection.
MCP Apps + server-rendered UIs = agents don’t just get data; they can work with designed interfaces, reducing parsing errors and increasing usability.
Skills + standardized procedures = agents operate from documented playbooks, not ad-hoc tool chains.
Event-driven MCP (on the horizon) = agents can be triggered by changes in underlying systems, not just client requests.

Put those together, and MCP starts to look like more than a tool-calling API. It is becoming a broader protocol layer for coordinating agent interactions, long-running work, user interfaces, identity, and enterprise infrastructure.

What’s Next on the MCP Roadmap?

The 2026 roadmap explicitly calls out unresolved questions in Tasks: retry behavior, result expiry, long-term state. These upcoming changes are foundation-building for a system where Tasks become the standard unit of agent work.

It mentions “portable server configuration,” which implies agents should be able to migrate between deployments without losing context. It talks about “composable tool execution,” which suggests chaining tools together in standardized ways.

Every item on that roadmap is a piece of this larger picture: MCP evolving from a protocol for calling functions into a protocol for agents to operate as members of an organization.

Update: On Aug. 22, the MCP maintainers published a new roadmap that reinforces this direction, with priorities including agentic messaging primitives, HTTP-native transport, agent identity and enterprise-ready security, improved primitives, and SDK developer experience.

What Comes Next in This Series

We’ve now covered two things:

The architectural shift to stateless, web-native MCP (Part 1).
The conceptual shift to full agent capabilities (this post).

The next three posts dig into the implications:

How the full vision ties these threads together.

How MCP’s architecture is becoming web-native and operations-friendly.

How enterprise security and governance are built into the foundation.

Learn More

MCP 2026 Roadmap (https://blog.modelcontextprotocol.io/posts/2026-mcp-roadmap/)
Skills Over MCP Working Group (https://github.com/modelcontextprotocol/spec/discussions) (SEP-2640)
Tasks Extension Specification (https://modelcontextprotocol.io/specification/2026-07-28/extensions/tasks)

MCP Agent Interoperability FAQ

How is MCP moving beyond tool calling?

MCP is expanding beyond simple function calls with capabilities such as Tasks, MCP Apps, Enterprise-Managed Authorization, and experimental work around Skills. Together, these developments support longer-running work, richer interactions, and more structured ways for agents to operate across enterprise systems.

What are Tasks in MCP?

Tasks are an official MCP extension for long-running work. A server can return a task handle from a tool call, allowing the client to check status, update the task, or cancel it without keeping the original request open.

What are Skills in MCP?

Skills are an experimental effort to make reusable agent procedures and workflows discoverable through MCP. The work is still evolving and is not yet part of the official MCP specification.

Why does agent identity matter for MCP?

As MCP is used across more enterprise systems, organizations need stronger ways to connect agent activity to identity and authorization controls. Enterprise-Managed Authorization and related roadmap work are aimed at making that access easier to govern centrally.