- 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
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.
Detailed answer & concept explanation~7 min readEverything 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. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Everything important, quickly.
4 min: three-message handshake order, version negotiation, capability negotiation, the readiness barrier, and why out of order requests fail.
| 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 products, models, and research that use this idea.
- Claude Code spawns each configured MCP server, then runs the `initialize` handshake over stdio before it ever lists tools for the session.
- The mcp-inspector debugging tool shows the `initialize` request, the server response, and the `initialized` notification as the first three frames on every connection.
- Cursor and Zed both follow the identical handshake order, which is why a server written for one host connects cleanly to the others.
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?
QWhy is `initialized` a notification rather than a request?
Don't say thisRed flags and common mistakes that signal junior thinking. Click to expand.
Red flags and common mistakes that signal junior thinking. Click to expand.
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.
The night-before-the-interview bullets. Scan these on the way to the call.
Primary sources. Skim if you want the original framing.
Same topic, related formats. Practice these next.