Protocol Eras: Legacy 2025 vs Modern 2026-07-28
Module 0 — Foundations
MCP has two behavioral families, called eras. Understanding them prevents confusion when you read older tutorials or connect to existing hosts. This article explains the difference and why the modern era matters.
The Two Eras
An era is a behavior family, not a single version string.
Legacy era — every protocol revision from 2024-10-07 through 2025-11-25. Opens with an initialize handshake and (on HTTP) can use session IDs.
Modern era — starts with the 2026-07-28 specification. Stateless. Every request carries its own protocol version and client capabilities in a _meta envelope. No initialize handshake and no Mcp-Session-Id.

Legacy relies on a handshake and sessions. Modern is stateless and self-describing.
Aspect | Legacy (2024–2025) | Modern (2026-07-28) |
|---|---|---|
Connection start |
| No handshake; |
Identity / capabilities | Stored from the handshake | Carried in every request’s |
HTTP sessions | Optional | Removed |
Change notifications | Unsolicited | Explicit |
Server-to-client asks (elicitation, sampling) | Server sends its own requests | Tool returns |
Scaling | Sticky sessions often required | Any instance can answer any request |
Why the Modern Era Matters
The 2026-07-28 revision made the protocol stateless. That has practical consequences:
Easier scaling — remote servers no longer need sticky sessions or a shared session store. You can put an MCP endpoint behind an ordinary load balancer.
Simpler observability — every request is self-contained. Logs and traces do not depend on correlating a session ID.
Better caching — list results can carry ttlMs and cacheScope hints.
Clearer multi-round-trip flows — tools that need extra user input return inputRequired instead of holding open streams.
Several features (Roots, Sampling, Logging, the old HTTP+SSE transport) are deprecated with a twelve-month window. They still work, but new code should not adopt them.
How the TypeScript SDK Handles Both Eras
The official TypeScript SDK v2 (@modelcontextprotocol/server and @modelcontextprotocol/client) implements the modern 2026-07-28 specification, yet it can still speak to legacy clients.
Servers: serveStdio(factory) and createMcpHandler(factory) serve modern traffic by default. With the default legacy: 'stateless' option they also answer legacy clients from a fresh instance of your factory. You can set legacy: 'reject' to make an endpoint modern-only.
Clients: By default a client still performs the 2025 initialize handshake. Opt in to modern negotiation with versionNegotiation: { mode: 'auto' } (or pin the modern revision). After connecting you can inspect client.getProtocolEra().
// Client that prefers the modern era and falls back if needed
const client = new Client(
{ name: 'my-client', version: '1.0.0' },
{ versionNegotiation: { mode: 'auto' } }
);
await client.connect(transport);
console.log(client.getProtocolEra()); // 'modern' | 'legacy'Practical Guidance for This Tutorial
This tutorial targets the modern 2026-07-28 era and the v2 packages. You will write servers that work with both current and legacy hosts because the SDK’s serving helpers support dual-era traffic out of the box. When you later build clients, you will see how to negotiate the era explicitly.
Older blog posts and examples that use @modelcontextprotocol/sdk (v1) and the initialize + session model belong to the legacy era. Prefer the official v2 documentation at https://ts.sdk.modelcontextprotocol.io/v2/.
What You’ll Do Next
You now know why the protocol looks different in 2026. The next article looks at the SDK packages, the Standard Schema (Zod v4), the factory pattern, and the two main transports.
Official references
Get new posts by Nelson Lin
Subscribe to receive email notifications when a new article is published.