skip to content

In MCP, what does the Deprecated status guarantee about a feature's removal?

level: middleimportance: should knowfreq 42%

answer

  1. announced, not yet gone
  2. there is a minimum lifetime
  3. new code should not adopt it
  4. one year, then the next revision
  5. every entry names its replacement

basics

~20 s

A feature marked Deprecated in MCP stays in the specification for at least twelve months, and new implementations SHOULD NOT adopt it. Features deprecated in revision 2026-07-28 cannot be removed before the first revision released on or after 2027-07-28.

solid answer

~50 s

MCP separates removal from deprecation and puts a clock on the gap. Marking a feature Deprecated means it remains in the specification for at least **twelve months**, that new implementations **SHOULD NOT** adopt it, and that existing implementations have a documented migration path to follow. For the batch deprecated in revision 2026-07-28, the earliest possible removal is the first revision released on or after **2027-07-28**. The specification keeps a registry of deprecated features so implementers can see the whole list in one place — it currently includes Roots, Sampling and Logging, RFC 7591 Dynamic Client Registration, the `includeContext` values `"thisServer"` and `"allServers"`, and the HTTP+SSE transport, which has been deprecated since revision 2025-03-26. Elicitation is not deprecated. Each entry carries its replacement, so "deprecated" is an instruction to migrate on a known schedule, not a warning that something may vanish at the next release.

go deeper

for a junior

Know the headline numbers: a deprecated MCP feature stays for at least twelve months, new implementations should not adopt it, and the specification names a replacement for each one.

for a middle

Explain the floor-versus-schedule distinction — earliest removal for the 2026-07-28 batch is the first revision on or after 2027-07-28 — and separate deprecated features from the ones that revision removed outright.

for a senior

Turn the policy into a plan: audit which deprecated features your implementation depends on, schedule the migrations inside the guaranteed window, and treat a new revision as three separate work streams — breaks, new deprecations, removals.

for a principal

Own the mirror-image obligation for what you operate: publish which deprecated mechanisms your own server still relies on and when you will drop them, so your consumers get the same planning horizon the specification gives you.

## Deprecated versus removed MCP evolves by dated revisions, and a revision date marks a backwards-incompatible change. Deprecation is the mechanism that stops those breaks from arriving without warning. A feature that is going away is first marked **Deprecated**: it still works, it is still fully specified, and implementations that use it are still conformant — but the specification has announced its end and named what replaces it. Removal is a separate, later event that lands in some future revision. ## The guarantee Three commitments come with the Deprecated label: 1. **Minimum lifetime.** The feature stays in the specification for at least twelve months after it is marked. 2. **New implementations SHOULD NOT adopt it.** This is aimed at anyone starting work today. Building on a deprecated feature means buying a migration you already know about. 3. **A migration path is documented.** Deprecation without a replacement would just be a countdown to breakage, so each entry says what to use instead. Applying the clock to the current batch: features deprecated in revision 2026-07-28 cannot be removed before the first revision released on or after **2027-07-28**. Note the shape of that rule — it is not "removed on 2027-07-28". The date is a floor, and removal happens in whatever revision comes after it, which may be considerably later. A well-behaved implementer reads it as "you have at least a year, and you will not be surprised inside that year". ## The registry The specification maintains a registry of deprecated features so you can see the whole surface at once instead of grepping revision notes. Reading it is the practical first step when planning an upgrade, because it tells you which parts of your implementation have a countdown attached. At revision 2026-07-28 it includes: - **Roots** — migrate by passing directories or files through tool parameters, resource URIs, or server configuration. - **Sampling** — migrate by integrating directly with an LLM provider's own API. - **Logging** — migrate by writing to `stderr` on stdio, and using OpenTelemetry for real observability. - **Dynamic Client Registration (RFC 7591)** — migrate to OAuth Client ID Metadata Documents. - The `includeContext` values `"thisServer"` and `"allServers"` — omit the field or use `"none"`. - **The HTTP+SSE transport**, deprecated since revision 2025-03-26 — migrate to Streamable HTTP. Elicitation is **not** deprecated, which is worth knowing because it is frequently lumped in with the client-side features that are. That last entry is instructive on its own: HTTP+SSE has been deprecated since 2025-03-26 and is still in the specification. Deprecation in MCP has been a long, well-signposted ramp in practice, not a euphemism for imminent removal. ## Deprecation is not the same as removal-in-2026-07-28 A common confusion in interviews is to blur the deprecated list with the **removed** list. Revision 2026-07-28 also removed things outright — the `initialize` handshake, protocol-level sessions, `ping`, `resources/subscribe` and `resources/unsubscribe`, server-initiated requests — and those got no twelve-month ramp because their removal *is* the backwards-incompatible change that the revision date announces. Deprecated features are the ones that survived the revision with a countdown attached; removed features are simply gone. If you say "Roots was removed in 2026-07-28" you have conflated the two, and it is exactly the slip an interviewer is listening for. ## How to use the policy in practice - **Starting a new implementation:** consult the registry before you design. Anything on it should not appear in your plan; take the documented replacement instead. This is cheapest at the start and expensive after you have shipped. - **Maintaining an existing one:** treat each deprecated feature you use as scheduled work with a known deadline. The twelve-month floor gives you a planning horizon that is realistic to fit into a normal roadmap, which is the whole point of publishing a floor rather than removing on the spot. - **Reading a new revision:** check three things — what the date breaks, what moved onto the deprecated registry, and what was removed outright. Those are three different classes of work with three different urgencies. - **Talking to your users:** if you operate a server, your own consumers care about the same clock. Publishing which deprecated features you still rely on, and when you will drop them, is the server-side mirror of what the specification does for you. ## What a strong answer sounds like State the twelve-month minimum, the SHOULD NOT-adopt rule for new implementations, and the concrete earliest-removal date for the 2026-07-28 batch. Mention that the registry exists and that each entry names its replacement. Then separate deprecated from removed with an example of each — that distinction is what demonstrates you have actually read a revision rather than a summary of one.

  • What is the earliest revision that could remove a feature deprecated in MCP 2026-07-28?
    The first revision released on or after 2027-07-28 — twelve months later. The date is a floor, not a scheduled removal: if no revision ships that day, the feature simply persists until one does. That is what makes the guarantee useful for planning; you know you cannot be broken inside the window.
  • How does a deprecated feature differ from one that revision 2026-07-28 removed outright?
    A deprecated feature is still fully specified and still works, with a countdown and a documented replacement — Roots, Sampling and Logging are examples. A removed feature is gone with no ramp, because its removal is itself the backwards-incompatible change the revision date announces: the initialize handshake, protocol sessions, ping, resources/subscribe. Conflating the two is a common error.
  • You are starting a new MCP server today. How does the deprecation registry change your design?
    You read it first and design around it. New implementations SHOULD NOT adopt deprecated features, so anything on the registry becomes its documented replacement instead — provider APIs rather than sampling, stderr and OpenTelemetry rather than the logging feature, tool parameters or configuration rather than roots, Streamable HTTP rather than HTTP+SSE. Avoiding it at design time costs nothing; retrofitting later does.

saying these in an interview costs you the question

  • Says a deprecated feature can be removed in the very next revision
  • Claims Roots and Sampling were removed in 2026-07-28 rather than deprecated
  • Thinks the twelve-month clock is a scheduled removal date rather than a floor
  • Believes deprecated features stop working or must not be implemented at all
  • Says Elicitation is deprecated along with the other client-side features

context