1Client sends `initialize` request with `protocolVersion`, `clientInfo`, and `capabilities`
2Client calls `tools/call` to invoke a specific tool
3Client sends `initialized` notification to confirm it is ready
4Server responds with its own `protocolVersion` and `capabilities`
5Client calls `tools/list` to discover available tools
Every MCP connection starts with a short greeting before any real work happens. The order is fixed, and that order is the point of the question.
First, the **client** sends an `initialize` request. It includes the protocol version it speaks, some client info, and the capabilities it supports. Second, the server responds with its own protocol version and capabilities. Now both sides know what the other can do.
Third, the client sends an `initialized` notification. This is a one-way message that says, 'I got your response, I am ready.' Only after these three messages is the session open for business.
From there, the client can call `tools/list` to discover what tools the server offers, then `tools/call` to actually invoke one. The handshake first, capability requests second. If you call `tools/list` before the greeting finishes, the server does not yet know your version or features, so the request is invalid.
MCP connections open with a fixed three-message handshake, then move to normal operation.
The client sends an `initialize` request carrying its `protocolVersion`, `clientInfo`, and `capabilities`. The server replies with its own version and capabilities. The client then sends an `initialized` notification to confirm readiness. Only after those three messages may either side issue capability-gated requests.
The ordering is not cosmetic. Version negotiation happens in the first exchange. If the two sides disagree on the protocol version, they resolve it before anything else runs. Capability negotiation also happens here. Neither side may use a feature the other did not advertise.
**The readiness gate** matters too. The initialized notification exists so the server knows the client finished setup. Sending `tools/list` before that notification leaves the session in an undefined state. So the standard flow is initialize, then the server response, then initialized, then tools/list, then tools/call.
Quick reference
TL;DR
MCP opens with a three-message handshake: client `initialize`, server response, client `initialized`. Only then can capability requests like `tools/list` and `tools/call` proceed.
Think of plugging a new gadget into a universal hub. First the gadget says hello and lists what it can do; the hub says hello back and lists what it understands; then the gadget gives a final thumbs-up that it is ready. Until that little three-step greeting finishes, neither side knows the other's language version or features, so nobody tries to send real commands yet. The MCP handshake works the same way. The client asks first, the server answers, and the client confirms. Skipping or reordering those greetings means one side might speak a protocol version the other cannot parse, or call a feature the other never agreed to support. Order is the whole point.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Reusing an already-initialized session for a follow-up tool call The handshake runs once per connection; re-sending initialize on a live session is a protocol error, not a refresh.
A purely in-process tool dispatch with no separate server There is no client-server boundary to negotiate, so the lifecycle handshake adds ceremony with no counterpart to greet.
Sending a ping or cancellation before initialize completes Pings are allowed during startup, but feature traffic is not; gating capability requests on the handshake is the whole point.
Quick scan · 2–4 min
Everything important, quickly.
4 min: three-message handshake order, version negotiation, capability negotiation, the readiness barrier, and why out of order requests fail.
Side-by-side
Step
Direction
Message kind
Purpose
initialize
Client to server
Request
Propose version and declare client capabilities
initialize response
Server to client
Response
Agree version and declare server capabilities
initialized
Client to server
Notification
Signal client is ready for normal operation
tools/list
Client to server
Request
Discover the tools the server advertised
tools/call
Client to server
Request
Invoke a specific discovered tool
Real-world examples
Real products, models, and research that use this idea.
1Claude Code spawns each configured MCP server, then runs the `initialize` handshake over stdio before it ever lists tools for the session.
2The mcp-inspector debugging tool shows the `initialize` request, the server response, and the `initialized` notification as the first three frames on every connection.
3Cursor and Zed both follow the identical handshake order, which is why a server written for one host connects cleanly to the others.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhat should happen if the client and server propose different protocol versions?
Sign in or go Pro to see the approach for this follow-up.
QWhy is `initialized` a notification rather than a request?
Sign in or go Pro to see the approach for this follow-up.
QWhat is the smallest set of messages legal before `initialized` is sent?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Sending tools/list before the handshake completes, or forgetting the initialized notification. Both leave the session in an undefined state where capabilities are not yet agreed.