What Elicitation Is and Why It Exists
Elicitation is a capability defined in the Model Context Protocol specification that allows an MCP server to request additional information from a user during an active interaction, rather than requiring all inputs to be supplied upfront. In practical terms, a server can pause mid-workflow and ask the client to collect a specific piece of information from the user before continuing.
This addresses a real limitation in earlier tool-calling patterns, where a server needed every parameter defined before invocation. Many real-world workflows do not fit that model. A server may not know it needs a piece of information until partway through a task, or may need to confirm something with the user before proceeding. Elicitation formalizes a way to handle that mid-session, rather than leaving it to ad hoc prompt engineering or forcing upfront over-collection of data that may not be needed.
The Technical Message Flow
Elicitation is initiated server-side but requires a round trip through the client, which acts as the mediator between the server and the user. The server sends an elicitation/create JSON-RPC request containing a message and a requested schema describing what information it needs. The client is responsible for presenting this request to the user, collecting a response, and returning it to the server.
The specification restricts elicitation schemas to flat objects using primitive property types such as string, number, boolean, and enum. Nested or complex structures are not permitted. This constraint is intended to simplify how clients render the request as a user interface and to reduce ambiguity about what is actually being asked for.
The client's response to the server falls into one of three defined categories: accept, decline, or cancel. Only on accept does the requested data get returned to the server. This means the protocol itself defines a clear decision point, but it does not dictate how that decision point is presented to the user.
Why the Client Is the Real Trust Boundary
The MCP specification places the responsibility for user review and consent on the client, not on the server and not on the protocol itself. The specification states that clients must provide a way for users to review and approve or decline elicitation requests before any data is returned. It also explicitly instructs servers never to use elicitation to request sensitive information such as passwords, API keys, or other credentials.
These are meaningful specification-level protections, but they are guidance rather than enforced technical constraints. Nothing in the protocol prevents a poorly built or misconfigured client from auto-accepting elicitation requests without meaningful human review, and nothing in the protocol prevents a non-compliant server from attempting to solicit sensitive data anyway, in violation of the specification's own instructions. MCP's general security guidance reinforces this by stating that hosts are responsible for obtaining explicit user consent before invoking tools or exposing data, but responsibility for implementing that consent correctly sits entirely with whoever built the client.
Operational and Governance Implications
Because elicitation introduces a runtime, user-facing data-collection event initiated by external server code, it deserves distinct treatment in enterprise governance rather than being lumped in with standard tool invocation. A few implications follow directly from how the specification is written.
- Client behavior is not uniform. Since the specification mandates review capability but not a specific user experience, one client implementation might present a clear approval dialog while another auto-approves silently. This needs to be verified per client, not assumed from the specification alone.
- The credential-request restriction is non-binding. A server can technically construct an elicitation request asking for a password using permitted primitive field types. Detecting and blocking this kind of request is left entirely to the enterprise's own controls.
- Elicitation events are a distinct audit category. Requests, responses, declines, and cancellations reflect a point where a user made a consent decision in response to an external server's request, which is different from a standard tool call log entry and should be retained and reviewed accordingly.
- Rate limiting is undefined at the protocol level. Since the specification does not define rate limiting or anti-abuse mechanisms for repeated elicitation requests, enterprises deploying multiple third-party MCP servers should decide, at the capability negotiation stage, which servers are actually permitted to use elicitation at all.
Evaluating Elicitation as Part of a Broader Runtime Governance Approach
Elicitation is a narrow but concrete example of a broader pattern in agentic systems: servers and tools taking actions or requesting inputs at runtime that were not fully specified in advance. The specification gives enterprises a defined message flow and some structural guardrails, such as schema constraints and the three-way response model, but it deliberately leaves policy enforcement, consent UX, and monitoring to the implementer.
This is consistent with how MCP treats security generally. Client responsibility, explicit user consent, and capability negotiation are specification principles, not runtime guarantees. Enterprises adopting MCP servers from multiple vendors or teams should treat elicitation as one of several runtime behaviors, alongside tool calls and sampling requests, that require policy enforcement, permissioning, and audit logging independent of what any individual server or client claims to do.
Trussed AI provides runtime governance and security for enterprise AI agents, including MCP security capabilities such as tool approval workflows, runtime policy enforcement, and audit logging that apply to agent and MCP server behavior, including capability-level controls relevant to features like elicitation. These are treated as part of a broader governance layer rather than a replacement for correct client implementation, which remains the primary responsibility of whoever deploys the MCP client.