Think inside your AI world.

A stateless protocol, against a session model you never adopted

A protocol revision is loud for everyone at once: a changelog of dozens of changes, and the whole ecosystem asking at the same moment what it means for them. What you actually need is the one line that lands on a choice you already made about your own architecture — and whether it is work, or nothing to do — because that line is yours, and the changelog cannot hold it.

Read the MCP 2026-07-28 specification through Unl and the whole revision arrives measured against what you settled — so instead of reading the entire changelog against your whole stack, you get the one change that bears on a decision you already made, with the reason it does. The verdict, not the announcement.

What the MCP 2026-07-28 specification carries

The 2026-07-28 revision is the largest since MCP launched, and there is a lot in it:

  • A stateless core — the initialize handshake and the protocol-level session are removed
  • Servers that no longer need sticky sessions, scaling on an ordinary round-robin load balancer
  • Server-rendered UIs, a long-running Tasks extension, and Multi Round-Trip Requests
  • Authorization aligned to OAuth and OpenID Connect, and a formal deprecation policy
  • No single line telling you which of these lands on the way you actually built your server

The line the feed can't hold

Say you settled a decision early: session state lives in your application layer, threaded as your own argument, never in the transport — because you did not want your servers pinned to sticky sessions. That decision is a line you drew, and it is not a column the changelog models.

The reason the line is yours is the whole point. The revision can announce that the protocol session is gone; it cannot know that you never put state there, or that the thing being deleted is the thing you already routed around, or that for your server the largest change since launch is a paragraph you can close.

The frame judges the data it is given; it does not verify the source’s accuracy.

The one that crosses

So when the stateless core lands, it crosses your line as a verdict rather than an alarm: the revision removes the protocol session your server never used, so for you this is nothing to migrate — the operators who built session affinity into their infrastructure have the migration; you have a header you never sent. Same specification; a decision against your architecture instead of a changelog against everyone’s.

You didn't ask — it was already there

You did not go looking for it. The criterion — where your server keeps state — was already settled, so the next time you open Claude on that codebase the reading is already in the window: this revision, read against the choice you made, with the reason it is or is not your problem. You draw the architectural line once; the read applies it every time the protocol moves.

The answer comes back measured against what you already decided, and why.

The lane is live and open to this tool today: one box, paste anything. If it speaks MCP, Unl can reach it. Readings arrive unprompted, the data beside the criterion; Unl is a courier, not a warehouse, and keeps only your keys and the frame.

Questions people ask

Does MCP 2026-07-28 break my server on the date?

The maintainers are explicit that the date is when the specification text is published, not a switch-off, and the revision carries a formal deprecation policy with a minimum support window. What a measured read gives you is narrower and more useful than the general answer: whether the stateless core lands on a choice you actually made — which, if you kept state out of the transport, is nothing to do — rather than the ecosystem-wide reassurance that applies to no one in particular.

How is this different from reading the changelog myself?

The changelog is the firehose: every change, ranked for the whole ecosystem, none of it against your build. The measured read joins the same public specification to a criterion you ratified — where your server keeps state — and returns the one change that bears on it, with the reasoning attached. You can read the whole thing and work out your exposure by hand; the frame does that read against your line and hands you the verdict.

Does Unl change anything in my server or the specification?

Unl reads the public specification and returns a verdict measured against your criterion; it writes nothing as a side effect of a read, and can act only on your explicit gesture. The specification is a public source; your architectural decision lives in Unl; the read joins them and alters neither.

What this is

Think inside your AI world — you stay in command

Unlimitless (Unl to friends) holds what you've settled, reads what your tools are showing, and catches what's changed out in the world — and hands your AI whatever bears on the work, the moment it's needed, without you asking. The right thing, in front of the model, unprompted, with you in command of the call. So you keep moving toward what you set out to build, on top of everything you've already decided.

It plugs into Claude, Claude Code, ChatGPT and Cursor as an MCP connector. Quick to connect, in a couple of steps.

Unlimitless is open now to invited Alpha. Apply for the Beta waitlist to come in ahead of the full launch:

Alpha is invite-only · free at launch.