GitHub MCP Server Adds Stateless Protocol Support Before July 28 Release

On July 28, 2026, the Model Context Protocol (MCP) moves to a stateless core, and the GitHub MCP Server already supports the new specification ahead of that date. The update removes sessions and the initialize handshake, cuts database reads from every call, and introduces official conformance tests for the first time. Tier 1 SDKs have shipped beta support with backwards compatibility preserved, meaning most developers do not need to change anything to keep working.

What happened

Detail	Fact
Protocol release date	July 28, 2026
GitHub MCP Server status	Already supports the new spec ahead of release
SDK used by GitHub	Official Go SDK
Sessions / initialize	Both removed from the spec
Redis sessions	Removed: database writes on initialize and reads per call are gone
Conformance tests	Now officially included in the MCP spec

MCP (Model Context Protocol) is the open standard that lets AI agents talk to external tools and servers, including GitHub’s own integrations with Copilot. The next version of the spec makes the protocol stateless, meaning servers no longer need to maintain session state between requests.

What exactly is changing in the protocol?

The biggest structural shift is that sessions and the initialize step are gone. Previously, a client had to complete a sequential handshake before it could do anything useful. Under the new spec, clients can complete that handshake in parallel, which speeds up connection time. Stateless servers are also much simpler to scale horizontally since there is no shared session state to synchronize.

The spec also formalizes extensions that enable things like MCP apps and Enterprise Managed Auth (both already supported in VS Code). Multi round-trip requests are now supported too, which opens the door for features like elicitation (prompting a user for input mid-task) on more remote servers.

Three specific changes GitHub made to its MCP Server

1. Removed Redis sessions. Database writes that happened on every initialize call are gone. So are the database reads that were attached to every subsequent call. The result is faster responses with no loss of functionality for users.
2. Avoided deep packet inspection. GitHub needs to read certain values from MCP requests for logging and secret scanning. The new spec guarantees those values are available in HTTP headers, so GitHub no longer has to inspect the full payload of every request before the SDK processes it.
3. Upgraded elicitation support. The stdio MCP server uses URL elicitation to handle user login. In the new protocol, each step in that flow is a separate HTTP request. GitHub used a wrapper from the Go SDK to support both the old and new mechanism simultaneously, keeping things working for older clients.

Why it matters

Stateless infrastructure is genuinely easier to operate at scale. If you run your own MCP server today, removing session state means you can run multiple instances behind a load balancer without sticky sessions or a shared Redis cluster. That is a real operational simplification, not a minor version bump.

The conformance test suite is arguably as significant as the protocol changes themselves. Before this, verifying that a client or server correctly implemented MCP was largely manual. Now there are official tests you can point at a codebase. According to GitHub, you can let Copilot run those tests by giving it access to the conformance suite, the draft spec documentation, and any tier 1 SDK implementation. That makes AI-assisted development of MCP tooling much more reliable to verify.

For teams building AI integrations on top of GitHub or Copilot, this is a good moment to review whether your server still carries Redis or session overhead that the new spec makes unnecessary. The gains are free if you upgrade.

Our take

The stateless move is the right call, and GitHub shipping support before the official date is a good sign that the spec process is maturing. The Redis removal is the kind of quiet, unglamorous improvement that actually matters in production: fewer moving parts, lower latency, less to debug at 2am.

The conformance tests are the part we are most interested in. Any time a protocol gets an official test suite, the quality of third-party clients and servers tends to jump. Right now MCP tooling quality is uneven. Expect that to improve. If you are building custom MCP clients or servers, running the conformance suite against your code should be one of the first things you do after July 28.

We have been watching the broader Copilot agent ecosystem expand quickly this year. Stateless MCP is part of what makes that scale without becoming a maintenance burden.

What to do about it

1. Check which MCP SDK version your project uses and confirm it has shipped beta support for the new spec (all tier 1 SDKs have, according to GitHub).
2. After July 28, audit your server setup for Redis session dependencies that can now be removed.
3. Run the official MCP conformance tests against any custom client or server you maintain.
4. If you use Copilot, point it at the conformance suite, the draft spec docs, and a tier 1 SDK to let it help verify your implementation.

The backwards compatibility guarantee means you can upgrade at your own pace, but the sooner you drop session overhead, the sooner your MCP server gets cheaper to run.

Source: GitHub Changelog