MCP’s Biggest Update Yet: What Changed in MCP 2026-07-28 and How Anthropic Is Rebuilding Claude Around It
On July 28, 2026, the Model Context Protocol received its largest update since the technology was introduced.
The new version, officially named MCP 2026-07-28, changes how AI systems connect to external applications, databases, business platforms, developer tools, and internal company services.
The most important change is architectural. MCP has moved away from a protocol that depended heavily on persistent sessions and bidirectional connections. It now has a stateless core built around independent request-and-response interactions.
That may sound like an implementation detail that only infrastructure engineers should care about. In reality, it could have a major effect on how quickly AI integrations are built, how reliably they operate, and how widely companies are willing to deploy them.
The update also formalizes support for long-running AI tasks, interactive application interfaces, enterprise identity systems, caching, standard routing, observability, and a more predictable extension model.
At the same time, Anthropic is integrating these capabilities throughout Claude.
Claude already has a directory containing more than 950 MCP servers, according to Anthropic. The company says these connectors are used by millions of people each day. Anthropic is now adding interactive MCP Apps, centralized enterprise authorization, developer analytics, private-network tunnels, and support for the updated specification across Claude’s different product surfaces.
The result is a bigger story than a protocol update.
Anthropic is attempting to turn MCP into the standard connection layer for AI applications while positioning Claude as one of the main environments where those connections become useful products.
What Is MCP?
MCP stands for Model Context Protocol.
It is an open protocol originally introduced by Anthropic to create a standardized way for AI applications to communicate with external tools and sources of information.
An AI model on its own does not automatically have access to a company’s project management system, customer records, source code, analytics platform, design files, cloud infrastructure, or internal documents.
Developers can connect these systems using custom APIs. However, building a separate integration for every combination of AI product and software platform quickly becomes complicated.
A project management platform might need one integration for Claude, another for ChatGPT, another for an enterprise AI agent, and another for an AI-powered development environment. Each AI application might also implement tools, authentication, context, permissions, and responses differently.
MCP attempts to reduce that fragmentation.
It defines a common way for an AI host to discover and use tools, resources, prompts, and other capabilities supplied by an MCP server.
The MCP specification describes three important parts:
The host, which is the AI application.
The client, which manages a particular connection inside the host.
The server, which provides tools, information, or capabilities.
The protocol uses JSON-RPC messages to allow these components to communicate. The concept is partly inspired by the Language Server Protocol, which helped standardize how programming-language features work across different code editors.
In simpler terms, MCP is an attempt to create a universal plug format for AI software.
Instead of every AI application building every integration from the beginning, a service can create an MCP server that exposes its capabilities in a standardized format. Any compatible AI host can then connect to it.
The long-term goal is not that every integration becomes identical. Different products will still provide different user experiences. The goal is to standardize the infrastructure underneath those experiences.
Why MCP Needed a Major Update
The first generations of MCP proved that there was significant demand for a standard integration protocol.
Anthropic says MCP surpassed 400 million monthly software development kit downloads, representing approximately four times the activity recorded earlier in 2026. The Claude connector directory has also grown to more than 950 listed MCP servers.
However, early adoption also exposed limitations in the protocol.
The previous architecture depended on protocol-level sessions. Clients and servers performed an initialization exchange, negotiated capabilities, and often maintained state associated with an ongoing connection.
This model could work well for local development tools and smaller integrations. It became more difficult when developers attempted to operate MCP servers as large, distributed internet services.
Modern cloud platforms are generally designed to distribute incoming requests across many server instances. One request may be handled by one instance, while the next request is handled by another.
Persistent session state complicates this model.
A developer may need to configure sticky sessions so requests from the same client continue reaching the same server. Alternatively, the server instances may need access to a shared session database. Long-lived connections can also make scaling, recovery, load balancing, and serverless deployment more difficult.
These are solvable engineering problems, but they create additional work.
For an integration standard to become widely adopted, it cannot only work in controlled demonstrations. It must also fit naturally into the cloud infrastructure that companies already use.
MCP 2026-07-28 is largely an attempt to make that transition.
The update takes ideas that worked during MCP’s early growth and restructures them around the requirements of production systems.
The Most Important Change: MCP Is Now Stateless
The headline feature of MCP 2026-07-28 is its stateless protocol core.
In the previous model, clients performed an initialize request followed by an initialized notification. Streamable HTTP connections could also use an Mcp-Session-Id header to associate requests with a protocol-level session.
The new specification removes this initialization exchange and eliminates the protocol session identifier.
Every request is now intended to carry the information required to understand and process it. That includes the protocol version, the client’s identity, and the capabilities available to the client.
A server can still maintain application-level state when necessary. However, that state must be explicit rather than hidden inside the transport connection.
For example, a server performing a multi-step operation can create a task identifier or another handle. The client or AI model can then include that handle in subsequent requests.
This distinction matters.
The application can remain stateful, but the communication infrastructure no longer requires every request to remain attached to an invisible session maintained by a particular server instance.
Because each request is more self-contained, it can be sent to any compatible server instance. Developers can place multiple instances behind an ordinary round-robin load balancer without requiring sticky sessions or shared protocol-session storage.
Why stateless MCP matters
Stateless architecture is one of the reasons the modern web can scale so effectively.
When a request is independent, infrastructure providers can distribute traffic based on capacity and availability. Failed instances can be replaced. Additional instances can be started during periods of high demand. Requests can be routed through content-delivery networks, gateways, edge platforms, and serverless environments.
MCP servers can now fit more naturally into that model.
This should make it easier to deploy MCP on platforms such as serverless functions, edge workers, container services, and globally distributed cloud infrastructure.
It could also reduce the operational cost of maintaining connectors.
A company that wants to expose its software through MCP should not need to create a specialized session-management architecture merely because an AI agent wants to call a tool.
The new design moves MCP closer to the basic assumptions of HTTP infrastructure.
For small developers, this may make deployment easier.
For large companies, it may make MCP more acceptable to infrastructure and security teams that expect services to use standard load balancing, routing, monitoring, and failure-recovery patterns.
MCP Requests Can Now Be Routed Through Standard Infrastructure
The new specification introduces required Mcp-Method and Mcp-Name HTTP headers for Streamable HTTP requests.
These headers expose the type of MCP operation being performed and, where relevant, the name of the tool being called.
Previously, an API gateway or security service might have needed to inspect the JSON body of a request to determine what action the client was attempting.
With the new headers, infrastructure can make decisions before parsing the entire message body.
A gateway could route different MCP tools to different backend services.
A rate limiter could apply stricter limits to expensive operations.
A security system could block access to sensitive tools.
A billing platform could measure how often particular tools are used.
An observability platform could group latency and failure rates by MCP operation.
A company could also create different policies for read-only tools and tools that modify data.
This makes MCP traffic easier to manage using the same infrastructure companies already use for APIs and web services.
The individual headers may appear to be a minor addition. Strategically, however, they help turn MCP from an AI-specific communication mechanism into something that conventional infrastructure teams can understand and govern.
MCP Introduces Multi Round-Trip Requests
Moving to a stateless protocol creates an obvious challenge.
What happens when a server needs more information while processing a request?
Imagine that an AI agent asks a financial tool to transfer money. The server may need confirmation from the user before completing the action.
A travel-booking tool may need the user to choose between several flights.
A project management tool may need clarification about which workspace should receive a new project.
A design application may need the user to select one of several generated layouts.
Earlier MCP patterns could rely on server-initiated requests over a connection that remained open. This was difficult to reconcile with a stateless architecture.
The new specification introduces Multi Round-Trip Requests, usually shortened to MRTR.
Under this pattern, a server can respond that additional input is required. The response includes one or more requests for information.
The client gathers the required input from the user, model, or application. It then retries the original operation and includes the answers.
Results now explicitly identify themselves as either complete or requiring more input.
This allows interactive workflows to continue without requiring the server to maintain a permanently open bidirectional stream.
A simple example
Suppose a user tells Claude:
“Create a new advertising campaign using the same audience as our previous campaign.”
Claude calls an MCP tool provided by an advertising platform.
The server discovers that the company has several previous campaigns and cannot determine which audience the user intended.
Instead of failing or guessing, the server returns an input-required response containing a list of campaigns.
Claude displays the options.
The user selects one.
Claude retries the original request with the selected campaign identifier attached.
The tool can then complete the operation.
This pattern is important because useful AI agents rarely complete every task in a single perfect request.
Real work involves clarification, approval, missing information, changing constraints, and human judgment.
MRTR gives MCP a standardized way to support those interactions while preserving the new stateless architecture.
MCP Lists Can Now Be Cached
MCP clients frequently request lists of available tools, prompts, resources, and resource templates.
These catalogs may not change often. Repeatedly downloading them wastes network traffic and processing time.
It can also create instability in the prompts sent to AI models.
If tools are returned in a different order each time, the generated prompt may also change, even though the actual capabilities remain the same. That can reduce the effectiveness of prompt caching.
The updated specification addresses this in two ways.
First, servers are expected to return tools in a deterministic order.
Second, list and resource responses include caching information.
The ttlMs field indicates how long a response may remain fresh. The cacheScope field indicates whether the response may be cached publicly or should remain private to the client.
This allows MCP clients to avoid requesting the same catalogs repeatedly.
The benefits could include:
Faster connection and reconnection times.
Lower infrastructure traffic.
Reduced server load.
More stable prompts.
Better prompt-cache performance.
More predictable tool ordering.
Lower operating costs for large MCP platforms.
Caching is another sign that MCP is being shaped by practical production experience rather than only protocol theory.
Tasks Become an Official MCP Extension
Some AI operations complete in seconds. Others may take minutes, hours, or longer.
An AI tool might generate a detailed report, process a large collection of documents, render a video, train a model, analyze a codebase, migrate information, prepare a data export, or run an approval workflow.
These operations should not depend on a single request remaining open until the work is finished.
MCP previously introduced experimental support for Tasks. In the 2026-07-28 release, Tasks move out of the experimental core and become an official extension.
The updated Tasks extension uses task handles and polling.
A server can return a task identifier when an operation will continue in the background. The client can check the task’s status using tasks/get.
The new tasks/update method also allows the client to provide additional information to a running task.
This is useful when a long-running operation reaches a point where it requires approval or new input.
Notifications are also reorganized through a subscription model. Clients can opt into the categories of changes they want to receive instead of keeping older forms of protocol communication alive.
Why Tasks matter for AI agents
Chat interfaces trained users to expect immediate answers.
Agents are changing that expectation.
An agent may be asked to perform a complete business process rather than return a paragraph of text.
For example:
Research 300 potential customers and prepare personalized outreach.
Analyze a company’s codebase and propose a migration plan.
Review several years of financial data.
Produce a full presentation with supporting charts.
Reconcile records between two business systems.
Process an entire folder of contracts.
Create and publish a marketing campaign.
Monitor an operation until a defined condition is reached.
These are not simple tool calls. They are jobs.
Standardized Tasks allow MCP servers and AI clients to represent these jobs more reliably.
The user should be able to see that work is still running, check its progress, supply more information, cancel it where supported, and receive the result later without depending on one fragile connection.
This is essential if MCP is going to support serious agentic applications rather than only quick lookups and basic actions.
MCP Apps Bring Interactive Interfaces Into AI Conversations
MCP began primarily as a way to expose data and callable tools.
However, text alone is not always the best interface.
A chart is easier to understand visually.
A project timeline is easier to edit through a graphical interface.
A form may be safer than asking an AI model to interpret a loosely written response.
A design is better reviewed on a canvas.
A message is easier to approve when the user can see its final formatting.
MCP Apps is an official extension that allows an MCP server to provide an interactive user interface inside a compatible AI product.
Anthropic introduced interactive connectors in Claude using MCP Apps earlier in 2026. Examples include working with project timelines in Asana, previewing Slack messages, exploring analytics in Amplitude, viewing files from Box, creating visual materials with Canva, generating diagrams through Figma, and interacting with data visualizations from Hex.
The MCP 2026-07-28 specification places MCP Apps inside a formal, versioned extensions framework.
This is important because it separates the stable core protocol from optional capabilities.
The core can remain relatively small and dependable.
Extensions can add richer features without forcing every MCP client or server to implement them.
A client and server can advertise which extensions they support. They can then use MCP Apps, Tasks, enterprise authorization, or future extensions when both sides understand them.
Why interactive MCP Apps change the product experience
The traditional chatbot pattern is simple:
The user writes text.
The AI writes text back.
Even when the AI uses external software, the result often returns as another text response.
MCP Apps move Claude toward a hybrid interface.
Conversation remains the primary control layer, but specialized software interfaces can appear when they are more useful than text.
A user might ask Claude to analyze sales performance. Claude could call an analytics connector and display an interactive chart. The user could modify the date range, filter a segment, or select a metric without writing another detailed prompt.
A user could ask Claude to plan a project. Claude could display an editable timeline supplied by a project management platform.
A user could ask Claude to draft a client message. The connector could show a formatted preview with buttons for editing, approving, or sending.
This means Claude does not need to recreate the entire interface of every connected product.
The connected application can provide the interface best suited to its own data and workflows.
Claude supplies the natural-language reasoning and orchestration layer around it.
Authorization Is Being Hardened for Enterprise Use
Connecting an AI system to business software creates serious security questions.
Which user is making the request?
Which organization do they belong to?
What data can they access?
Which actions are they allowed to perform?
How should access be revoked?
What happens when the same connector works across personal and business accounts?
How can a company enforce its existing identity policies?
Anthropic says authorization has been one of the most time-consuming parts of MCP implementation.
The updated specification introduces several security and compatibility improvements.
Clients must more carefully validate the identity of authorization servers. Credentials are tied to the issuer that created them and should not be reused with another authorization server.
The specification also improves how desktop and command-line clients identify themselves during OAuth registration, reducing common redirect errors.
Dynamic Client Registration is being deprecated in favor of Client ID Metadata Documents, although backward compatibility remains during the transition.
These changes bring MCP authentication closer to established OAuth 2.0 and OpenID Connect deployments. Anthropic says this should make it easier for MCP servers to work with enterprise identity platforms such as Microsoft Entra and Okta.
Enterprise-managed authorization in Claude
Anthropic is also building its own product layer on top of the protocol.
Its enterprise-managed authorization system allows an administrator to approve an MCP connector for an organization.
Employees can then inherit access based on the identity-provider groups and roles they already have.
Instead of each employee manually connecting and authorizing the same service, the connector can appear automatically when the employee logs into Claude.
Access can remain consistent across Claude chat, Claude Code, and Claude Cowork.
When an employee leaves the company or changes roles, connector access can be revoked through the company’s existing identity system.
Administrators can also prevent employees from accidentally linking personal accounts to business connectors.
This may sound like an administrative feature, but it is critical for adoption.
Companies are unlikely to connect AI systems to sensitive internal tools if permissions are inconsistent, difficult to audit, or dependent on every employee configuring integrations correctly.
Anthropic is trying to make MCP connectors feel like ordinary enterprise applications governed through the existing identity stack.
MCP Adds a Formal Extension and Deprecation System
Standards must evolve, but frequent changes can create uncertainty for developers.
If a protocol changes without a predictable transition period, companies may hesitate to build on it.
MCP 2026-07-28 introduces a formal feature lifecycle with Active, Deprecated, and Removed states.
Deprecated features receive a minimum transition period of 12 months before removal.
The specification now also maintains a registry of deprecated functionality.
Several earlier capabilities are being deprecated, including Roots, Sampling, Logging, the older HTTP and Server-Sent Events transport, and Dynamic Client Registration as the preferred authorization mechanism.
These features continue working during the transition, but new implementations are advised not to depend on them.
The extension framework serves a related purpose.
Instead of continuously expanding the core protocol, MCP can keep its foundation more stable while allowing optional functionality to develop independently.
MCP Apps, Tasks, and Enterprise-Managed Authorization are examples of features that can evolve as official extensions.
This resembles the way mature internet technologies separate a dependable core from optional modules.
It also gives developers a clearer answer to two questions:
What functionality can every modern MCP implementation be expected to support?
What functionality must be negotiated as an extension?
That distinction becomes more important as the ecosystem grows.
The Official SDKs Have Been Updated
A protocol specification has limited practical value if developers cannot easily implement it.
The MCP project maintains official SDKs that provide the libraries and APIs used to build clients and servers.
At launch, the four Tier 1 SDKs for TypeScript, Python, Go, and C# supported MCP 2026-07-28.
The Rust SDK also supported the new specification in beta.
The update includes migration costs, particularly for developers whose servers depended on protocol sessions or session identifiers.
Applications that rely on deprecated features will also need to plan transitions.
However, the availability of updated SDKs means developers can begin building against the new architecture immediately rather than waiting for implementation support to catch up.
For the MCP ecosystem, synchronized SDK support is important.
A standard can fragment when different programming languages support different subsets or versions. By updating the primary SDKs together, the project is attempting to make the new specification the common baseline.
How Anthropic Is Changing Claude Around MCP
Anthropic is presenting MCP as an open industry standard, not a private Claude integration format.
Other AI companies, development tools, cloud platforms, and software providers can implement it.
However, Anthropic also has a clear product advantage.
It created MCP, continues to invest in the protocol, and can rapidly add support throughout Claude.
The company is building several layers around the standard.
1. A connector directory
Claude’s connector directory gives users a place to discover MCP integrations.
Anthropic says the directory contains more than 950 MCP servers.
A standard alone does not solve discovery. Users still need to know that an integration exists, understand what it does, trust it, and activate it.
The directory turns an open protocol ecosystem into something closer to an application marketplace.
2. Interactive applications
MCP Apps allow connected services to provide graphical interfaces within Claude.
This changes connectors from invisible background tools into visible product experiences.
It also allows software companies to preserve their own workflows and interfaces instead of reducing everything to plain text.
3. Enterprise-managed authorization
Administrators can provision connectors through identity providers and manage access centrally.
This reduces setup friction while bringing MCP under familiar enterprise security controls.
4. Connector observability
Anthropic provides dashboards for developers with connectors published in its directory.
Developers can monitor adoption, errors, latency, and usage across Claude product surfaces.
This helps companies understand whether their connector is being used successfully and where it is failing.
5. Private-network connectivity
Anthropic is testing MCP tunnels that connect Claude to servers inside private company networks.
The internal MCP server does not need a public endpoint or inbound firewall rule.
This is particularly relevant for companies that want Claude to access internal systems without exposing those systems directly to the public internet.
6. Support across Claude products
Anthropic is not limiting MCP to its standard chat interface.
Connector access is being integrated across Claude chat, Claude Code, Claude Cowork, web, desktop, and mobile experiences.
The company is effectively making MCP one of the shared infrastructure layers behind the Claude product family.
Is Anthropic Turning Claude Into an AI Operating System?
Calling Claude an operating system would be premature and technically imprecise.
Claude does not replace Windows, macOS, Linux, Android, or iOS.
However, Anthropic is clearly expanding Claude beyond the role of a standalone chatbot.
Claude can increasingly act as a control layer above other applications.
The user describes an objective in natural language.
Claude determines what information and tools are required.
MCP connectors provide access to external systems.
Tasks manage longer-running work.
MCP Apps display specialized interfaces.
Enterprise authorization determines what the user may access.
Observability helps connector developers operate their integrations.
Private tunnels connect internal systems.
The underlying applications still store the data and perform specialized operations. Claude coordinates the experience.
A more accurate description may be that Anthropic wants Claude to become an AI work layer.
In this model, users do not begin every task by choosing an application.
They begin by describing the outcome.
Claude then brings the relevant applications into the conversation.
This does not eliminate traditional software. It changes how people enter and move between software products.
How the MCP Update Could Affect Software Companies
For established software companies, MCP is becoming a distribution channel.
A company may still provide its website, mobile application, APIs, browser extensions, and integrations. It may now also provide an MCP server so users can access its features through compatible AI products.
The immediate benefit is reach.
A single MCP implementation may work with multiple AI hosts instead of requiring a completely separate integration for each platform.
The deeper effect is that users may increasingly interact with software indirectly.
A customer might use a project management service through Claude without opening the project management application.
A designer might send generated material into Figma from an AI conversation.
A sales team might research prospects, retrieve customer records, create outreach, and update a CRM through one agent-driven workflow.
This creates both opportunity and risk.
Software companies can become part of more user workflows. But they may also lose direct control over the top-level customer interface.
The AI host could become the place where users begin their work, while connected applications become specialized service providers behind it.
MCP Apps partly address this risk by allowing software companies to bring their own interfaces into the AI environment.
However, the overall direction is still clear: AI products are trying to become the orchestration layer above existing business software.
How the Update Could Affect Developers
For developers building MCP servers, the new version should make production deployment more conventional.
Stateless requests simplify horizontal scaling.
Header-based routing works better with gateways and security infrastructure.
Cacheable catalogs reduce repeated work.
Tasks provide a standard model for long-running operations.
MRTR supports interactive clarification without permanent bidirectional sessions.
The extension system offers a structured way to adopt optional capabilities.
Authorization changes improve compatibility with enterprise identity platforms.
OpenTelemetry context propagation also helps teams trace MCP requests through distributed systems.
The tradeoff is migration.
Existing MCP servers may rely on initialization handshakes, session IDs, older Server-Sent Events behavior, Roots, Sampling, Logging, or Dynamic Client Registration.
Developers should not assume that updating an SDK version will be sufficient.
They will need to examine how their applications handle state, discovery, authentication, notifications, tool catalogs, interrupted requests, and deprecated features.
The protocol is becoming easier to scale, but some of that improvement requires breaking with earlier assumptions.
How the Update Could Affect General Users
Most Claude users will never read the MCP specification.
They may still notice its effects.
Connectors should become easier for developers to operate at scale.
More applications may become available inside Claude.
Interactive interfaces may reduce the need to switch between tabs.
Long-running jobs may become more reliable and easier to track.
Enterprise connectors may appear automatically based on company permissions.
Internal tools may become accessible without complicated public infrastructure.
Authentication errors may become less common.
Tool catalogs may load faster because clients can cache them.
Users may also receive more consistent experiences across Claude chat, Claude Code, Cowork, desktop, web, and mobile.
The most important change is conceptual.
Claude may increasingly feel less like a chatbot that occasionally calls an external tool and more like a workspace connected to the rest of a user’s software.
What MCP 2026-07-28 Does Not Solve
The update is significant, but it does not automatically solve every problem associated with AI integrations.
Security still depends on implementation
A stronger authorization standard does not prevent a badly designed tool from exposing excessive permissions.
Developers still need to validate inputs, protect credentials, limit access, review tool behavior, and defend against malicious instructions.
Standardization does not guarantee quality
Two MCP servers can follow the same protocol while providing very different reliability, documentation, performance, and user experiences.
MCP standardizes communication. It does not guarantee that every integration is useful.
Agents can still make mistakes
An AI model may select the wrong tool, misunderstand a request, use incorrect parameters, or perform an action the user did not expect.
Confirmation interfaces and permission controls remain important, particularly for destructive or financial actions.
Application providers may resist interface displacement
Some software companies may not want AI hosts to become the main interface through which customers use their products.
They may restrict capabilities, reserve advanced features for their own applications, or design MCP experiences that deliberately return users to the original platform.
The ecosystem can still fragment
MCP is open, but different hosts may support different extensions, interface capabilities, authorization models, and approval patterns.
A connector may technically work across several hosts while offering its richest experience only in one.
Migration will take time
Support for the new specification is rolling out across Claude products. Existing MCP infrastructure will not move to the new version immediately.
For a period, developers will need to support multiple protocol generations and compatibility paths. Anthropic stated at launch that Claude product support was still being rolled out.
Why This Update Matters Strategically for Anthropic
Anthropic competes in a market where model quality alone may not create a permanent advantage.
Frontier models continue to improve. Differences between providers can narrow. Users can switch products. Businesses may use several model providers at once.
The surrounding ecosystem therefore matters.
MCP gives Anthropic influence over the infrastructure through which AI systems interact with software.
Because the protocol is open, it has a better chance of achieving broad adoption than a Claude-only integration system.
Software companies have more reason to invest in MCP if the same server can work with several AI products.
At the same time, every new MCP server makes Claude more useful.
This creates a possible ecosystem loop:
More developers build MCP servers because multiple AI hosts can support them.
Claude supports those servers deeply across its products.
Users gain access to more tools and data.
More users create demand for higher-quality MCP integrations.
Software companies invest further in their MCP servers.
The protocol becomes more valuable, and Claude becomes more useful as one of its primary hosts.
Anthropic does not need to own every connected application. It needs Claude to be one of the best environments for discovering, authorizing, and using them.
The 2026-07-28 update supports that strategy by making MCP easier to scale, secure, extend, and operate.
Is MCP Becoming the Standard Protocol for AI Tools?
It is still too early to declare that the standards competition is finished.
However, MCP has moved beyond being a small Anthropic experiment.
The protocol is supported by major cloud providers, software platforms, development tools, infrastructure companies, and AI products.
The official release announcement included support or implementation statements from organizations including AWS, Cloudflare, Figma, Google Cloud, Microsoft, Netlify, Zoom, Intuit, and other members of the ecosystem.
The download numbers also indicate substantial developer activity.
The most important signal may be the nature of the new update.
Early protocols usually focus on adding capabilities.
MCP 2026-07-28 focuses heavily on scaling, caching, routing, authentication, observability, compatibility, deprecation, and migration.
These are the concerns of infrastructure that people are attempting to use seriously.
MCP is no longer only answering the question:
“Can an AI model connect to an external tool?”
It is now answering harder questions:
Can thousands or millions of users connect reliably?
Can companies deploy servers through normal cloud infrastructure?
Can security teams govern access?
Can developers monitor failures?
Can long-running work survive beyond a single request?
Can interfaces appear inside the AI experience?
Can the standard evolve without constantly breaking production systems?
The new specification does not prove that MCP will become universal.
It does show that the project is being engineered for that possibility.
The Larger Direction: AI Products Are Becoming Integration Platforms
The first stage of consumer generative AI focused on conversation.
The user entered a prompt, and the model generated text, images, audio, video, or code.
The next stage is increasingly about action.
AI systems are expected to retrieve private information, use business software, coordinate workflows, create structured outputs, request approvals, and complete tasks across multiple services.
This requires more than better models.
It requires infrastructure.
The AI system needs standardized tools, secure identities, permission boundaries, task status, application interfaces, error handling, observability, and reliable deployment.
MCP is Anthropic’s attempt to create that infrastructure as an open standard.
Claude is becoming Anthropic’s implementation of what the user experience can look like when the infrastructure matures.
The model provides intelligence.
MCP provides connections.
Tasks provide persistence.
MCP Apps provide interfaces.
Enterprise identity provides access control.
The connector directory provides discovery.
Observability provides operational feedback.
Tunnels provide private connectivity.
Together, these pieces point toward a version of Claude that operates less like a single application and more like a connected environment for work.
Final Takeaway
MCP 2026-07-28 is the protocol’s most important update so far because it addresses the difference between a promising developer standard and production infrastructure.
The stateless core makes MCP easier to deploy on ordinary cloud, edge, and serverless systems.
Multi Round-Trip Requests preserve interactive workflows without requiring permanent bidirectional sessions.
Tasks create a standardized foundation for longer-running agent work.
MCP Apps allow real application interfaces to appear inside AI conversations.
Caching, routing headers, observability conventions, hardened authorization, and formal deprecation rules make the protocol more manageable for serious deployments.
Anthropic is simultaneously integrating these capabilities into Claude through its connector directory, interactive applications, centralized enterprise authorization, connector analytics, private-network tunnels, and support across its product family.
The protocol and the product are developing together.
MCP gives software companies a common way to expose tools and context to AI.
Claude gives users a place to use those tools through conversation, interfaces, and agentic workflows.
The ultimate significance of the update may not be that MCP gained several new features.
It is that MCP is beginning to resemble the infrastructure layer required for AI systems to become connected platforms rather than isolated chatbots.
Frequently Asked Questions
What is MCP 2026-07-28?
MCP 2026-07-28 is the fifth major specification release of the Model Context Protocol. It introduces a stateless protocol core, Multi Round-Trip Requests, standardized extensions, stronger authorization, cacheable results, improved routing, official Tasks support, and a formal feature-deprecation policy.
What is the biggest change in the new MCP version?
The biggest change is the removal of protocol-level sessions. Each request now carries the information needed to process it, allowing MCP servers to scale across ordinary load balancers, serverless platforms, and distributed cloud infrastructure without relying on sticky sessions.
Does stateless MCP mean applications cannot remember anything?
No. Applications can still maintain state. The difference is that state should be represented explicitly through task identifiers, handles, tool parameters, databases, or application-level resources rather than being hidden inside a transport session.
What are MCP Tasks?
Tasks are an official MCP extension for work that does not finish immediately. A server can return a task handle, and the client can check its progress or provide additional input while the operation continues.
What are MCP Apps?
MCP Apps allow an MCP server to provide an interactive interface inside a compatible AI product. Instead of returning only text, a connector can display charts, forms, previews, timelines, diagrams, and other application-specific interfaces.
What are Multi Round-Trip Requests?
Multi Round-Trip Requests allow an MCP server to ask for more information while processing an operation. The server returns an input-required result, the client gathers the requested information, and then retries the original operation with the answers attached.
Why did MCP remove sessions?
Protocol-level sessions made distributed deployment more complicated. Stateless requests can be sent to any compatible server instance, making horizontal scaling, load balancing, serverless deployment, and failure recovery easier.
Is MCP owned by Anthropic?
MCP was created by Anthropic, but it is developed as an open protocol with public specifications, SDKs, community contributions, and support from companies throughout the AI and software ecosystem.
How is Anthropic using MCP in Claude?
Anthropic uses MCP to power connectors across Claude. It is also adding a connector directory, interactive MCP Apps, enterprise-managed authorization, developer observability, private-network tunnels, and support across Claude chat, Claude Code, Claude Cowork, web, desktop, and mobile.
Will MCP replace APIs?
MCP does not replace ordinary APIs. An MCP server often uses existing APIs behind the scenes. MCP creates a standardized AI-oriented layer that describes tools, resources, prompts, interactions, and capabilities in a format that compatible AI clients can understand.
Will existing MCP servers stop working?
Not immediately. Some features are deprecated rather than removed, and the new lifecycle policy provides a minimum 12-month deprecation period. However, developers should review their use of sessions, initialization, old HTTP and SSE transport, Roots, Sampling, Logging, and Dynamic Client Registration.
Does Claude already support MCP 2026-07-28?
Anthropic announced that support was being rolled out across Claude products following the July 28, 2026 release. Availability may therefore vary by Claude product and deployment during the rollout period.
Why is MCP important for AI agents?
Agents need reliable ways to access data, call tools, request approval, continue long-running work, and operate across different applications. MCP attempts to standardize these connections so every AI product and software platform does not need a completely separate integration system.
Could MCP become the standard connection layer for AI?
MCP has strong momentum, broad ecosystem support, and substantial developer activity. However, its long-term position will depend on adoption by AI hosts, software companies, enterprise customers, and developers, as well as how consistently different products implement the standard.