Technical Guide

Model Context Protocol Elicitation: Architecture and Governance

MCP elicitation is a specification-defined capability that lets an MCP server pause an interaction and request additional information from a user through the client, using a schema-constrained JSON-RPC message. The client is responsible for presenting the request for user review, and the user can accept, decline, or cancel it. Because the specification does not enforce runtime consent behavior, enterprises must verify how their client implementations handle elicitation and apply their own governance controls around capability negotiation, logging, and sensitive-data detection.

Elicitation at a Glance

Defined In

The MCP specification, as a distinct server capability alongside sampling and roots

Message Flow

JSON-RPC elicitation/create request, mediated by the client, returned to the server

Schema Rules

Flat objects with primitive types only, no nested structures

Client Responses

Accept, decline, or cancel, with mandatory user review before data is returned


Where Elicitation Fits in MCP Architecture

  1. 1

    One of Three Client-Mediated Capabilities

    Elicitation is one of three ways a server can request client-mediated action, alongside standard tool calls and resource access.

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.


Questions to Ask Before Enabling Elicitation in Production

  • Does our MCP client present elicitation requests for genuine human review, or does it auto-accept them?
  • Can we restrict or disable elicitation on a per-server basis during capability negotiation?
  • What audit logging exists for elicitation requests, responses, declines, and cancellations?
  • How do we detect a server attempting to solicit credentials or sensitive data through elicitation despite specification guidance?
  • What happens to downstream workflow state when an elicitation request times out or is cancelled?

Govern MCP Elicitation as Part of Your Runtime Security Posture

Understand how elicitation, tool calls, and other MCP server behaviors fit into your enterprise governance and audit requirements.

Explore MCP Security