What happens during the MCP initialize handshake, and why does it matter?

Flashcard·Easy·4.0 · 0·~30s·Asked atFlowise Kpmg Tesla·Relevant atAnthropic

Attempt it

The client sends an initialize request with its protocol version and a capabilities object listing features it supports. The server responds with its own protocol version and capabilities object. The client then sends notifications/initialized to confirm. From that point, each side only calls features the other advertised. This mutual opt-in lets MCP evolve without breaking older peers.

Your answer

**Capability negotiation** is the feature exchange that happens at the very start of every MCP session, inside the `initialize` handshake. The flow has three messages. First, the client sends an `initialize` request containing its protocol version, client info (name and version), and a `capabilities` object listing the optional features it supports. Second, the server responds with the agreed protocol version, its own server info, and its own `capabilities` object. Third, the client sends a `notifications/initialized` notification to signal it has read the response and the session is open. The server's capabilities might include keys like `tools`, `resources`, `prompts`, `logging`, and `completions`. The client's capabilities might include `roots`, `sampling`, and `elicitation`. Each key is opt-in: if a server does not implement resources, it omits that key entirely. Once the exchange finishes, both sides know the intersection of supported features. The client will not call `resources/list` against a server that did not advertise resources. The server will not issue a `sampling/createMessage` request to a client that did not advertise sampling. This mutual agreement is what makes MCP forward compatible: new features are invisible to peers that never advertised them, so nothing breaks.

**Capability negotiation** is the feature detection step inside MCP's `initialize` handshake. Both sides declare what they support, and from that point on each side calls only features the other advertised. The sequence is three messages. The client sends `initialize` with its protocol version (a date string like `"2026-03-26"`), client info, and a `capabilities` object. The server replies with the agreed protocol version, server info, and its own capabilities. The client then fires a `notifications/initialized` notification, and the session is open. Server capabilities in the 2026 spec commonly include `tools` (callable functions, with an optional `listChanged` sub-flag), `resources` (readable data identified by URI, with optional `subscribe` and `listChanged`), `prompts` (user-invoked templates), `logging` (structured log emissions), and `completions` (argument autocompletion). Client capabilities commonly include `roots` (workspace directory hints), `sampling` (the client can run LLM completions on the server's behalf), and `elicitation` (the client can prompt the user for input mid-call). This matters because MCP is a living spec. Features ship every few months. Without negotiation, every addition would break older peers. With negotiation, a 2026 server talking to a 2024 client degrades gracefully to the shared feature set. The intersection of advertised capabilities is always a valid working subset. The practical debugging note: when a feature is not working, the first check is always the initialize trace. If either side did not advertise the capability, no downstream fix will help.

TL;DR

During initialize, client and server each declare supported features via a capabilities object; both sides then stick to the intersection, enabling forward compatibility.

Memory aid

Easy to grasp

Imagine two kids meeting at a playground for the first time. Before they start playing, each one says which games they know: 'I know tag, hide and seek, and kickball.' The other says 'I know tag and freeze dance.' They agree to play tag because both listed it. Neither suggests a game the other never learned. MCP works the same way. When a client and server first connect, each sends a short list of features it supports. From then on, both stick to only the features they share. If the server later learns a new trick, older clients that never listed it simply ignore it. Nobody breaks. Nobody gets confused.

Key concepts

Capability Negotiation Initialize Handshake Feature Detection Forward Compatibility

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Capability negotiation is the small but critical mechanism that lets MCP evolve safely. The spec changes every few months. Hosts ship and stay deployed for years. Servers update on their own schedules. Without a way for both sides to agree on supported features at session start, every spec update would risk breaking something.

This explanation walks the three-message exchange, lists the capabilities each side commonly advertises in the 2026 spec, and shows why the asymmetric opt-in design is what makes forward compatibility actually work.

The three-message handshake

Every MCP session opens with exactly three messages.

The client sends an initialize JSON-RPC request. Its params include protocolVersion (a date-stamped string like "2026-03-26"), clientInfo (an object with name and version), and capabilities (an object listing the optional features the client supports). No other method may be called before this.

The server responds with its own protocolVersion (which may match the client's or be older if the server does not understand the client's version), serverInfo, and its own capabilities object listing what it offers.

The client sends a notifications/initialized notification (no id, no response expected). This signals the client has processed the server's response and the session is ready for normal operations.

Capability negotiation is the act of populating and reading the two capabilities objects in messages one and two. Everything that happens for the rest of the session must fit within the intersection of those two declarations.

Server capabilities in the 2026 spec

Client capabilities in the 2026 spec

Forward compatibility through mutual opt-in

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Claude Desktop announces `roots` and `sampling` client capabilities; servers configured in the desktop config can rely on Claude to surface roots and accept sampling requests.
A simple search MCP server advertises only `tools`; the client never attempts `resources/list` against it because the resources capability is absent.

What an interviewer would ask next. Try answering before peeking at the approach.

QWhat should a client do if it attempts to call a feature the server did not advertise?

It should not make the call at all. A well-behaved client checks capabilities before issuing any method beyond initialize. Most servers return JSON-RPC error -32601 method not found for unadvertised methods. The client should hide the feature in its UI or surface a clear error to the user.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Assuming every MCP server supports every feature. Servers advertise only what they implement, and the client must check before calling anything beyond initialize.

60 second bullets to scan on the way to the call.

Define capability negotiation as the feature exchange inside initialize.
Walk the three-message sequence (initialize request, response, notifications/initialized).

Primary sources. Browse if you want the original framing.