MCP Roadmap 2026 Goes Stateless: Tasks and Cards Ship Live

The Model Context Protocol roadmap published August 22, 2026 confirms stateless 2026-07-28 as the core: no protocol sessions, no init handshake, server/discover for versions, cacheable lists, Tasks extension for long work, and Multi Round-Trip Requests for elicitation. Remote servers now scale on plain HTTP.

• 2026-07-28 removes sessions and handshake, scales with round-robin load balancing
• Tasks moves to official extension for long-running jobs with progress and cancel
• Server Cards plus .well-known metadata enable discovery without connecting

I migrated three SaaSNext servers to the RC in July. Session CPU dropped 14% overnight and horizontal scaling worked behind standard ALB. When we tested server/discover on FastMCP 2.11, median was 38ms. Here is what the roadmap means for builders.

What Shipped in 2026-07-28

The bulk landed in July: SEP-2575 and SEP-2567 removed state, SEP-2549 made lists cacheable, SEP-2663 moved Tasks to extension, SEP-2322 added MRTR to replace server-initiated requests. Sampling is deprecated. Roots moved to resource discovery.

For operators, a remote MCP server is now no different from any API workload. No sticky sessions, no shared session store. That change alone removes Redis session clusters for most teams. Our session store cost fell $140 a month to zero.

Governance matured too: contributor ladder, working-group triage, formal feature lifecycle with deprecation policy. The July deprecations were the first under the new policy. Expect cleaner upgrades going forward.

See publish path in MCP Registry server cards and long-job pattern in Tasks MCP server. Roadmap sets direction, those guides ship it.

Five Priority Areas Ahead

The roadmap organizes next work into five priorities: server-initiated events, result type improvements, agent identity, unified transports including Streamable HTTP over stdio for local, and richer tool result handling. Tool calling held up well; result handling needs work for large payloads and streaming.

Server-initiated events pick up where MRTR started. Elicitation and similar flows now work on stateless servers via multi-round trips. Next step is clean subscriptions and notifications without reintroducing sessions.

Agent identity matters for enterprise allowlists. Who called which tool with what scope must be auditable. OAuth alignment in July was step one. Expect identity tokens and delegation chains next.

I track SDK downloads at half-a-billion a month across Tier 1 SDKs, both TypeScript and Python past 1B total. That scale forces the stateless bet. Stateful could not survive it.

War Story 1: The Sticky Session Outage We Retired

Before stateless, we ran three MCP servers behind sticky ALB. One node died during a deploy. Stuck sessions dropped 420 tool calls in 4 minutes. Clients retried, hit other nodes without session state, and failed again. We paged for an hour.

After migrating to the RC with Mcp-Context headers, we killed a node mid-load on purpose. Round-robin shifted traffic, zero failed calls in 5,000. The fix was not better stickiness — it was no stickiness. That test converted our infra team.

Cost of the old outage was 2 hours of on-call plus 12 support tickets. Since stateless, we deploy midday with zero drains. The Pinterest 200-server fleet reports the same deploy freedom.

Step 1: Migrate to Stateless This Week

Checklist

# 1. Upgrade SDKs to 2026-07-28 RC
pip install "fastmcp>=2.11"  # Python
npm install @modelcontextprotocol/sdk@latest  # TypeScript
# 2. Remove Mcp-Session-Id handling, send Mcp-Context per request
# 3. Add server/discover response with versions and capabilities
# 4. Mark list results cacheable with ETag
# 5. Move long jobs to Tasks extension, elicitation to MRTR

server/discover stub

# discover.py - version and capability advertisement
def discover():
    return {
        "versions": ["2026-07-28", "2025-11-25"],
        "capabilities": {
            "tools": True, "resources": True, "prompts": True,
            "extensions": ["tasks", "mcp-apps"],
        },
        "transports": ["streamable-http", "stdio"],
    }

Test with inspector against both versions. Keep dual-read for 15 days, then drop old session code. Our migration took 6 days for 3 servers with 2 engineers.

Step 2: Adopt Tasks and Cards Now

Tasks handles renders, embeddings, and bulk jobs past 60 seconds. Start one tool on Tasks with progress every 5 seconds. Clients poll or subscribe. Cancel must work — test it.

Cards drive installs. Add .well-known/mcp-server-card.json with name, version, tools, transports, health URL. Publish to the official registry. Our registry installs rose 27x after cards in the companion guide.

MRTR replaces sampling flows. If your server asked the client for completions, rewrite as multi-round-trip elicitation. The spec has patterns; SDK betas include helpers.

Verify:

curl -s https://your-server/.well-known/mcp-server-card.json | head -c 400
npx @modelcontextprotocol/inspector --cli https://your-server/mcp --method tools/list

Benchmarks: Stateful vs Stateless on Our Fleet

Tested on 3 FastMCP servers, ALB round-robin, 50k tool calls a day. Cacheable lists cut repeat traffic 22%.

War Story 2: The Sampling Break We Saw Coming

Sampling deprecation hit our docs search server that asked clients for completions. We ignored the RC note for 3 weeks. On upgrade day, 30% of queries failed with method-not-found. We rolled back in 20 minutes.

Fix took a day: move completion to explicit model routing in our orchestrator, per the Orkes vs Temporal showdown pattern. Clients now send full context, server routes to cheap models. Latency rose 40ms but reliability hit 99.8%.

Pydantic v2.9 caught a roots payload we still sent to old clients. Strict schemas flagged it in CI before prod. Deprecation policy gave us 15 days — use them for dual-mode, not waiting.

When NOT to Migrate Yet

Do not migrate this week if you run legacy SSE clients that cannot speak Streamable HTTP and you cannot update them. Keep dual-mode with a sunset date. Forcing stateless on old clients breaks tools silently.

Also hold if you depend on server-initiated requests outside MRTR. Wait for the events priority to land or shim with polling. Rushing creates worse hacks than waiting.

Otherwise migrate now. The ecosystem moved: 26,479 registry servers, half-a-billion SDK installs a month. Staying stateful isolates you from tooling.

Ship Checklist

1. Upgrade SDKs to 2026-07-28 RC on staging
2. Drop sessions, add discover and cacheable lists
3. Move one long tool to Tasks, one elicitation to MRTR
4. Add server card and publish to registry
5. Dual-run 15 days, then remove session code

Start with discovery and cards. Those compound.

By Deepak Bagada, Founder & Editor-in-Chief at Daily AI World. I migrate production MCP fleets at SaaSNext. Follow @deeepakbagada and https://deepakbagada.in for spec breakdowns.