Agentic Text-to-SQL systems can interact with users to clarify underspecified queries before generating SQL. However, a correct execution result does not necessarily imply that the agent has adequately resolved the underlying underspecification: the agent may silently make unverified assumptions that happen to match the intended answer. We show that this behavior is driven in part by premature clarification termination. Although forcing an agent to ask more questions improves execution accuracy, ambiguities are concentrated in earlier interactions, making brute-force questioning inefficient. More importantly, even when explicitly prompted to plan its clarification process, the agent frequently abandons questions that it has already identified as relevant. To address this failure mode, we introduce PlanPool, which externalizes the clarification plan as a mutable question pool. Every planned question must be explicitly asked or dropped before submission, while newly discovered ambiguities can be added during interaction. Across three benchmarks derived from BIRD-Interact and Spider, PlanPool consistently improves ambiguity coverage and reduces silent failures over unconstrained and prompt-based alternatives, while maintaining competitive execution accuracy. Our results highlight an important distinction in agentic reasoning: identifying missing information is not sufficient, and the agent must also reliably maintain and resolve it before committing to an answer.
Figures & tables
Figure 1: (a) Execution accuracy comparison on three datasets in single- and multiple-turn settings. (b) Ground-truth annotated ambiguity distributions versus ambiguities detected through multiple-turn interaction.
Figure 2: (a) Execution accuracy scaling with the number of clarification questions k . (b) Cumulative composition of asked clarification questions as k increases. (c), (d) Planned versus actually asked question distributions for prompting-based plan mode on BIRD-Lite and BIRD-Full.
Statistic
BIRD-Lite
BIRD-Full
Spider
# Instances
171
225
297
# Distinct Databases
18
22
19
# Tokens / User Query
31.8
24.0
14.3
# Tokens / SQL
149.5
78.5
18.1
# Ambiguities / Task
3.56
2.77
2.08
Table 1: Dataset statistics.
Dataset
Method
EA ↑
Recall ↑
GS ↑
US ↓
SF ↓
#Asks ↓
BIRD-Lite
Naive
74.3
73.9
33.9
40.4
17.0
2.3
Read-All
69.6
70.8
29.8
39.8
18.7
2.0
Regenerate
74.9
73.7
31.6
43.3
15.2
2.3
Draft
75.4
71.6
28.7
46.8
19.9
2.5
Self-Reflection
77.2
75.5
35.7
41.5
16.4
2.7
Plan-Prompt
79.5
80.8
42.1
37.4
10.5
3.3
Table 2: Method comparison across datasets.
Statistic
BIRD-Lite
BIRD-Full
Spider
Initial Pool Size
3.9
3.3
2.3
Actual Asks
4.2
3.6
2.5
Unmodified Pool
65.5%
61.8%
81.5%
Adding question usage
30.4%
32.9%
18.5%
Dropping question usage
4.7%
10.7%
0.7%
Table 3: PlanPool tool usage across datasets.
Figure 3: Annotated versus detected ambiguity distributions produced by different methods, together with the KL divergence with respect to the annotated ground-truth distribution: (a) BIRD-Lite, (b) BIRD-Full, and (c) Spider.
Dataset
Method
Input Tok. ↓
Output Tok. ↓
Cost ()\downarrow$
BIRD-Lite
Naive
136k
2.4k
0.36
Read-All
122k
1.8k
0.30
Regenerate
169k
3.1k
0.35
Draft
139k
2.7k
0.29
Plan-Prompt
148k
2.6k
0.29
PlanPool
201k
2.5k
0.32
Table 4: Computational cost across datasets. Token counts are averaged per query.
Appendix figures & tables11 assets
Supplementary material from the paper’s appendix.
Appendix
Figure 4: Construction pipeline for the multi-ambiguity Spider benchmark. Each applicable operator introduces one type of underspecification, after which the modified instance is validated and annotated.
Action
Observation
execute
SQL execution result
get_schema
Database schema with example data
get_all_column_meanings
Meanings of all columns
get_column_meaning
Meaning of the specified column
get_all_external_knowledge_names
Names of available external knowledge
get_knowledge_definition
Definition of the specified knowledge
Appendix
Table 5: Datasource interaction tools adopted from BIRD-Interact. We use the original tool interfaces but ignore the action-level costs defined in BIRD-Interact.
Step
Pool Action
Outcome
1
pool_next(Q0)
The user specifies that artifacts should be ranked directly by CPI rather than AVS: “Just use the Conservation Priority Index (CPI) itself—rank by CPI, no AVS needed.”
2
pool_drop(Q1)
As AVS is no longer needed, ERF becomes irrelevant. The agent explicitly removes Q1 instead of asking an unnecessary question, reasoning that CPI alone is sufficient.
3
pool_next(Q2)
The user clarifies that CPI should not be taken directly from ConservePriorityScore : “No, don’t use that column. CPI needs to be calculated from the artifact’s historical significance, research value, cultural score, and conservation status.”
4
pool_add(Q5)
The previous answer reveals a new clarification need. The agent adds the following question with highest priority: “What is the exact CPI formula? How are the ratings combined, and what is the numerical mapping for ConserveStatus?”
5
pool_next(Q5)
The user provides the specific formula to calculate CPI.
6
pool_next(Q3)
The user confirms that historical era corresponds to ArtDynasty .
Appendix
Table 6: Evolution of the clarification pool of PlanPool in the case study.
Figure 5: Base system prompt shared by all agentic methods (Part 1/2).
Figure 6: Base system prompt shared by all agentic methods (Part 2/2).
Figure 7: Additional system instruction used by the Read-All baseline.
Figure 8: Runtime observation injected by the Regenerate baseline after two independently generated SQL candidates diverge.
Figure 9: Additional system instruction used by the Draft baseline.
Figure 10: Additional system instruction used by the Self-Reflection baseline.
Figure 11: Additional system instruction used by the Plan-Prompt baseline.
Figure 12: Additional system instruction used by PlanPool .
Text-to-SQL systems typically assume a one-to-one mapping between natural-language queries and correct SQL translations. In practice, however, many queries are inherently ambiguous, admitting multiple valid interpretations that yield distinct outputs. We introduce Adversarial Intent Resolution (AIR), a multi-agent framework that actively probes and resolves such ambiguity without any task-specific training. AIR first constructs competing interpretations, verifies through SQL execution that they produce genuinely different results, and generates targeted clarification questions grounded in the observed data differences. Evaluating on leading benchmarks for ambiguous questions, AIR demonstrates strong performance, efficiency, and robust cross-benchmark transferability. On the AMBROSIA benchmark under schema-only context, a realistic production setting where exposing the full database is infeasible, AIR outperforms IntentRL, the state-of-the-art reinforcement learning model, across all metrics (e.g., F1 0.679 vs. 0.618). Crucially, AIR exhibits only ~7% performance degradation without the full database, compared to ~20% for IntentRL. On the AmbiQT benchmark, where ambiguity arises from schema design rather than linguistic structure, AIR achieves higher F1 under both context settings without any benchmark-specific adaptation.
As text-to-SQL systems move beyond demonstrations toward real-world deployment, ambiguity in user questions becomes a primary source of errors. Such ambiguities are often subtle, domain- or data-specific, and can silently cause system outputs to deviate from the user's true intent. Ambiguity is traditionally addressed through conversational clarification, which is often inefficient, cognitively demanding, and poorly aligned with real-world user workflows. We propose structured disambiguation, a new paradigm in which ambiguity is resolved through explicit, constrained interactions rather than free-form dialogue. We construct ARCS (Ambiguity Resolution Corpus for SQL), the first text-to-SQL benchmark featuring naturally occurring, unconstrained ambiguities over real-world databases, with complete annotations of all valid ambiguity points, interpretations, and SQL queries. Experimental results show that text-to-SQL remains challenging in the presence of ambiguity: gpt-6-sol achieves only 51% end-to-end execution accuracy, and no open-source model exceeds 27%.
Text-to-SQL systems often struggle with deep contextual understanding, particularly for complex queries with subtle requirements. We present PV-SQL, an agentic framework that addresses these failures through two complementary components: Probe and Verify. The Probe component iteratively generates probing queries to retrieve concrete records from the database, resolving ambiguities in value formats, column semantics, and inter-table relationships to build richer contextual understanding. The Verify component employs a rule-based method to extract verifiable conditions and construct an executable checklist, enabling iterative SQL refinement that effectively reduces missing constraints. Experiments on the BIRD benchmarks show that PV-SQL outperforms the best text-to-SQL baseline by 5% in execution accuracy and 20.8% in valid efficiency score while consuming fewer tokens.