Agent Disambiguation Request Prompt

This prompt is for an autonomous agent that has encountered ambiguous user intent and cannot safely proceed without clarification. The job-to-be-done is to generate a structured, minimal-back-and-forth request that a human reviewer or the end-user can quickly answer, unblocking the agent's workflow. The ideal user is an AI platform engineer or product manager integrating a human-in-the-loop clarification step into a multi-agent or copilot system. Required context includes the original user input, the agent's current task, the specific point of ambiguity, and a set of candidate interpretations the agent has already considered.

Do not use this prompt when the agent can resolve ambiguity through tool use, retrieval, or by asking a clarifying question directly to the end-user in a conversational interface without a structured handoff. This prompt is specifically for workflows where the clarification must be routed through a review queue, logged for audit, or handled by a human operator who is not the original user. It is also inappropriate when the ambiguity is trivial or when the cost of human review exceeds the risk of an incorrect autonomous action. In high-stakes domains like healthcare or finance, this prompt should be paired with an evidence package and a risk classification, and the human response must be captured as a structured decision record.

Before implementing, define the schema for the clarification request and the expected human response. The agent should not re-prompt the human with open-ended questions; it must present discrete, selectable interpretations or a specific missing piece of information. Wire the output into a review queue with a timeout: if no human responds within the SLA, the agent should either escalate, abort, or fall back to a safe default. Test this prompt against edge cases where the ambiguity is subtle, where candidate interpretations overlap, and where the human provides an incomplete or out-of-scope answer. The most common failure mode is the agent asking a question that is still ambiguous, triggering a second round-trip.

This prompt template is designed for an agent that has encountered ambiguous user input and cannot proceed with confidence. Instead of guessing or failing silently, the agent must structure a precise clarification request that a human reviewer can act on without reading raw agent logs or replaying the conversation. The template uses square-bracket placeholders for all dynamic inputs, making it straightforward to wire into an orchestration harness.

textCopy
You are an agent operating within a [WORKFLOW_NAME] workflow. Your task is to request human clarification when user intent is ambiguous.

## Context
User Request: [USER_REQUEST]
Agent Role: [AGENT_ROLE]
Session Context: [SESSION_CONTEXT]

## Ambiguity Detected
[AMBIGUITY_DESCRIPTION]

## Candidate Interpretations
For each interpretation below, provide the interpretation, the action the agent would take, and the consequences of being wrong.

1. Interpretation: [INTERPRETATION_1]
   Action if correct: [ACTION_1]
   Risk if incorrect: [RISK_1]

2. Interpretation: [INTERPRETATION_2]
   Action if correct: [ACTION_2]
   Risk if incorrect: [RISK_2]

[ADDITIONAL_INTERPRETATIONS]

## Clarification Needed
[SPECIFIC_QUESTION_TO_HUMAN]

## Output Format
Produce a JSON object with the following schema:
{
  "ambiguity_summary": "string (one-sentence summary of the ambiguity)",
  "candidate_interpretations": [
    {
      "interpretation": "string",
      "proposed_action": "string",
      "risk_if_wrong": "string",
      "confidence": number (0.0 to 1.0)
    }
  ],
  "clarification_question": "string (the specific question the human must answer)",
  "context_for_reviewer": "string (concise context so the reviewer doesn't need to replay the conversation)",
  "escalation_reason": "string (why the agent cannot resolve this autonomously)"
}

## Constraints
- Do not guess the user's intent. If confidence is below [CONFIDENCE_THRESHOLD], request clarification.
- Limit candidate interpretations to the [MAX_INTERPRETATIONS] most plausible options.
- The clarification question must be answerable with a single choice or short response.
- Include only information the human reviewer needs. Omit raw agent logs.
- If the ambiguity involves a [HIGH_RISK_DOMAIN] action, mark the request as priority.

To adapt this template, replace each square-bracket placeholder with values from your orchestration layer. The [CONFIDENCE_THRESHOLD] and [MAX_INTERPRETATIONS] parameters should be configurable per workflow. For high-risk domains such as finance or healthcare, set the threshold higher and reduce the max interpretations to avoid overwhelming the reviewer. Always validate that the agent's output conforms to the JSON schema before presenting it to a human. If the agent fails to produce valid JSON after [RETRY_LIMIT] attempts, escalate with a raw output and an error flag.

The Agent Disambiguation Request Prompt is not a standalone chat message; it is a structured interrupt inside an agent execution loop. When the agent's intent classifier returns multiple candidate interpretations above a similarity threshold or below a confidence floor, the harness should pause the agent's tool-use phase, inject this prompt with the ambiguity payload, and route the output to a human review queue. The prompt itself is stateless—it receives the ambiguity description, candidate interpretations, and the specific clarification question as input variables. The harness owns all state, session context, and routing logic.

Wire the prompt into a decision node in your agent graph. The node receives an AmbiguityEvent object containing ambiguous_input, candidate_interpretations (list of objects with interpretation, confidence, and proposed_action), and missing_clarification (the specific question the agent needs answered). The harness populates the prompt's [AMBIGUITY_DESCRIPTION], [CANDIDATE_INTERPRETATIONS], and [CLARIFICATION_QUESTION] placeholders from this event. After generation, validate the output against a schema that requires clarification_request (the human-readable question), options (an array of suggested responses if applicable), and context_for_reviewer (a concise summary of why the agent is blocked). Reject and retry if the output is missing required fields, exceeds a maximum token length (e.g., 500 tokens to keep the review queue scannable), or fails to include the original ambiguous input for reference. Log every disambiguation event with the agent's trace ID, the candidate interpretations, and the generated request for later evaluation of whether the agent is escalating too frequently or with poor-quality questions.

For high-stakes domains—finance, healthcare, legal, or any workflow where a wrong interpretation has material consequences—add a human approval gate before the clarification request is sent to the end user. A second reviewer or a senior operator should confirm that the disambiguation question is clear, unbiased, and does not leak internal agent state or confidential context. The harness should also enforce a deduplication check: if the same ambiguity event ID has already been escalated, do not create a duplicate review task. Finally, instrument the loop with a timeout and fallback: if the human reviewer does not respond within a configured SLA (e.g., 30 minutes for operational workflows), the harness can either re-queue with elevated priority, escalate to a broader team, or—if the risk is low and a safe default exists—execute the highest-confidence interpretation with a logged override. Never let an agent silently guess when ambiguity is declared; the harness must enforce that the disambiguation path is the only path forward until resolved.