Handling Ambiguity in Agent Conversations: Clarification, Confirmation, and Disambiguation

Ambiguity Is the Norm, Not the Exception

Users rarely communicate with the precision of a SQL query. They say "cancel it" when they have three active orders, "change the time" without specifying which appointment, or "how much does it cost" about a product with twelve pricing tiers. Human conversations are inherently ambiguous, and agents that cannot handle ambiguity feel brittle and frustrating.

The goal is not to eliminate ambiguity — that is impossible. The goal is to detect it, resolve it efficiently, and learn from patterns to reduce future friction.

Detecting Ambiguity

Ambiguity falls into distinct categories, each requiring a different resolution strategy:

from enum import Enum
from dataclasses import dataclass


class AmbiguityType(Enum):
    REFERENTIAL = "referential"       # "Cancel it" — what is "it"?
    LEXICAL = "lexical"               # "Bank" — financial or river?
    SCOPE = "scope"                   # "All users" — this org or globally?
    TEMPORAL = "temporal"             # "Next Friday" — which Friday?
    INTENT = "intent"                 # "I need help" — with what?
    ENTITY = "entity"                 # "The Smith account" — John or Jane?


@dataclass
class AmbiguityDetection:
    detected: bool
    ambiguity_type: AmbiguityType | None
    candidates: list[str]       # Possible interpretations
    confidence_spread: float    # How close the top interpretations are


def detect_referential_ambiguity(
    user_input: str,
    conversation_context: dict,
) -> AmbiguityDetection:
    """Detect when pronouns or references are ambiguous."""

    pronouns = ["it", "that", "this", "them", "those", "the one"]
    has_pronoun = any(p in user_input.lower() for p in pronouns)

    if not has_pronoun:
        return AmbiguityDetection(False, None, [], 0.0)

    # Check if context provides a clear single referent
    recent_entities = conversation_context.get("recent_entities", [])

    if len(recent_entities) == 1:
        return AmbiguityDetection(False, None, recent_entities, 0.0)

    if len(recent_entities) > 1:
        return AmbiguityDetection(
            detected=True,
            ambiguity_type=AmbiguityType.REFERENTIAL,
            candidates=recent_entities,
            confidence_spread=0.1,  # Very close — genuinely ambiguous
        )

    return AmbiguityDetection(
        detected=True,
        ambiguity_type=AmbiguityType.REFERENTIAL,
        candidates=[],
        confidence_spread=0.0,
    )

Asking Clarifying Questions

Clarifying questions should be specific, provide options, and never make the user feel like they made a mistake:

def generate_clarifying_question(
    ambiguity: AmbiguityDetection,
    user_input: str,
) -> str:
    """Generate a natural clarifying question based on ambiguity type."""

    templates = {
        AmbiguityType.REFERENTIAL: {
            "with_candidates": (
                "I want to make sure I help with the right thing. "
                "Are you referring to:\n{options}"
            ),
            "without_candidates": (
                "Could you clarify what you'd like me to {action}? "
                "I want to make sure I get it right."
            ),
        },
        AmbiguityType.ENTITY: {
            "with_candidates": (
                "I found a few matches for that. Which one did you mean?\n"
                "{options}"
            ),
            "without_candidates": (
                "Could you be more specific? For example, "
                "include a full name or account number."
            ),
        },
        AmbiguityType.TEMPORAL: {
            "with_candidates": (
                "Just to confirm — when you say '{time_ref}', "
                "do you mean:\n{options}"
            ),
            "without_candidates": (
                "Could you specify the exact date? "
                "For example, 'March 20' or 'this Thursday'."
            ),
        },
        AmbiguityType.SCOPE: {
            "with_candidates": (
                "Should I apply this to:\n{options}\n"
                "Let me know which scope you intended."
            ),
            "without_candidates": (
                "Could you clarify the scope? For example, "
                "should this apply to your account only or "
                "to all accounts in the organization?"
            ),
        },
    }

    template_set = templates.get(
        ambiguity.ambiguity_type,
        {
            "with_candidates": "I need a bit more detail. Did you mean:\n{options}",
            "without_candidates": "Could you provide a bit more detail?",
        },
    )

    if ambiguity.candidates:
        options = "\n".join(
            f"  {i+1}. {c}" for i, c in enumerate(ambiguity.candidates)
        )
        return template_set["with_candidates"].format(options=options)

    return template_set["without_candidates"]

The Confidence Threshold Pattern

Not every ambiguity needs a clarifying question. If the agent is 90% confident about the user's intent, asking for clarification is annoying. If it is 50/50, clarification is essential:

@dataclass
class IntentMatch:
    intent: str
    confidence: float
    entities: dict


def should_clarify(
    matches: list[IntentMatch],
    clarify_threshold: float = 0.3,
    auto_resolve_threshold: float = 0.85,
) -> dict:
    """Decide whether to clarify, auto-resolve, or reject."""

    if not matches:
        return {
            "action": "reject",
            "message": "I'm not sure what you're asking. Could you rephrase?",
        }

    top_match = matches[0]

    # High confidence — proceed without asking
    if top_match.confidence >= auto_resolve_threshold:
        return {
            "action": "proceed",
            "intent": top_match.intent,
            "entities": top_match.entities,
        }

    # Check if top two matches are close
    if len(matches) >= 2:
        spread = top_match.confidence - matches[1].confidence

        if spread < clarify_threshold:
            return {
                "action": "clarify",
                "candidates": [
                    {"intent": m.intent, "confidence": m.confidence}
                    for m in matches[:3]
                ],
            }

    # Moderate confidence, no close competitor — proceed with confirmation
    return {
        "action": "confirm",
        "intent": top_match.intent,
        "message": (
            f"Just to confirm — you'd like to "
            f"{intent_to_description(top_match.intent)}?"
        ),
    }


def intent_to_description(intent: str) -> str:
    descriptions = {
        "cancel_order": "cancel your order",
        "track_order": "check your order status",
        "start_return": "start a return",
    }
    return descriptions.get(intent, intent)

Smart Defaults for Common Ambiguities

When the ambiguity has an obvious "most likely" resolution, use a smart default with implicit confirmation:

SMART_DEFAULTS = {
    "cancel_order": {
        "default_target": "most_recent_order",
        "confirmation": (
            "I'll cancel your most recent order (ORD-7821, placed yesterday). "
            "If you meant a different order, let me know."
        ),
    },
    "check_balance": {
        "default_target": "primary_account",
        "confirmation": (
            "Here's the balance for your primary account (ending 4521). "
            "Want to see a different account?"
        ),
    },
    "schedule_appointment": {
        "default_target": "next_available_slot",
        "confirmation": (
            "The next available slot is Thursday at 2 PM. "
            "Does that work, or would you prefer a different time?"
        ),
    },
}


def resolve_with_default(intent: str, entities: dict) -> dict:
    """Apply smart defaults when entities are missing."""
    default = SMART_DEFAULTS.get(intent)
    if not default:
        return {"resolved": False}

    return {
        "resolved": True,
        "target": default["default_target"],
        "confirmation_message": default["confirmation"],
        "allows_override": True,
    }

Smart defaults speed up the happy path. The key is always telling the user what you assumed and making it easy to override.

Multi-Turn Disambiguation

Sometimes ambiguity cannot be resolved in a single exchange. Build a disambiguation session that tracks resolution state:

class DisambiguationSession:
    """Manage a multi-turn disambiguation process."""

    def __init__(self, original_input: str, candidates: list[dict]):
        self.original_input = original_input
        self.candidates = candidates
        self.eliminated: set[int] = set()
        self.turns = 0
        self.max_turns = 3

    def ask_discriminating_question(self) -> str | None:
        active = [
            c for i, c in enumerate(self.candidates)
            if i not in self.eliminated
        ]

        if len(active) <= 1:
            return None  # Resolved

        if self.turns >= self.max_turns:
            return None  # Give up, use best guess

        # Find the attribute that best splits remaining candidates
        distinguishing_attr = self._find_best_discriminator(active)
        self.turns += 1

        values = set(c.get(distinguishing_attr, "unknown") for c in active)
        options = "\n".join(f"  - {v}" for v in values)
        return (
            f"Could you help me narrow it down? "
            f"Which {distinguishing_attr} are you referring to?\n{options}"
        )

    def process_answer(self, answer: str) -> list[dict]:
        active = [
            c for i, c in enumerate(self.candidates)
            if i not in self.eliminated
        ]
        # Filter candidates based on answer
        remaining = [
            c for c in active
            if answer.lower() in str(c).lower()
        ]
        return remaining

    def _find_best_discriminator(self, candidates: list[dict]) -> str:
        # Find the attribute with the most unique values
        if not candidates:
            return "name"
        attrs = candidates[0].keys()
        best_attr = max(
            attrs,
            key=lambda a: len(set(str(c.get(a)) for c in candidates)),
        )
        return best_attr

FAQ

How do I avoid "clarification loops" where the agent keeps asking questions?

Set a hard limit of 2-3 clarifying questions per topic. After that, make a best-guess decision with explicit confirmation: "Based on our conversation, I think you mean X. I'll go ahead with that — let me know if that's not right." Also, track which clarifications actually helped resolve ambiguity in your analytics. If a particular question never leads to resolution, remove it.

When should the agent guess vs. ask for clarification?

Use the risk-based approach: for low-stakes actions (displaying information, answering a question), guess with implicit confirmation. For high-stakes actions (canceling an order, sending money, deleting data), always ask for explicit confirmation, even if confidence is high. The cost of a wrong guess on a destructive action far outweighs the friction of one extra question.

How do I handle ambiguity when the user's language is vague on purpose?

Some users are intentionally vague because they do not know the right terminology or they are exploring. In these cases, do not force precision. Instead, offer a guided exploration: "It sounds like you're looking for help with your account. Here are the most common things I can help with: [list]. Which of these is closest to what you need?" This respects the user's uncertainty while moving the conversation forward.

---

#Ambiguity #Disambiguation #ConversationDesign #AIAgents #NLU #AgenticAI #LearnAI #AIEngineering