Ambiguous Intent Resolution Prompt

This prompt is for AI system designers and platform engineers who need a structured, multi-turn strategy to resolve user intent when a single input is too ambiguous to route or act on. The core job is not to guess the intent, but to produce a resolution plan—ask a clarifying question, infer from conversation history, or escalate to a human—that minimizes downstream errors. Use this when your system sits at a triage point where misrouting a request has a measurable cost: wrong agent, wrong tool, wrong policy, or a broken user experience. It is designed for conversational AI products, support platforms, and any multi-step workflow where the system can interact with the user before committing to an action.

This prompt is most valuable when ambiguity is structural, not just lexical. That means the user's words could reasonably map to multiple intents in your taxonomy, or the request is missing a required parameter that cannot be defaulted safely. The prompt expects you to supply the ambiguous input, the conversation history, the available intent taxonomy, and the system's capabilities. It then reasons about the cost of guessing wrong versus the cost of asking, and outputs a decision with a justification. Do not use this prompt for simple keyword matching, single-intent classification with high confidence, or non-interactive batch pipelines where clarification is impossible. In those cases, a standard classification prompt with a fallback queue is more appropriate.

Before deploying this prompt, ensure you have defined what 'ambiguous' means in your domain. A request for 'help with my account' might be low-risk to route to a general support queue, but 'cancel everything' in a healthcare or finance context demands immediate clarification. Wire the prompt's output into a state machine that can execute the chosen strategy: a clarification turn, a context-based inference with a confidence note, or an escalation handoff with a structured payload. Always log the resolution decision and the evidence that drove it. In high-stakes domains, require human review for any escalation path and periodically audit resolution accuracy against real user outcomes. The next section provides the copy-ready template you can adapt to your taxonomy and risk tolerance.

This prompt template is designed to be dropped into a conversational AI system when the primary intent classifier returns low confidence or detects multiple conflicting signals. Instead of guessing, the system uses this prompt to decide on a resolution strategy: ask a single clarifying question, infer the most likely intent from conversation history, or escalate to a human agent. The template uses square-bracket placeholders so you can wire it directly into your application's context assembly layer.

textCopy
You are an intent resolution specialist operating inside a conversational AI system. Your job is to resolve ambiguous user inputs by choosing the best resolution strategy.

## INPUT
User message: [USER_INPUT]
Conversation history (last 5 turns): [CONVERSATION_HISTORY]

## CLASSIFICATION CONTEXT
Top intent candidates with confidence scores: [INTENT_CANDIDATES]
Ambiguity type: [AMBIGUITY_TYPE]
Ambiguity severity: [SEVERITY_LEVEL]

## RESOLUTION STRATEGIES
You must select exactly one strategy:
- **ask**: The ambiguity is resolvable with one targeted question. Generate that question.
- **infer**: Context makes one intent clearly more likely. State the inferred intent and your reasoning.
- **escalate**: The ambiguity is too severe, the stakes are too high, or clarification would degrade the user experience. Prepare a handoff.

## CONSTRAINTS
- If you choose **ask**, produce exactly one clarification question. Do not ask multiple questions or offer a menu of options.
- If you choose **infer**, you must cite specific evidence from the conversation history that supports your inference.
- If you choose **escalate**, explain why neither asking nor inferring is appropriate in this case.
- Never fabricate user intent. If the evidence is insufficient, escalate.
- For [RISK_LEVEL] of "high" or "critical", prefer escalation over inference.

## OUTPUT SCHEMA
Return valid JSON only:
{
  "strategy": "ask" | "infer" | "escalate",
  "clarification_question": "string | null",
  "inferred_intent": "string | null",
  "inference_evidence": "string | null",
  "escalation_reason": "string | null",
  "confidence_after_resolution": 0.0-1.0
}

To adapt this template, replace each placeholder with live data from your application context. [USER_INPUT] should receive the raw user message. [CONVERSATION_HISTORY] should be a formatted summary of recent turns, not the entire session log—include user messages, assistant responses, and any confirmed intents. [INTENT_CANDIDATES] should be the top-k results from your classifier with their scores. [AMBIGUITY_TYPE] accepts values like underspecified, multi_intent, conflicting_signals, or out_of_distribution. [SEVERITY_LEVEL] should map to your ambiguity grading prompt's output: low, medium, high, or critical. [RISK_LEVEL] should come from your risk classification pipeline and controls the bias toward escalation.

Before deploying this prompt, validate the output JSON against the schema in your application layer. If the model returns strategy: "ask" but leaves clarification_question null, reject the response and retry with a stronger constraint instruction. Log every resolution decision with the original input, classifier scores, chosen strategy, and final outcome for audit and drift analysis. For high-risk domains such as healthcare or finance, route all escalate decisions to a human review queue and never auto-infer intent when [RISK_LEVEL] is critical. Start testing with a golden set of 50 ambiguous inputs where you know the correct resolution strategy, and measure whether the prompt selects ask, infer, or escalate appropriately across severity levels.

The Ambiguous Intent Resolution Prompt is designed to sit between your intent classifier and your downstream router or agent. When the classifier returns a confidence score below your defined threshold, this prompt takes the ambiguous input, the conversation history, and the top-k candidate intents to decide the next action: ask a clarifying question, infer the most likely intent from context, or escalate to a human. The prompt is not a standalone chatbot; it is a decision node in a triage pipeline. Wire it as a synchronous API call with a strict timeout, because a slow resolution decision blocks the user's request from reaching any handler.

Implement a validation layer that parses the model's JSON output against a strict schema before acting on it. The expected output fields are action (enum: clarify, infer, escalate), rationale (string), and, when action is clarify, a clarification_question (string). If the model returns infer, also require inferred_intent and confidence fields. Reject any response that fails schema validation and retry once with the same prompt plus the validation error message appended as a [PREVIOUS_ERROR] block. If the retry also fails, default to the escalate action and log the full failure context for review. For high-stakes domains such as healthcare or finance, route all escalate decisions and any infer decisions with confidence below 0.85 to a human review queue. The review queue payload should include the original user input, the classifier's top-k intents with scores, and the model's resolution proposal.

Model choice matters here. Use a model with strong instruction-following and JSON mode support, such as GPT-4o, Claude 3.5 Sonnet, or a fine-tuned Llama 3 variant. Avoid smaller models that may collapse the clarify and infer actions into generic text. Log every resolution decision with the input hash, model version, prompt template version, action taken, and whether the action was overridden by a human reviewer. This log becomes your audit trail for measuring resolution accuracy and user experience impact. Next, build an eval harness that tests the prompt against a golden set of ambiguous inputs with known correct resolutions, measuring precision and recall per action type, and run this harness before every prompt change.