The Model Context Protocol (MCP) dropped its session state, swapping it for receipt-style requests and a new server/discover command. Developers can now run MCP on serverless platforms like AWS Lambda and avoid the “single waiter” bottleneck that has long hurt reliability.

Why the old model mattered

MCP originally required a persistent connection to a specific server. The server held a user’s “table number”—a hidden session that stored context, rules, and pending actions. When that server crashed, the session vanished and the client had to start over.

What the update does differently

  • No sessions – Each request carries everything the server needs, like a restaurant receipt any cashier can read. The “initialize” handshake disappears.
  • Receipt model – A tiny meta block at the start of every request includes version info and required parameters. The server processes the request in isolation, then returns a result with resultType, ttlMs (time-to-live in milliseconds), and cacheScope. These fields let the client cache the answer safely and know when it expires.
  • Server/discover – A new command lets a client query a server for its current capabilities. The response is immediate and does not depend on prior interaction.
  • Subscriptions/listen – Works like a buzzer: the client subscribes to updates and is only notified when something changes, cutting polling traffic.
  • Input_required flow – If the server needs more information, it returns an input_required response instead of reaching back to the client. The client then supplies the missing data in a follow-up request.

Because the server no longer holds state, any stateless compute environment can host MCP endpoints. Functions that spin up on demand, pause, or migrate across zones can handle traffic without breaking a conversation.

Who wins, who worries

Developers building AI front-ends – gain simpler, more reliable back-ends. Infrastructure teams – can provision MCP on cheap, auto-scaling services. MCP server maintainers – must rewrite handlers to emit ttlMs, cacheScope, and honor the server/discover contract. Code that relied on a persistent session will need refactoring. Enterprises with strict compliance – benefit from clearer data-lifecycle control.

The buried detail: version negotiation

Every receipt includes a tiny meta block that advertises the protocol version the client expects.

What’s still uncertain

What to watch next

Takeaway

By stripping away session state and turning every interaction into a self-contained receipt, MCP now fits naturally into serverless ecosystems. The shift makes MCP more stable and scalable, letting servers run anywhere and scale like any normal web service.