The mental model most developers carry for the Model Context Protocol is a one-way street: the client (Claude Desktop, an IDE, an agent runtime) calls the server, and the server answers — here are my tools, here is a resource, here is the result of running this function. That picture is correct for ninety percent of MCP traffic, and it's also why two of the protocol's most interesting features go unused. Because MCP is not a one-way street. It has a return lane, and it has two of them.
Those two lanes are sampling and elicitation. Both let a server stop answering and start asking — reaching back through the client to get something it can't produce alone. The reason to learn them together is that they are mirror images: one reaches the model, the other reaches the human, and the symmetry is the whole point.
Sampling: the server borrows the client's brain
Sampling is the answer to a problem every server author eventually hits: I need an LLM call inside my tool, but I don't want to ship an API key. Say your server summarizes a document or classifies a ticket. The naive design bundles its own model provider, its own key, its own bill. Sampling deletes all of that. Via sampling/createMessage, the server hands the client a set of messages — optionally a system prompt, model preferences (hints plus cost/speed/intelligence priorities), and how much context to include — and the client runs the completion with its own model and returns the text.
The consequence is more than convenience. The client owns the model choice, so the user's privacy boundary and spend stay on the user's side of the wire; the server never sees the key and never pays for the inference. The spec leans hard on this: clients should let the user review and approve the prompt before it runs, and the completion before it goes back. The server gets to think without ever holding the credit card or the keys to the model.
Elicitation: the server asks the person
Elicitation, added in the 2025-06-18 revision, is the other direction. Sometimes a server doesn't need the model — it needs you. A booking tool is missing the travel date; a deploy tool wants a typed confirmation; an integration needs which of three accounts to use. Before elicitation, the server's only move was to fail and make the agent re-prompt. Now it can call elicitation/create with a human-readable message and a requestedSchema — a deliberately restricted JSON Schema, flat objects with primitive fields only — and the client renders a form. The user can accept (and supply the data), decline, or cancel, and those three are distinct outcomes the server must handle differently.
There's a guardrail bolted on: servers MUST NOT use elicitation to request sensitive information — no passwords, no API keys — and clients are expected to make clear which server is doing the asking. Elicitation is for the missing field, not the secret.
Sampling reaches the model; elicitation reaches the human. They are the two halves of the same idea — a server that can ask, not just answer.
The symmetry, and the catch
Put them side by side and MCP stops looking like a tool-calling RPC and starts looking like an actual conversation between three parties. A server can pause to think (sampling) or pause to ask (elicitation), and both requests travel the same reverse path: server → client → (model | human) → back. This is what makes MCP bidirectional in a way function calling never was — the integration isn't just a menu of callable tools, it's a participant that can reach back out.
The catch — and it is a big one — is that both are client capabilities, negotiated at initialization, and the client has to actually implement them. A glance at the protocol's own client feature matrix shows how uneven that support still is: plenty of clients speak tools and resources fluently while supporting neither sampling nor elicitation. If the client never advertised the capability, your server's beautiful createMessage call has nowhere to land.
So the honest engineering posture is progressive enhancement. Design the server to detect what the client supports and degrade: fall back to a tool argument when elicitation is missing, fall back to a documented "bring your own key" path when sampling isn't there. The same caution applies to anything riding the newer transport and authorization work — the spec moves faster than the clients do. The 2025-11-25 revision has already pushed both features further, adding tool-calling to sampling and a URL mode to elicitation — capabilities most clients haven't caught up to yet. The features that make MCP feel alive are exactly the ones you can't yet assume. Build for the return lane, but check that it's paved before you drive down it.
