The Model Context Protocol’s 2026 release candidate, published on May 21, 2026, makes the protocol stateless at its core — removing the session-state handshake that made scaling MCP servers hard — and sets July 28, 2026 as the date the final specification locks in. The practical question for agent developers right now is not whether the change matters but what it requires you to do during the 10-week validation window, and which tools help you navigate an ecosystem still catching up to a specification that has not yet finalized.
The RC arrived into an already large and fast-moving ecosystem. Server counts vary widely by source and crawl method — Glama reports roughly 31,644, MCPfinder’s aggregate covers about 27,432, PulseMCP tracks 16,820+ — and none are authoritative totals, since each directory crawls and deduplicates differently. What is clear is that Salesforce Hosted MCP Servers reaching general availability in April 2026, for Enterprise Edition organizations and above, added the largest managed MCP endpoint to reach production ahead of the final specification. The broader pattern — major enterprise platforms shipping MCP support while the protocol is still in RC — is what defines the 2026 ecosystem.
Glama ranks as the best tool for discovering and evaluating servers under the new spec, where rich per-server metadata and a try-before-install sandbox are the right instruments for the RC window. MCPfinder is the top pick for the distinct and growing use case of agent-native discovery — when the AI, not a human, needs to find and configure a server programmatically. Below we rank six tools, explain what the stateless change actually means, and note what it does not fix.
What “stateless at the protocol layer” means in practice
The RC removes two things that previously tied sessions together: the initialize/initialized handshake and the Mcp-Session-Id header. In the current spec, a client must open a persistent connection, exchange handshake messages, and track the resulting session ID; the server then routes every subsequent request from that client to the same process instance, usually through sticky sessions on a load balancer. That works for small deployments but breaks horizontal scaling — add a second server instance and you need session affinity, shared state, or a centralized session store.
The RC moves state management to the application layer. Each request now carries its protocol version, client identity, and capabilities in the _meta field of the JSON-RPC envelope. State previously held in a session — say, which document is open, or which transaction is in progress — is returned as an explicit handle by the tool that created it, and the model passes that handle as an argument on subsequent calls. Any standard load balancer can now route MCP traffic without sticky sessions.
Two new HTTP headers make this operationally clean: Mcp-Method identifies the MCP method being called without requiring the load balancer to parse the JSON-RPC body, and Mcp-Name identifies the target server. Response caching gets first-class support via ttlMs (time-to-live) and cacheScope fields. Together these are the changes that move MCP from a protocol that mostly ran locally over stdio into one designed to run cleanly at scale as an HTTP service.
Salesforce’s April 2026 GA — enterprise adoption before the final spec
The stateless upgrade matters partly because of what is arriving to use it. Salesforce Hosted MCP Servers reached general availability in April 2026 for Enterprise Edition organizations and above, following a pilot in spring 2025 and a beta in October 2025. They expose Salesforce data, flows, Apex actions, and query capabilities as managed MCP endpoints — meaning an enterprise agent stack can reach a company’s entire Salesforce organization through the same protocol interface as any community open-source server. This follows a broader pattern: OpenAI, Google, Microsoft, and Salesforce all shipped MCP support within roughly 13 months of the protocol’s launch, and GA endpoints from major enterprise platforms are now arriving before the specification itself has finalized.
For discovery tooling, this creates a genuinely new categorization challenge. Managed enterprise endpoints behave differently from community-contributed open-source servers — they are more likely to implement the RC’s authorization hardening (OAuth 2.1 and OpenID Connect alignment) but also more likely to be gated behind enterprise licensing. Distinguishing between open-ecosystem community servers, hosted managed endpoints, and enterprise-gated services is a problem the current generation of directories is only beginning to solve.
Why agent-native discovery matters more, not less, in a stateless world
Counterintuitively, the shift to stateless increases the value of good discovery tooling. In a session-bound world, an agent’s MCP configuration was typically baked in at startup — you initialized a fixed set of servers and used them for the session’s lifetime. In a stateless world, where any request can reach any server instance and state is explicit in every call, there is no structural reason to limit configuration to startup time. An agent can discover which server handles a specific request at call time, pass explicit handles between calls, and include a server it did not know about when the session opened.
MCPfinder is the only discovery tool currently designed for this runtime-discovery use case. Because it is itself an MCP server, an agent calls search_mcp_servers to find candidates, get_server_details to check trust signals and warning flags, and get_install_config to receive client-specific JSON — all inside a single agent workflow without a human browsing a website. The open-source MCPfinder project aggregates the Official Registry, Glama, and Smithery, so the agent searches the same ecosystem a developer would find on those directories manually. That discover-evaluate-install loop becomes more natural, not less, when the server being discovered does not require a fresh session initialization on every call.
Three deprecations and what to do before the 12-month window closes
The RC puts three protocol features into a 12-month deprecation window: roots, sampling, and logging. All three remain fully functional during that window, but removal is scheduled once it closes. Roots allowed servers to declare filesystem paths they would accept; sampling let servers request LLM completions from the connected client; logging provided a structured log-forwarding mechanism. If your MCP server or client uses any of these, check the RC blog post for the migration path, and begin adapting during the 10-week validation window — which runs through July 28, 2026 — while the API surface is still in open discussion. The RC’s formal deprecation policy guarantees a 12-month minimum runway, so there is time to plan; the clock started May 21.
The Extensions Framework introduced in this RC is the structural replacement for some of this surface: extensions now have first-class status with reverse-DNS identifiers and independent versioning, and two official extensions debut with the RC — MCP Apps (server-rendered HTML UIs in sandboxed iframes) and Tasks (redesigned as an optional extension for long-running operations). These represent the direction for feature additions going forward rather than the core protocol surface.
What going stateless does not fix: security exposure remains
The stateless protocol change resolves session-management complexity but does not address the security exposure that has been growing in parallel with ecosystem scale. In an April 2026 internet-wide scan, Censys identified 12,520 Internet-accessible MCP services — most reachable without any authentication. The RC does include authorization hardening: six spec-enhancement proposals align MCP with OAuth 2.1 and OpenID Connect, including issuer validation and application-type declaration at registration. But those controls depend on server operators implementing them, and the gap between “the protocol allows it” and “deployments require it” is exactly where the exposure lives.
The discovery tools most relevant to this risk surface are those that surface per-server security metadata, not just catalog breadth. Glama’s per-server security audits and quality scores, the Official MCP Registry’s namespace authentication (which guarantees a listing comes from its claimed publisher), and MCPfinder’s inline trust signals and warning flags — which let an agent weigh a server’s risk profile before generating install config — are the discovery-layer responses to a concern the RC partially but not fully addresses. In an ecosystem where more than 12,000 services were reachable without authentication as of April 2026, the verification layer remains the most practical defense a discovery tool can offer.