Think inside your AI world.

A server-rendered UI, against a faceplate you already own

A new capability is announced as a possibility for everyone, but a possibility is only a decision for the servers whose architecture it touches. If you already settled where your UI lives, the question is not ‘can a server render UI now’ — it is whether this changes anything you decided, and that is a line the announcement cannot hold.

Read the MCP 2026-07-28 specification through Unl and its server-rendered UI capability arrives measured against the architecture you settled — so instead of reading a new feature as an open question, you get a verdict on whether it bears on a decision you already made about where your UI lives. The verdict, not the possibility.

What the MCP 2026-07-28 specification carries

The 2026-07-28 revision adds capability that changes what a server can do, not only how it talks:

  • Server-rendered UIs — a server can ship interactive UI into a host, rendered in a sandboxed frame
  • UI templates a server can declare ahead of time, so hosts can prefetch and review them
  • A long-running Tasks extension and richer server-to-client interaction alongside it
  • No line telling you whether any of this touches a decision you already made about your own surface

The line the feed can't hold

Say you settled a firm architectural decision: your server returns data, and the interface lives in a separate surface you build and control — one loop, many faceplates, the seam designed once and no other UI tool built. That decision is a line you drew deliberately, and a new capability does not un-draw it; it only asks to be read against it.

The reason the line is yours is that a capability is not a mandate. The revision can let a server ship UI into a host; it cannot know that you decided the UI is not the server’s job, or that this changes what is possible without changing what you chose, or that for you the honest reading is ‘worth a look after launch, not a rebuild today’.

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 architecture rather than a feature you must evaluate cold: this capability lets the server ship the faceplate you deliberately kept separate — so it bears on your ‘data, not UI’ decision and is worth sizing deliberately, but it is an opportunity to weigh, not a change that forces your hand. Same specification; a reading against the line you drew instead of an open question against everyone’s.

You didn't ask — it was already there

You did not have to evaluate a new capability from scratch. The criterion — where your UI lives, and why — was already settled, so when a capability touches it the reading is in the window: this is the one change in the revision that bears on your surface decision, here is why it does, and here is the honest size of it — a thing to weigh, not a fire to fight. You settle the architecture once; the read holds new capability up against it as the protocol grows.

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

Do I have to adopt server-rendered UI when 2026-07-28 lands?

No. It is a capability the revision makes available, not a requirement, and a server that deliberately keeps its interface elsewhere is not obliged to change. The value of a measured read here is that it reads the capability against your settled architecture and returns a verdict — whether it bears on your decision at all, and if so how big it honestly is — rather than leaving a new feature sitting as an open question you have to evaluate cold.

How is this different from reading the feature announcement?

An announcement describes what is now possible, for everyone. The measured read joins the same public specification to your criterion — the decision you made about where your UI lives — and returns whether the capability touches that decision, with the reasoning attached. The announcement gives you a possibility; the read gives you a verdict against your own architecture, including the honest answer that it can wait.

Does Unl build or change any UI in my server?

No. Unl reads the public specification and returns a verdict measured against your criterion; it renders nothing into your server and changes no surface. Your architectural decision 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.