Think inside your AI world.

A deprecation policy, against a method you still call

A deprecation notice is written for everyone who might call a method, which is nobody in particular. The question that actually matters is narrower: does it land on a method your code calls, and how long do you have — and that is a line the notice cannot hold, because it does not know your call sites.

Read the MCP 2026-07-28 specification through Unl and its deprecation policy arrives measured against the methods you actually call — so instead of reading every deprecation against your whole codebase, you get the ones that land on your call sites, each with the support window attached. The verdict, not the notice.

What the MCP 2026-07-28 specification carries

The 2026-07-28 revision formalises how the protocol retires things, and the policy applies broadly:

  • A formal deprecation policy, so the protocol can evolve without breaking what you built
  • A minimum support window on a deprecation, rather than a change that lands without warning
  • Capabilities marked deprecated as annotations, carried forward rather than removed on the date
  • No line in the policy that knows which of the affected methods your own code calls

The line the feed can't hold

Say you settled the line that makes a deprecation worth your attention: interrupt me only when a method my code actually calls is deprecated, and tell me how long the support window gives me — everything else waits for the scheduled review. That call-site awareness is a decision you hold; it is not something the policy can model for you.

The reason the line is yours is that only your codebase knows which methods it calls. The policy can guarantee a support window in general; it cannot know that a deprecation lands on a method threaded through your hot path, or that another one touches nothing you use and is safe to ignore until the review.

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 where the blanket notice does not: this deprecation lands on a method your code calls, and the formal policy gives you a defined support window rather than a surprise — so it is worth planning now; the others in the revision touch nothing you call and can wait. Same specification; a verdict against your call sites instead of a policy against everyone’s.

You didn't ask — it was already there

You did not have to comb the policy. The criterion — interrupt me for a deprecation on a method I call, with the window attached — was already ratified, so the reading is in the window the next time you open the codebase: the deprecations that land on you, each with the time you have, and the reason it cleared your line. You author the rule once; the read applies it every revision.

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

Will a deprecation in 2026-07-28 break my server on the date?

The revision’s formal deprecation policy is designed so it does not: a deprecated capability carries a minimum support window rather than being removed on the publication date. What a measured read adds is the part the policy cannot give you — whether a given deprecation lands on a method your code actually calls, and therefore whether the window is something you plan around now or note and defer.

How is this different from a linter or a changelog scan?

A linter checks your code against rules it ships with; a changelog scan shows you every deprecation, ranked for everyone. The measured read joins the public specification to your criterion — the methods you call, and the window you consider worth acting on — and returns the deprecations that cross that line, with the support window attached, rather than the full list for you to filter by hand.

Does Unl modify my code or the specification?

Neither as a side effect of a read. Unl reads the public specification and returns a verdict measured against your criterion; your call-site criterion lives in Unl, the specification is a public source, and the read joins them and changes nothing. Any change to your code is your own gesture.

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.