In MCP, what must happen when one side does not support a requested extension?
answer
- opt-in is mutual, silence is not consent
- two legal responses, not one
- core behaviour, or refuse
- the extension's own spec says which
basics
~20 sThe extension simply does not apply. Under MCP revision 2026-07-28 the other side MUST either revert to core protocol behaviour or reject the request outright. Proceeding as though the extension were in effect is not an option.
solid answer
~50 sMCP revision 2026-07-28 states the rule directly: if one side does not support an extension, the other side MUST either revert to core behaviour or reject the request. Those are the only two legal responses, and which one applies is decided by the extension itself — an extension's specification SHOULD document its fallback so both implementers behave the same way. The choice is a real design decision. A server whose work is still meaningful without the extension should degrade: answer with an ordinary core-shaped result rather than the extension-shaped one. A server that genuinely cannot serve the request without it should reject, accepting that this narrows the clients it can serve. What is never permitted is the third path — emitting extension-shaped output at a peer that never opted in, on the grounds that it is additive and probably harmless.
go deeper
Remember that an extension only applies when both sides support it, and that a peer which lacks it must be answered with ordinary core behaviour or an outright rejection.
State both legal responses and explain that the extension's own specification is where the fallback is documented, not the core protocol.
Show the judgment: pick revert when a core-shaped answer is still truthful, reject when it would misrepresent what happened, and evaluate the opt-in per request rather than caching it across a connection.
Own the fleet-level consequence. Decide whether an extension may ever be mandatory for your servers, how the degraded path is monitored, and how you stop fallback behaviour from quietly weakening a security check.
## The rule Extensions in MCP revision 2026-07-28 are always opt-in on both sides. The corollary the spec spells out is what happens when the opt-in fails: **if one side does not support an extension, the other side must either revert to core behaviour or reject the request.** Two options, both explicit, neither silent. Note what is excluded. There is no "send it anyway, additive fields are ignored by old clients" path. That instinct comes from formats where unknown fields are cheap to skip, and it is wrong here because an extension typically changes the *meaning* of a result, not just its field list — a result shaped by an extension is not a core result with extra decoration, and a client that never opted in has no obligation, or ability, to interpret it. ## Revert versus reject **Revert to core behaviour** is the graceful path, and the right default whenever the request is still answerable without the extension. The peer does the ordinary thing: a normal, complete result in the core shape. From the other side's point of view nothing unusual happened, which is exactly the desired property — a client that has never heard of your extension gets a working interaction. **Reject the request** is the honest path when the operation is meaningless without the extension. It is sanctioned, not a failure of design, but it has a cost: every client that has not implemented the extension is now a client you cannot serve. Reach for it when reverting would produce something misleading — for instance, when a core-shaped answer would look complete while the real work was never performed. The deciding factor is whether a core-shaped answer is *truthful*. If it is, revert. If it would misrepresent what happened, reject. ## Whose job is it to decide? The **extension's own specification** should document the fallback. The core protocol deliberately does not enumerate per-extension behaviour — it cannot, since anyone may define an extension under their own prefix. This is why a well-written extension spec says, in as many words, what a peer does when the other side lacks it. When you author an extension, that paragraph is not optional polish; without it two implementations will disagree, one reverting and one rejecting, and the mismatch will surface as intermittent failures in the field. ## The statelessness trap MCP is stateless as of revision 2026-07-28: every request is self-contained and carries its own protocol version and capabilities, and servers must not rely on prior requests over the same connection to establish context. Applied to extensions, this means the check must run **against the request in front of you**. A server that saw an opt-in an hour ago, cached it, and now emits extension-shaped output for a request whose capabilities did not declare the extension has violated both the statelessness rule and the fallback rule at once. Behind a load balancer the bug is worse than it looks, because it will reproduce only on the node that happens to hold the stale cache. The flip side matters too. Because the opt-in travels per request, a client can legitimately opt in on some requests and not others. A server must treat that as normal, not as a client bug. ## Designing for a mixed fleet The deployed MCP fleet in 2026 is uneven — different clients, different vintages, different feature sets. Practical guidance: - **Write the degraded path first.** If you cannot describe what your server does for a client without your extension, you do not yet have a design. - **Make the fallback observable.** Log which path a request took; "why is this client not getting task-shaped results" is otherwise a long afternoon. - **Do not require an extension for basic functionality.** A server whose `tools/list` is useless without an extension has effectively made a private protocol. - **Tolerate unknown identifiers.** A peer will eventually declare an extension you have never seen; that is not an error, it is just an extension that is not active. - **Do not let the fallback change security posture.** Reverting to core behaviour must not mean skipping a check the extension path performed; if the core path cannot be made safe, reject instead. ## What the interviewer is testing Whether you know there are exactly two legal responses and can pick between them for a concrete case, and whether you resist the tempting third option of sending extension output optimistically. The strongest answers add the statelessness point — that the opt-in is evaluated per request, so "they supported it last time" is not an input to the decision.
- Where should the choice between reverting and rejecting be written down?In the extension's own specification. The core protocol states only the two permitted responses; it cannot enumerate per-extension behaviour, since anyone may define one under their own prefix. An extension that omits its fallback paragraph will get two implementations that disagree — one degrading, one erroring — and the mismatch shows up as intermittent field failures.
- Can a server refuse every client that has not opted into its extension?Yes — rejecting is the sanctioned alternative to reverting. But it turns the extension into a hard requirement and shrinks the set of clients that can use the server at all. Reserve it for operations where a core-shaped answer would misrepresent what happened; if a truthful core answer exists, degrade instead.
- A server cached a client's opt-in from an earlier request and reuses it. What is wrong with that?It breaks the statelessness rule of revision 2026-07-28, where every request carries its own capabilities and servers must not rely on prior requests to establish context. The client may legitimately omit the extension on this request, and behind a load balancer the behaviour becomes node-dependent — the bug reproduces only where the stale cache lives.
Two colleagues agree on a shorthand. If the person in front of you does not know it, you either say the same thing in plain words or tell them you cannot continue — you never keep using the shorthand and hope it lands.
saying these in an interview costs you the question
- Sends extension-shaped output anyway because the fields are additive
- Treats an unsupported extension as always fatal, ignoring the revert option
- Expects the core specification to define each extension's fallback
- Caches a previous request's opt-in and assumes it still holds
- Lets the degraded path skip a check the extension path performed