The MCP protocol receives a key update — AI interoperability standards are finally starting to "speak human language."

MCP has been updated again. This time, it’s not about adding new features, but fixing several pain points that developers have complained about most over the past year.

On July 20, TechCrunch revealed details of the upcoming new version of the Model Context Protocol. The core update can be summed up in one sentence: make this so-called “USB-C of the AI world” actually behave like USB-C—rather than the kind that requires developers to handwrite glue code just to connect.

Anyone familiar with this line of work knows MCP was introduced by Anthropic in November 2024 to establish a unified standard for connecting large models with external data sources and tools. The idea is simple: every AI app used to require separate pipelines for Slack, GitHub, and databases, each with its own connection code. MCP aims to unify those pipelines into a single protocol, implemented once on both the model and tool sides, making them interoperable in between.

What’s Actually Changed

This upgrade focuses on four main threads, each targeting a commonly reported issue from the community over the past year.

1. Task-Based Workflows.
Originally, MCP calls were relatively stateless—Client sends a request, Server executes the tool call once, and returns the result. Sounds simple, but real-world scenarios almost never happen in one step. Want the agent to help you reply to a complex email? It might need to check your calendar, look up a contract, and query an internal knowledge base before generating the response. Previously, you either stuffed that logic into a prompt or built a state machine at the application layer.

The new version raises “tasks” to the level of protocol primitives. A task can span multiple tool calls, and the MCP Server now understands and tracks its entire lifecycle, instead of treating each call as an independent event. For those developing Agent applications, this essentially means outsourcing state management to the protocol itself.

2. Simplified Authorization Process.
This was the most criticized area in the past six months. Connecting to a remote MCP Server used to be a nightmare—OAuth flows required handling callbacks, token refresh, and scope checks, making many developers give up on remote servers entirely and run everything locally.

The new protocol introduces a simplified authorization model and URL pattern guidance. Servers can now explicitly tell Clients which resources require what authorization level, and Clients can more clearly relay requests to users. This approach isn’t new—OAuth 2.1 and some enterprise SSO schemes have similar designs—but MCP standardizing it at the protocol level means developers no longer have to reinvent the wheel for each integration.

3. Enterprise-Grade Security and Governance.
This may be the most “boring” but also the most crucial part of the update. The protocol adds specs for permission boundaries and audit logs, providing a compliance baseline for enterprise MCP deployments. Don’t underestimate this—the past few months have seen multiple MCP security issues surfaced, including command overlap, sandbox escapes, and malicious server spoofing. A research paper by Huazhong University of Science and Technology’s Security PRIDE team earlier this year mapped out attack surfaces across the server lifecycle, drawing major community attention.

4. Extension Framework and Sampling with Tools.
This is more technical: it allows the Server to make reverse inference requests to the model during responses, or even nest tool calls. It sounds like “the Server can act as a Client,” but in practice, it lays the foundation for more complex agent orchestration. Imagine a data analytics MCP Server that can first ask the model which SQL dialect to use before executing a query—this kind of two-way interaction used to require manual integration at the app layer, but is now natively supported.

Why Fix It Now

A thought-provoking question: MCP launched in November 2024, so why did it take 20 months to address these obvious usability issues?

The answer lies within MCP’s adoption curve. When it first launched, the earliest adopters were Anthropic’s own Claude Desktop and several IDE-type tools (Cursor being one of the first deep users). These scenarios share a common trait: local-first deployment with the user and developer being the same person or team. In such cases, authorization could be simplified and state management handled bluntly—if anything broke, you could just fix the code.

But by the second half of 2025, cloud providers like Cloudflare and Google Cloud started pushing MCP Servers toward remote-hosted, multi-tenant environments, changing the picture completely. Enterprise use means SSO, auditing, and permission isolation are mandatory; multi-tenancy means the authorization chain must be airtight; and cross-organization calls mean the protocol must handle spoofing and injection risks.

In other words, MCP’s first 18 months were driven by “developer community enthusiasm,” and only in the last six months has it entered real enterprise environments. This update essentially fills the infrastructure gaps required for those deployments.

Compared to Competitors, Where MCP Stands Out

You might ask: we already have OpenAI’s Plugin, Function Calling, and even LangChain’s tool integration—why do we need MCP?

Here’s an imperfect but illustrative analogy:

• OpenAI Plugin / Function Calling: like a closed App Store ecosystem. The spec is defined by the platform, execution happens within it, and cross-platform reuse is nearly impossible. A plugin written for GPT won’t work with Claude.
• LangChain Tools: functions more like a glue-layer framework that wraps tools into a unified Python/JS interface. It’s flexible but locked into that framework—switch to another agent framework and you have to rewrite everything.
• MCP: more like HTTP or LSP (Language Server Protocol). The protocol itself is decoupled from the model, language, and platform—implement a Server once, and any MCP-compatible Client can use it.

MCP’s real differentiator isn’t elegance—it’s that it’s the only protocol designed from the ground up for cross-model, cross-platform reuse. That’s why companies like Google, Microsoft, and Cloudflare are on board—they don't want to lock their ecosystems into Anthropic’s, but since the protocol is neutral, adoption becomes purely a technical and business decision.

As Yuanda Securities’ recent industry report put it: “AI is moving from a fragmented SDK-adaptation phase to a standardized, protocol-compatible era.” That might sound like analyst-speak, but the direction is right. MCP is likely to become AI’s equivalent of HTTP—not necessarily the most elegant, but certainly the most widespread.

Developer View: Is the Upgrade Worth It?

For teams already running MCP Servers in production, migration costs aren’t trivial. Task workflows and the new authorization model affect core protocol behavior. Older Servers will likely need refactoring to fully benefit from new features, though backward compatibility was considered—basic tool-call scenarios should transition smoothly.

For new teams starting MCP integration, it’s best to go directly with the new version. Official SDKs (TypeScript, Python, Java, Kotlin, C#) cover major stacks, and community tools like FastMCP and EasyMCP are quickly catching up—ideal for rapidly spinning up new Servers.

A typical MCP Server configuration file now looks like this:

{
  "mcpServers": {
    "my-workflow-server": {
      "command": "node",
      "args": ["./dist/server.js"],
      "env": {
        "API_KEY": "${MY_API_KEY}"
      },
      "capabilities": {
        "tools": true,
        "tasks": true,
        "sampling": true
      }
    }
  }
}

The new tasks and sampling capability declarations were introduced with this update. Clients use them to determine whether task-level orchestration and reverse sampling can be enabled.

Remaining Issues

Despite the breadth of this update, several long-standing issues remain unresolved.

Server Distribution and Trust Mechanisms.
Current community-driven marketplaces like MCP.so, Glama, and PulseMCP lack official review processes. Malicious servers impersonating legitimate tools are a real risk—you might think you’re calling a GitHub Server when it’s actually a man-in-the-middle. This update adds metadata and signature recommendations but no mandatory distribution standards.

Version Downgrade Attacks.
Unofficial installers (like mcp-get or mcp-installer) might default to older versions, reintroducing patched vulnerabilities. The protocol can only do so much—ultimately an official package management system is needed, which still doesn’t exist.

Performance and Observability.
How remote MCP Servers behave under high concurrency, how call latency stacks when combining multiple Servers, and how retries are handled—these operational-layer issues remain mostly outside the protocol’s scope, left to individual Client and Server implementations.

Epilogue

Zooming out, from its birth in late 2024 until now, MCP has followed the same path as most open-source infrastructure protocols: start with a minimal viable version, gain momentum through community adoption, get stress-tested in production, then gradually evolve toward enterprise-grade robustness.

This update isn’t an endpoint, nor even a milestone—it’s just a normal waypoint on that road. But the signal is clear: MCP has moved past the “prove it’s useful” phase and entered the “prove it’s usable” phase. For the broader AI application ecosystem, that’s good news—the more standardized and “boring” the underlying protocols become, the more innovation the upper layers can achieve.

The differences between major model APIs are also fading. Aggregation platforms like OpenAI Hub already unify GPT, Claude, Gemini, and DeepSeek under an OpenAI-compatible format, with one key granting access to all—even in mainland China. As the MCP ecosystem matures and both model and tool sides adopt standard protocols, the barrier to building AI applications will drop even lower.

The next watchpoint: when major IDEs and Agent frameworks adopt the new protocol features. Cursor and Claude Code will likely move first, while enterprise platforms will depend on security and compliance validation. By year-end, we should have a clearer answer.

References

• Official MCP Specification and SDK Repositories – Protocol spec, multi-language SDKs, and reference implementations maintained by Anthropic
• MCP Server Community List – Official set of MCP Server samples for Slack, GitHub, Git, databases, etc.
• Awesome MCP Servers – A community-curated list of MCP server resources for quick integration
• In-Depth MCP Protocol Analysis (Juejin) – Chinese community article analyzing MCP architecture, lifecycle, and practical use cases
• Zhihu: Discussion Comparing MCP and Function Calling – Developer community discussion of differences between MCP, OpenAI Function Calling, and LangChain Tools