💬 NLP

Reasoning about Intent for Ambiguous Requests

This paper proposes a reinforcement learning-based method that generates a single structured response enumerating multiple valid interpretations for ambiguous requests, thereby improving coverage and transparency without requiring additional interaction rounds or explicit supervision.

Original authors: Irina Saparina, Mirella Lapata

Published 2026-08-11

📖 8 min read🧠 Deep dive

CC BY 4.0

Original authors: Irina Saparina, Mirella Lapata

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are talking to a super-smart robot that knows almost everything. You ask it a question, but you forget to mention a tiny detail, like the year or the specific type of thing you mean. In the world of Artificial Intelligence, this is called "ambiguity." It's like asking a friend, "What's the best movie?" without telling them if you want a scary horror film or a funny comedy. The robot has to guess what you mean. Usually, it just picks one guess, answers you, and hopes for the best. If it guesses wrong, you get a frustrating answer, or worse, the robot might accidentally give you something dangerous because it misunderstood your intent. This paper, written by researchers at the University of Edinburgh, tackles this problem of "guessing wrong" by teaching robots to stop guessing and start listing all their options at once.

The researchers, Irina Saparina and Mirella Lapata, propose a new way for these Large Language Models (LLMs) to handle tricky questions. Instead of silently committing to a single interpretation, their method, called IntentRL, forces the model to act like a helpful librarian who says, "I see you asked for 'the best movie.' Here are three different ways to understand that: 1) The best horror movie, 2) The best comedy, and 3) The best movie of all time. Here is the answer for each." The paper suggests that by training the model to explicitly list these different meanings and their corresponding answers in a single go, we can avoid confusion and make the AI safer and more transparent. They tested this on tasks like answering conversation questions and writing computer code (specifically SQL queries for databases), finding that their method covers more correct answers than previous tricks like asking the user for clarification or just hoping the robot gets it right.

The Problem: The Robot's "One-and-Done" Guess

Imagine you are playing a game of "20 Questions" with a robot. You say, "I'm thinking of a fruit that is red." The robot immediately shouts, "Apple!" and stops. But wait! You were actually thinking of a strawberry, or maybe a cherry, or even a red bell pepper. The robot didn't ask, "Did you mean a berry?" or "Did you mean a vegetable?" It just picked the first thing that popped into its digital head.

In the real world, this happens all the time. People are often brief or forget details when they talk to computers. A user might ask, "Show me films with a budget of 20 million," but they might mean "films that are both horror and thriller with that budget," or "films that are either horror or thriller with that budget." If the robot picks the wrong meaning, the answer is useless. Even worse, if the robot is a "reasoning model" (one that thinks for a long time), it might spend thousands of "tokens" (its way of thinking steps) chasing the wrong idea, wasting energy and reinforcing its own mistake.

The Old Ways: Asking or Rambling

Before this new method, scientists tried two main ways to fix this:

The Clarification Question: The robot stops and asks, "Do you mean horror or thriller?" This works, but it's annoying. It turns a quick question into a long, back-and-forth conversation. It's like asking your friend, "Wait, do you want a red apple or a red strawberry?" every time you ask for a fruit.
The Long-Form Answer: The robot tries to be super helpful by writing a huge paragraph that covers everything. "Well, if you mean horror, it's X. If you mean thriller, it's Y. If you mean both, it's Z." This is often messy and hard to read. It's like a friend giving you a 10-page essay to answer a simple question. Plus, if the meanings contradict each other (like "show me films that are both horror and thriller" vs. "show me films that are either"), it's hard to mash them into one smooth story.

The New Solution: The "Menu" Approach

The authors of this paper suggest a third way: The Structured Menu. Instead of guessing or rambling, the robot generates a neat list of "Interpretation-Answer Pairs."

Think of it like ordering at a restaurant where the menu is ambiguous. If you say, "I'll have the special," and the special could be a burger or a salad, a normal waiter might just bring you a burger. The IntentRL robot, however, brings you a tray with three small plates:

Plate 1: "If you meant the burger special, here is your burger."
Plate 2: "If you meant the salad special, here is your salad."
Plate 3: "If you meant the soup special, here is your soup."

The robot does this in one single step. It doesn't wait for you to say "No, I wanted the salad." It just gives you all the options at once, clearly labeled. This is great because:

Transparency: You can see why it gave you that answer.
Speed: No waiting for a second round of conversation.
Safety: If one answer is dangerous, you can spot it immediately because you see the other options too.

How They Taught the Robot: The "Double-Goal" Game

Teaching a robot to do this is tricky. You can't just show it a list of questions and answers because the robot needs to learn when to list multiple things and when to just give one answer. If you teach it to always list five options, it will annoy you when you ask a simple question like "What is 2+2?"

The researchers used a technique called Reinforcement Learning (think of it as training a dog with treats). They gave the robot a special "dual reward" system:

The "Catch-All" Reward (Recall): If the question is ambiguous (like "What other state ruled it?"), the robot gets a big treat if it lists all the possible valid answers. It's like a fishing game where you get points for catching every type of fish in the pond, not just one.
The "Precision" Reward: If the question is clear (like "What is the capital of France?"), the robot gets a treat for giving only the one correct answer. If it tries to list five different capitals, it gets no treat (or a penalty).

Crucially, they didn't need to teach the robot what the "interpretations" were. They only needed the list of correct answers. The robot figured out the rest on its own by trying to maximize its treats. It learned to say, "Hmm, this question could mean A, B, or C. I'll list all three to be safe," or "This question is simple. I'll just give the one answer."

The Results: A Clear Winner

The team tested this new method on two different types of tasks:

Conversational Question Answering: Answering questions based on a story or conversation.
Text-to-SQL: Turning English questions into computer code (SQL) to query a database.

They compared their method (IntentRL) against:

Just asking the robot to guess (Prompting).
Teaching the robot by showing examples (Supervised Fine-Tuning).
The "Clarification Question" method (asking the user).
Super-smart, closed-source models (like GPT-5.4 and Gemini 2.5 Pro).

The findings were surprising:

Better Coverage: IntentRL found the correct answer in 74.1% of ambiguous cases (Full Coverage), while the best closed-source models only managed around 16%. Even the "Thinking" models (which spend a lot of time reasoning) didn't do much better than standard models.
No "Over-thinking": The researchers found that simply making the robot "think" longer didn't help it find more answers. The robot would often get stuck on the same wrong idea. IntentRL, however, learned to systematically explore different paths.
Generalization: When they tested the robot on a completely new type of database it had never seen before, IntentRL still worked well. The other methods (like standard training) failed because they just memorized the old database patterns. This suggests IntentRL learned a general skill of "thinking about what the user means," rather than just memorizing answers.
Human Approval: When humans looked at the robot's answers, they agreed that the interpretations made sense 90% of the time. The robot wasn't just making up random lists; it was actually explaining its logic.

What This Means for the Future

The paper suggests that the key to handling ambiguity isn't just making the robot bigger or smarter, or asking it to "think harder." It's about teaching it to reason about intent. By forcing the model to generate a structured list of possibilities, we get a system that is more honest about what it knows and what it doesn't.

The authors note that while their method is great, it's not perfect. Sometimes the robot lists too many options (up to 5), and for extremely vague questions, a human might still need to step in. Also, they didn't test if humans prefer this menu style over a simple conversation, though they suspect it would be very useful for technical tasks like writing code.

In short, this paper shows that by teaching AI to say, "Here are all the ways I could understand your question, and here are the answers for each," we can build robots that are less likely to misunderstand us, less likely to waste time, and much more helpful in the long run. It's a shift from "guessing and hoping" to "listing and clarifying," all in a single, efficient step.

Technical Summary: Reasoning about Intent for Ambiguous Requests

Problem Statement

Large Language Models (LLMs) frequently encounter ambiguous user requests where multiple plausible interpretations exist. Current models typically respond by implicitly committing to a single interpretation, which can frustrate users, obscure the model's reasoning, and create safety risks if the chosen interpretation is incorrect. Furthermore, reasoning models may waste computational resources by expending tokens on incorrect interpretations.

Existing strategies for handling ambiguity present distinct trade-offs:

Clarification Questions: Require additional interaction rounds, increasing latency and user effort.
Long-form Answers: Cover multiple interpretations in a single verbose response but lack explicit structure, making them difficult to parse for downstream applications (e.g., agentic systems) and potentially overwhelming for users.
Parallel Sampling: Often fails to produce substantially different outputs due to model biases toward specific completions.

The core challenge is teaching models to recognize ambiguity, enumerate valid interpretations, and provide corresponding answers without requiring explicit interpretation labels or clarification questions during training.

Methodology

The authors propose IntentRL, a reinforcement learning approach that trains models to generate a single structured response containing multiple interpretation-answer pairs.

1. Output Format

Instead of a single answer or a clarification dialogue, the model generates a sequence of pairs $\{(i_1, a_1), \dots, (i_m, a_m)\}$ , where:

$i_k$ is an explicit interpretation that disambiguates the input (e.g., "Other state refers to the predecessor of Bohemia").
$a_k$ is the corresponding answer for that specific interpretation.
The model generates up to five pairs sequentially. Due to the autoregressive nature of LLMs, subsequent interpretations are conditioned on previous ones, encouraging diversity and semantic alignment.

2. Training Framework

The method utilizes DAPO (Decoupled Clip and Dynamic Sampling Policy Optimization), an extension of Group Relative Policy Optimization (GRPO).

Supervision: The approach requires only gold answers as supervision. It does not require gold interpretations, clarification questions, or explicit reasoning traces. Ambiguous inputs are identified by the presence of multiple valid answers ( $|A| > 1$ ) in the dataset.
Dual Reward Objective:
- For Ambiguous Inputs ( $|A| > 1$ ): The reward is based on Recall. The model is optimized to maximize the coverage of distinct valid interpretations found in the gold set.
- For Unambiguous Inputs ( $|A| = 1$ ): The reward is based on Precision. The model is penalized for generating spurious alternatives, encouraging it to recognize when a single intent suffices.
Matching Mechanism: To compute rewards, the predicted answers are matched against gold answers using the Hungarian algorithm to find the optimal one-to-one mapping based on a similarity score (exact match for SQL execution, word-overlap F1 for QA).

3. Data Balancing

Datasets often contain far more unambiguous examples than ambiguous ones. The authors employ a 3:1 oversampling ratio for ambiguous examples during training. This ensures the model receives sufficient learning signals for handling ambiguity while using unambiguous examples as regularization to prevent over-generation.

Key Contributions

Structured Ambiguity Resolution: The paper introduces a single-step generation method that produces structured interpretation-answer pairs, offering a balance between the interactivity of clarification questions and the efficiency of direct answers.
Training with Sparse Supervision: The method demonstrates that models can learn to reason about user intent and enumerate interpretations using only answer annotations, eliminating the need for expensive interpretation labels or clarification dialogue data.
Dual-Objective Reinforcement Learning: The introduction of a dual reward objective (recall for ambiguous, precision for unambiguous) effectively teaches the model to dynamically switch between enumerating options and committing to a single answer.
Empirical Validation: The approach is validated across two distinct tasks: Conversational Question Answering (Abg-CoQA) and Text-to-SQL Parsing (Ambrosia, AmbiQT).

Results

Performance on Ambig-CoQA (Conversational QA)

IntentRL achieved 78.1% recall and 61.0% full coverage on ambiguous questions, significantly outperforming baselines like IntentPrompt (62.3% recall) and Supervised Fine-Tuning (SFT) (48.1% recall).
SFT models tended to overfit to unambiguous cases, failing to generate multiple interpretations even when necessary.
IntentRL maintained high performance on unambiguous questions (90.9% recall), demonstrating it does not blindly over-generate.

Performance on Ambrosia (Text-to-SQL)

IntentRL achieved 82.4% recall and 74.1% full coverage on ambiguous SQL queries, outperforming the state-of-the-art two-stage method DisambigParse (59.7% recall, 30.5% full coverage).
Notably, IntentRL achieved this with a single-stage training process, whereas DisambigParse requires gold interpretations for training.

Generalization and Human Evaluation

Out-of-Domain Generalization: When trained on Ambrosia and tested on the out-of-domain AmbiQT benchmark, IntentRL achieved 49.1% full coverage, whereas SFT collapsed to 9.1%. This suggests IntentRL learns general reasoning skills about ambiguity rather than dataset-specific patterns.
Human Evaluation: Annotators confirmed that 90.0% (Abg-CoQA) and 91.7% (Ambrosia) of the predicted interpretations were aligned with their corresponding answers, validating that the generated interpretations meaningfully explain the answers.
Comparison with SOTA: IntentRL outperformed the multi-turn clarification method ACT (83.0% similarity vs. 75.1%) and significantly outperformed closed-source frontier models (GPT-5.4, Gemini 2.5 Pro) in full coverage on Ambrosia (74.1% vs. ~16%).

Significance and Claims

The paper claims that IntentRL promotes transparency by making interpretations explicit, thereby allowing users to quickly identify their intended meaning without additional interaction rounds. The structured output format supports downstream applications, particularly in agentic systems where branching across interpretations is beneficial.

Crucially, the authors argue that the performance gains stem from learning to reason about user intent rather than merely adopting a specific output format. Experiments show that parallel sampling and alternative prompting strategies fail to recover the diversity of interpretations that IntentRL achieves through targeted training.

The work advocates for a shift in handling ambiguity: rather than silently committing to a single (potentially wrong) interpretation or engaging in costly clarification loops, models should be trained to enumerate plausible interpretations when necessary. This approach is presented as a step toward more robust, user-aligned LLMs that embrace ambiguity rather than obscuring it, particularly in safety-critical applications where over-generating plausible interpretations is preferable to silent failure.

The authors acknowledge limitations, including the fixed limit of five interpretations and the need for strong backbone models, but emphasize that the method generalizes well across domains and model families without requiring complex annotation pipelines.