Think inside your AI world.

A long-running task, against a limit you designed around

You do not just read the changes a protocol adds — you read them against the constraints you engineered around. When a revision moves a limit you spent real design effort avoiding, that is not a feature to note; it is a decision to revisit — and only you know which limit you built against.

Read the MCP 2026-07-28 specification through Unl and its long-running-work capability arrives measured against the constraint you designed around — so instead of reading a new extension as one more feature, you get a verdict on whether the limit you engineered around has just moved. The verdict, not the feature list.

What the MCP 2026-07-28 specification carries

The 2026-07-28 revision changes what is possible for slow work, not only fast calls:

  • A Tasks extension for long-running work, without holding a long-lived stream open
  • Multi Round-Trip Requests, so a server can ask the human mid-call and the client retries with the answer
  • A stateless core that scales on ordinary infrastructure rather than sticky sessions
  • No line telling you whether any of this lifts a constraint you specifically built your server around

The line the feed can't hold

Say you settled your design against a real limit: you built for short request and response, and avoided anything long-running, because a long-lived stream was the only way to do slow work and it did not scale the way you needed. That constraint shaped your server — and a revision that moves it is a line worth crossing, if it is genuinely yours.

The reason the line is yours is that only you know which limit you paid to avoid. The revision can add a Tasks extension and mid-call requests in general; it cannot know that you turned down a whole class of feature because slow work meant a stream you could not scale, or that lifting exactly that limit reopens a decision you closed deliberately.

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

The one that crosses

So the measured read crosses as a verdict against your design rather than a feature you might skim past: the constraint you engineered around — slow work meaning a long-lived stream that did not scale — is exactly what this revision lifts, so the decision you closed is worth reopening now; the other additions do not touch the limit you built against. Same specification; a reading against the constraint you designed around instead of a feature list against everyone’s.

You didn't ask — it was already there

You did not have to spot that a new extension undid an old constraint. The criterion — the limit you built your server around — was part of your settled design, so when a revision moves it the reading is in the window: this is the change that lifts the constraint you engineered around, here is why it does, and here is the decision it reopens. You record what you designed around once; the read watches for the day the protocol moves it.

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

How do I know a new capability lifts a limit I actually built around?

That is exactly what a general changelog cannot tell you and a measured read can. The changelog lists the Tasks extension and the mid-call request pattern for everyone; the read joins them to your criterion — the constraint you engineered around, recorded as your own line — and returns whether this revision lifts that specific limit, so a capability that reopens a real design decision does not slip past as one more entry.

Is this just an alert on a keyword like ‘streaming’?

No. A keyword alert fires on a word; a measured read fires on a decision. The line is not ‘mention streaming’ — it is ‘the constraint I built my architecture around’, and the read returns the change that lifts that constraint with the reasoning attached, rather than every clause that happens to use a matching term. The difference is a verdict against your design versus a match against your vocabulary.

Does Unl run or change anything in my server?

No. Unl reads the public specification and returns a verdict measured against your criterion; it executes nothing in your server and changes no code. Your design constraint lives in Unl, the specification is a public source, and 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.