MCP quietly ran on borrowed architecture for its first year and a half. Every server your marketing stack talks to, from a CRM connector to a brand asset library, assumed a persistent session and a single machine keeping track of it. On July 28, the Agentic AI Foundation shipped the spec update that finally admits that assumption never scaled, and most marketing teams have not noticed the ground moved under the integrations they turned on this year.
This is not a minor changelog entry. MCP went fully stateless, added a formal enterprise authorization extension built with Okta, closed a real class of authentication attack, and put a 12-month clock on every future breaking change. If your team wired up a Salesforce, Canto, or Presentations.AI MCP server in the last few months, all four of those changes land directly on infrastructure you already depend on.
What Actually Changed on July 28
The old MCP model required sticky routing. A client opened a session with a specific server instance, and that instance held the state for the rest of the conversation. It worked fine for a single developer testing a tool call, and it fell apart the moment a company tried to run the protocol behind a standard load balancer. One AAIF executive described running into companies deploying tens of thousands of agents and hitting session management as the wall that stopped pilots from becoming production.
The new spec removes that requirement entirely. State moves through the transport layer instead of living on a server, so any request can land on any instance behind a Kubernetes deployment or a cloud load balancer, the same way a normal web request does. The tradeoff is payload size: state that used to sit quietly on a server now travels with every call. Official SDKs across TypeScript, Python, Rust, Java, and C# absorb most of that complexity, so the migration cost for a marketing team consuming someone else's MCP server is close to zero. The migration cost for a vendor building one is not, which is exactly why you need to check whether the vendors feeding your stack actually finished the move.
Two extensions graduated to official status in the same release. MCP Apps lets a server return a rich interactive interface instead of plain text, and MCP Tasks formalizes long-running asynchronous work, the kind a campaign build or a bulk content generation job actually needs. Neither is optional infrastructure anymore. Both are things an agent vendor can now legitimately ship, and both are things your review process has probably never tested.
| Capability | Before July 28 | After July 28 |
|---|---|---|
| Session model | Stateful, sticky routing required | Fully stateless, any instance can serve any request |
| Auth | Ad hoc API keys and shared logins | Enterprise Managed Authorization extension, corporate IdP-controlled |
| Breaking changes | No formal notice window | 12-month deprecation window guaranteed |
| Long-running work | Not natively supported | MCP Tasks extension, formal async operations |
| Rich responses | Text only | MCP Apps extension, interactive interfaces |
The Security Fix Nobody Announced Loud Enough
Buried inside the stateless rewrite is a mandatory validation rule for OAuth issuer parameters. Before this spec, a poorly implemented MCP server could be tricked into accepting a token from the wrong identity provider, a mix-up attack that lets an attacker impersonate a legitimate session without ever stealing a credential. The new spec closes that hole by requiring every compliant server to validate the issuer field, not just the token signature.
Pair that with the new Enterprise Managed Authorization extension, developed jointly with Okta, and the access model for MCP servers changes completely. Instead of a marketing ops person generating an API key and pasting it into a config file, a corporate identity provider can now govern who is allowed to connect to which server, the same way it already governs who gets into Salesforce or Slack. That is the difference between an integration you can audit and one you find out about when someone leaves the company and nobody remembers to revoke their key.
Here is the problem: none of this is retroactive. A vendor's MCP server does not automatically start validating issuers or supporting centralized auth because the spec now requires it. Every MCP connection your team already has, whether it is feeding campaign data into a CRM or pulling brand assets into an agent workflow, needs to be checked against the actual server implementation, not the spec document.
MCP
- List every MCP server your team connects to, including ones added by individual contributors without a formal review
- Ask each vendor directly whether their server enforces OAuth issuer validation per the July 28 spec
- Check whether Enterprise Managed Authorization is available and route new connections through your identity provider instead of shared API keys
- Confirm whether each server has moved to a stateless deployment or still requires sticky session routing on your side
- Put the 12-month deprecation policy into your vendor renewal calendar, not just your engineering backlog
The 12-Month Clock You Didn't Know Was Ticking
Marketing ops teams do not track API changelogs the way engineering teams do, and MCP servers have quietly become an integration surface with the same fragility as an API but none of the same ownership. The formal deprecation policy fixes half of that problem. Vendors now owe you a 12-month window between a deprecation notice and actual removal, which is a real, enforceable guarantee that did not exist before July.
It does not fix the other half. Nobody is going to forward you that deprecation notice unless you ask who receives it. If the person who set up your Salesforce MCP connection left the company, that notice is going into an inbox nobody reads, and you will find out your integration broke on the day it stops working instead of twelve months earlier when you had time to plan. Treat every MCP server the same way you already treat a critical API dependency: name an owner, get the vendor's deprecation contact in writing, and put a calendar reminder to check server status alongside your quarterly martech stack review.
Do the Audit Before the Next Vendor Announcement
SDK downloads for MCP roughly doubled in the six months leading into this release, which means the servers piling onto your stack are shipping faster than your governance process can review them. The spec update did the hard part. It gave marketing teams a real authorization model, a real deprecation guarantee, and a protocol that can actually run in production instead of falling over the first time two agents hit the same server at once.
None of that helps you if the servers you are already running were built to the old rules and nobody checked. The teams that run the audit above this week will be the ones who catch a broken integration in a planning meeting. The teams that skip it will catch it in a Slack message from someone whose campaign just stopped working, with no idea why.
Tags
LETSGROW Dev Team
Marketing Technology Experts
Ready to Apply This Insight?
Schedule a strategy call to map these ideas to your architecture, data, and operating model.
Schedule Strategy Call