elicitly
Elicitly is a local MCP server/toolkit that lets your AI ask a human questions via standardized MCP elicitation.
elicit_confirm — Ask the user a yes/no (OK/Cancel) question; returns true/false/null with dismissal/error reasons.
elicit_form — Ask the user to fill a form defined by a JSON schema; returns accepted values or decline/cancel/error.
elicit_doctor — Diagnose the host's elicitation support, echo the MCP initialize handshake, and optionally run a live test elicitation.
Run instantly via
npx -y elicitlyor embed the same tools in your ownMcpServerwith@elicitly/tools.Safety constraints — no secret/credential collection, and tools are forbidden from task/tool execution.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@elicitlyconfirm with the user before shipping this change to production"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Elicitly — Free Edition
Your AI has questions. Your users have answers. Elicitly connects them — human-in-the-loop for prompts and Agent Skills over MCP elicitation.
This repository is the open-source Free Edition: the elicitly local MCP
server and the @elicitly/tools library. The hosted Pro Edition — durable
approvals with review pages, an audit trail, and organization dashboards —
lives at elicitly.ai.
Quick start
Run the local (stdio) MCP server straight from npm — no clone, no config:
npx -y elicitlyRegister it in your MCP host (Claude Code shown; any stdio host works):
claude mcp add elicitly -- npx -y elicitlyOr skip the command line: in Claude Desktop, download elicitly.mcpb from
the latest release
and open it — a one-click, self-contained
desktop extension.
Then ask your agent to call elicit_confirm ("Ship it?"), elicit_form
(your own JSON schema), or elicit_doctor (does this host actually support
elicitation?).
Related MCP server: MCP-Confirm
Packages
Package | What it is |
The local stdio MCP server ( | |
Embeddable toolkit: register the elicitation tools on your own |
Why
MCP has a native answer for asking a human — elicitation — but host support is
inconsistent, and only an MCP server can trigger it. Nobody wants to roll
their own server just to ask a question. Elicitly is that server (or, via
@elicitly/tools, the toolkit inside yours), plus the diagnostic
(elicit_doctor) that makes real-world host support visible — feeding the
public Support Matrix.
Develop
pnpm install
pnpm build # tsdown builds both packages
pnpm test # vitest
pnpm test:coverage # vitest + v8 coverage (thresholds enforced; HTML report in coverage/)
pnpm typecheck # tsc
pnpm check # biomeLicense
Available Tools
3 toolselicit_confirmAsk the user to confirm (OK/Cancel)A
Ask the user an OK/Cancel confirmation via elicitation (convenience wrapper over elicit_form), modeled on JavaScript's confirm(). Use this for a single yes/no question; use elicit_form to collect arbitrary fields. Returns three-state {confirmed}: true = proceed, false = a human explicitly said no, null = no answer was obtained (reason: "dismissed" | "error") — ask again later.
| Name | Required | Description | Default |
|---|---|---|---|
| labels | No | Relabel or localize the OK/Cancel buttons. Each label is trimmed, 1-40 characters; unknown keys are rejected. Button placement and styling stay fixed. | |
| message | Yes | The yes/no question shown to the user in the host's elicitation dialog. | |
| timeoutSeconds | No | How long to wait for the answer, in seconds (default 300, clamped 60-3600). |
Output Schema
| Name | Required | Description |
|---|---|---|
| reason | No | Present only when confirmed is null: "dismissed" = the elicitation was closed unanswered (including timeout), "error" = it failed. |
| confirmed | Yes | true = the user chose OK; false = an explicit no (Cancel choice or declined elicitation); null = no answer was obtained. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the provided annotations (openWorldHint=false, destructiveHint=false), the description discloses the three-state return contract: true, false, or null, with null's reason values 'dismissed' or 'error'. It also explains that this is a blocking elicitation and advises 'ask again later' behavior for null results. This is rich behavioral context that the annotations do not carry.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: it opens with the core action, immediately distinguishes from elicit_form, and then gives the essential return contract. Every sentence carries functional information; there is no filler or repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has only 3 parameters, an output schema, and annotations, the description is fully sufficient. It covers when to use it, the exact return semantics including edge cases, and the relationship to siblings. No critical operational detail appears to be missing for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already covers all parameters at 100% with descriptive text for message, labels, and timeoutSeconds. The description adds contextual meaning around the message as a 'single yes/no question' and labels via the JS confirm() model, but it does not substantially augment the parameter semantics beyond the schema. Baseline 3 is appropriate for complete schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Ask'), a specific resource ('the user an OK/Cancel confirmation'), and explicitly positions the tool as a convenience wrapper over elicit_form modeled on JavaScript's confirm(). It also distinguishes it from sibling elicit_form by stating 'Use this for a single yes/no question.' An agent can immediately understand what this tool does and how it differs from at least one sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage guidance: 'Use this for a single yes/no question; use elicit_form to collect arbitrary fields.' This tells the agent when to choose this tool over an alternative. The return semantics also clarify how to treat the result, and the caveat about 'no answer was obtained' reinforces appropriate re-prompting behavior.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
elicit_doctorDiagnose the host's elicitation supportARead-only
Check whether the connected MCP host actually supports elicitation (and sampling/roots) before relying on it — advertising a capability is not the same as it working. Use it to decide whether to call elicit_form/elicit_confirm, to explain why a prompt did or didn't appear, or to contribute a host capability fingerprint. Returns a passive report derived from the initialize handshake; set probeElicitation: true to also run one live form round-trip (the user may see a dialog) and classify what really happened. Read-only; safe to call anytime.
| Name | Required | Description | Default |
|---|---|---|---|
| probeElicitation | No | Also fire one live form-elicitation round-trip (the user may see a dialog) and report the outcome under probes.elicitationForm. Default false: passive capability report only, no prompt. |
Output Schema
| Name | Required | Description |
|---|---|---|
| probes | No | Present only when probeElicitation was true: the live round-trip's attempted/action/latencyMs/verdict. |
| support | Yes | Elicitly's derived support booleans, inferred from the advertised capabilities. |
| initialize | Yes | The MCP initialize handshake echoed verbatim: { request: { clientInfo, capabilities }, response: { protocolVersion, capabilities, serverInfo } }. |
| deprecations | Yes | Spec-level deprecation advisories (MCP 2026-07-28, SEP-2577) for the client features the report surfaces. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description discloses that the default is a passive report derived from the initialize handshake and, critically, that probeElicitation:true runs a live round-trip and 'the user may see a dialog'. 'Read-only; safe to call anytime' aligns with the annotations rather than contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded in the first clause, and each subsequent sentence carries distinct information: use cases, probe behavior, and safety. Nothing is wasted, but it is a single dense paragraph whose length could be relieved by light restructuring.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The output schema covers return values and the annotations cover the read-only safety profile, so the description only needs to cover purpose, usage, and side effects — which it does. The sole gap is the absence of an explicit when-not-to-use statement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the schema's own description of probeElicitation already documents the default, the dialog side effect, and the output field (probes.elicitationForm). The description adds only framing ('classify what really happened'), so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Check whether the connected MCP host actually supports elicitation (and sampling/roots)'. The title 'Diagnose the host's elicitation support' and the explicit naming of siblings (elicit_form/elicit_confirm) make its diagnostic role unambiguous and clearly distinguish it from the action tools it gates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives three concrete use cases — deciding whether to call elicit_form/elicit_confirm, explaining why a prompt did or didn't appear, and contributing a capability fingerprint — and names the alternative tools explicitly. It lacks an explicit when-not-to-use exclusion, which keeps it a point below the top.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
elicit_formAsk the user to fill a formA
Trigger a form elicitation with a caller-supplied JSON schema; returns the raw {action, content}. For a plain OK/Cancel question, prefer elicit_confirm. MUST NOT be used to request secrets, credentials, or other sensitive information.
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | The instruction shown to the user above the form fields. | |
| timeoutSeconds | No | How long to wait for the answer, in seconds (default 300, clamped 60-3600) — raise it for forms with several fields. | |
| requestedSchema | Yes | JSON Schema for the form, restricted to the MCP elicitation requestedSchema subset: a flat object whose properties are strings, numbers/integers, booleans, or enums — no nested objects, arrays of objects, $ref, or allOf. See https://modelcontextprotocol.io/specification/2025-11-25/client/elicitation#requested-schema |
Output Schema
| Name | Required | Description |
|---|---|---|
| action | Yes | accept = the user submitted the form; decline = an explicit no; cancel = dismissed unanswered (including timeout); error = the elicitation failed. |
| content | Yes | On accept, the submitted values keyed by requestedSchema property name; null for every other action. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only indicate non-destructive and non-open-world behavior, so the description adds value by stating the return format and the sensitive-content restriction. It does not describe cancellation behavior, but the output schema likely covers expected outcomes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences, each earning its place: purpose, alternative, and safety constraint. Front-loaded with the core action and return value, with no redundant wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a form elicitation tool with a rich schema, an output schema, and clear annotations, the description covers purpose, usage, safety, and return shape. Nothing critical is missing for an agent to select and invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so every parameter is already documented in the schema. The description adds little beyond the schema, mentioning 'caller-supplied JSON schema' and the raw return, which is acceptable given the high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific action ('trigger a form elicitation'), the resource ('caller-supplied JSON schema'), and the return value ('raw {action, content}'). It also distinguishes itself from the sibling elicit_confirm, so an agent can immediately tell which tool to use.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly directs agents to prefer elicit_confirm for plain OK/Cancel questions and forbids use for secrets or credentials. This gives clear when-to-use and when-not-to-use guidance, including a named alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.1.0- First observed
elicit_confirm - First observed
elicit_doctor - First observed
elicit_form
TDQS
Scored across 3 tools
Each tool has a clearly distinct purpose: elicit_confirm for single yes/no confirmations, elicit_form for arbitrary schema-based forms, and elicit_doctor for checking host elicitation support. The descriptions explicitly call out when to prefer one over the other, eliminating ambiguity.
All tool names follow the same elicit_verb or elicit_noun pattern with snake_case, creating a predictable and readable convention. The prefix uniformly signals the domain while the suffix distinguishes the operation.
Three tools is well-scoped for an elicitation-focused server: one core form tool, one convenience wrapper, and one diagnostic tool. Each tool earns its place and the count feels neither thin nor bloated.
The tool surface covers the full elicitation lifecycle: capability detection via elicit_doctor, simple confirmations via elicit_confirm, and arbitrary data collection via elicit_form. There are no obvious gaps for the stated purpose.
Maintenance
Related MCP Connectors
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Related MCP Servers
- AlicenseCqualityDmaintenanceA demonstration server that showcases how to collect user input dynamically using the Model Context Protocol (MCP) elicitation system across tools, resources, and prompts.10264,496 npm-
- AlicenseAqualityDmaintenanceAn MCP server implementing AI-user confirmation protocols, providing tools for LLMs to seek user confirmation when uncertain through yes/no questions, action confirmations, intent clarification, understanding verification, and satisfaction ratings.88 npmMIT
- AlicenseAqualityAmaintenanceAn MCP server that enables AI agents to pause and request human approval or information via Slack, Telegram, or macOS dialogs before proceeding with actions.215Apache 2.0
- AlicenseBqualityDmaintenanceAn MCP server that provides elicitation tools to interactively request user input, such as selecting options, providing information, or performing manual tests.31MIT