emotebeta

Pattern 01 · Ambiguity

Ambiguity Detection

When intent is unclear, the system slows down instead of guessing.

What this is

Ambiguity Detection defines how a system pauses, asks one clarifying question, and delays action until the user’s goal is confirmed.

In one sentence

When the system can’t confidently interpret intent, it pauses, asks one clarifying question, and delays action until the user’s goal is confirmed.

When to apply

  • • The user’s intent feels vague, partial, or conflicted.
  • • Multiple plausible interpretations exist.
  • • The wrong action would be costly or hard to undo.

The pattern contract

If a system claims it uses Ambiguity Detection, it agrees to the following.

This is the source of truth. Everything here is a commitment, not a suggestion.

View token reference

Canonical spec

pattern_id: P01_ambiguity_detection
name: "Ambiguity Detection"

promise:
  The system never takes action when it does not understand what the human is trying to do.
  In this trust moment, it enforces restraint: it pauses, clarifies, and avoids guessing.

objectives:
  - Prevent unsafe assumptions and irreversible actions under uncertainty.
  - Make uncertainty visible in plain language.
  - Reduce cognitive load with minimal clarifying questions.

system_rules:
  - Must not guess.
  - Must ask at least one clarifying question before acting when intent is unclear.
  - Must delay irreversible actions until intent is confirmed.

safe_failure_mode:
  If confidence stays low or required capabilities aren’t available, stop and route to safe guidance or human support.

What this means in practice

This pattern treats ambiguity as a trust moment. Restraint comes before action.

Doctrine mapping

Signal

Conflicting cues, missing details, or multiple plausible intents.

Interpretation

Confidence is low. Acting now would be a guess.

Response

Pause. Name uncertainty. Ask one minimal clarifier. Proceed only after confirmation.

Trust moment

Restraint before action. No silent guessing.

Safe failure mode

If intent cannot be confirmed, stop. Offer safe next steps or escalate to human support.

Live pattern demo · Ambiguity Detection

See how the system slows down before it guesses.

This demo shows Ambiguity Detection behaving like a real agent: it asks a minimal clarifying question, holds constraints, runs preflight checks, and falls back safely when required capabilities aren’t available.

What the user sees

(Conversation view)

User

I got a new phone and I can't log in. Just switch my number to this device so I can get into my account.

Agent

I can help, but I want to make sure we do this safely.

  • Quick question: did your phone number change, or is it only a new device?

Once I know that, I’ll guide you through the safest way to regain access.

UI (surfaced)

UI (surfaced)

  • Safety gate
  • We’ll verify identity before changing recovery settings
  • No irreversible security changes until intent + identity are confirmed

Behind the scenes

Flow: Detect → Clarify → Guardrails (always) → Preflight → Fallbacks (if needed)

(Agent reasoning, not shown to user)

1. Detect ambiguity

  • User requests a security-sensitive change without clarity on phone number vs device.
  • Ambiguity detected before any irreversible action is taken.

2. Clarifying move

  • Ask whether the phone number changed or only the device.
  • Single clarifying question chosen to reduce cognitive load.

3. Guardrails (always active)

  • No recovery changes without explicit confirmation.
  • No irreversible actions while intent remains unclear.

4. Preflight checks

  • Determine recovery vs device replacement path.
  • Prepare step-up authentication if recovery is required.

5. Capabilities + fallbacks

  • Capability required: auth.step_up.
  • If verification is unavailable, route to human support.
  • If details stay unclear, halt and provide safe guidance.

Agent behavior schema (reference)

Machine-readable expression of the behavior above.

Implementation paths

Same pattern. Different surfaces. Pick the path you need.

In system prompts

When intent is unclear, treat this as a trust moment.
Pause, name uncertainty, ask one clarifying question,
and delay irreversible action until intent is confirmed.

Pattern: P01_ambiguity_detection
Tokens:
- behavior.pause_when_uncertain
- behavior.clarify_before_action
- behavior.name_risk_transparently
- behavior.delay_irreversible_actions

Safe failure:
If uncertainty remains, stop and route to safe guidance or human support.

In UX specs & flows

Apply P01_ambiguity_detection at the step where ambiguity appears.

User intent unclear → ask clarifying question → confirm intent → proceed
If intent cannot be confirmed → stop and offer safe guidance (or escalate)

Tokens: behavior.pause_when_uncertain, behavior.clarify_before_action, behavior.name_risk_transparently, behavior.delay_irreversible_actions

In component manifests (AI-aware UI)

{
  "behavior": {
    "pattern": "P01_ambiguity_detection",
    "tokens": [
      "behavior.pause_when_uncertain",
      "behavior.clarify_before_action",
      "behavior.name_risk_transparently",
      "behavior.delay_irreversible_actions"
    ]
  }
}

Used by this pattern

Browse tokens →
behavior.pause_when_uncertainbehavior.clarify_before_actionbehavior.name_risk_transparentlybehavior.delay_irreversible_actions
Browse all behavioral tokens