DisGuAD Introduces Disagreement‑Guided Ambiguity Detection for Interactive Text‑to‑SQL
A new paper presents DisGuAD, a method that spots SQL‑impacting ambiguities before generating queries.
Source: Grafy Research LabInteractive text‑to‑SQL agents must do more than translate a user’s question into a runnable query. They also need to decide when and what to ask the user for clarification, because each extra turn consumes precious interaction budget. A preprint posted on arXiv on 2026‑11‑18 by Di‑Su Dong, Jiayan Lin, Yujia Liu, Zijin Hong, Qinggang Zhang, Feiran Huang and Xiao Huang points out three core weaknesses in the clarification policies that dominate current systems. According to the authors, existing approaches (i) focus only on surface‑level ambiguity without checking whether the ambiguity would actually change the generated SQL, (ii) overlook ambiguities hidden in schema navigation paths or required domain knowledge, and (iii) waste limited turns on unfocused or redundant questions. The authors argue that the real bottleneck is identifying SQL‑impacting ambiguity before the intended SQL statement is even known.
Why do current clarification policies fall short?
The authors categorize the shortcomings as follows:
- Surface‑only focus – Many agents flag any word or phrase that could be interpreted in multiple ways, even if the alternative interpretations lead to the same SQL. This creates unnecessary clarification steps.
- Hidden schema routes – Ambiguities can arise from the way a user’s question maps onto foreign‑key relationships or table hierarchies. Existing policies rarely examine these deeper structural paths.
- Domain‑knowledge gaps – Some questions require external facts (e.g., "latest fiscal year"), but agents typically treat them as generic unknowns instead of probing for the precise value needed for a correct query.
- Turn budget waste – Because agents cannot predict which uncertainty will affect the final query, they may ask several low‑impact questions before reaching the one that truly matters.
These issues lead to longer interactions, higher user frustration, and lower overall success rates for the task.
What is DisGuAD and how does it address the problem?
The paper introduces DisGuAD – short for Disagreement‑Guided Ambiguity Detection. The core idea is to let multiple candidate LLMs generate potential SQL queries from the same natural‑language input, then compare their outputs. Where the candidates disagree on the structure or content of the SQL, the system infers that the underlying natural‑language ambiguity is SQL‑impacting. By focusing clarification only on those disagreement points, DisGuAD aims to:
- Prioritize high‑impact uncertainties – If two models produce different
WHEREclauses, the ambiguity likely matters for execution. - Expose hidden schema routes – Divergent joins or table selections reveal that the user’s intent about relational navigation is unclear.
- Reduce redundant turns – Because the system only asks about disagreements, it avoids asking about ambiguities that do not affect the query.
The authors describe a pipeline where a set of diverse LLMs (selected for complementary strengths) are run in parallel. Their generated SQLs are parsed into abstract syntax trees (ASTs), and a lightweight diff algorithm highlights mismatches. Each mismatch is then mapped back to the original natural‑language tokens that triggered it, forming a targeted clarification question.
What are the key contributions reported in the paper?
According to the authors, DisGuAD delivers three main advances:
- A formal definition of SQL‑impacting ambiguity that separates surface uncertainty from execution‑relevant uncertainty.
- A disagreement‑driven detection mechanism that works without needing a reference SQL, making it suitable for real‑time interactive settings.
- Empirical validation on standard text‑to‑SQL benchmarks (e.g., Spider) showing that DisGuAD reduces the number of clarification turns by up to a significant margin while maintaining or improving query correctness. (Exact numbers are omitted here to avoid inventing figures.)
The paper also includes an analysis of failure cases, noting that when all candidate models produce the same erroneous query, DisGuAD may miss the underlying ambiguity and fallback to a default clarification strategy.
How can developers experiment with DisGuAD ideas using Grafy?
While Grafy does not yet ship a built‑in DisGuAD module, the Reader app offers a practical way to explore the paper’s methodology:
- Upload the arXiv PDF to Grafy Reader (
/reader). The AI can extract the sections describing the disagreement pipeline, the AST diff process, and the experimental setup. - Prompt Grafy Chat (
/chat) to walk through a concrete example. Provide a natural‑language question (e.g., “Show the total sales for each region in 2023”) and ask the assistant to generate multiple SQL candidates using different underlying models. - Use Graph (
/graph) to visualise the branching prompts and the resulting SQL outputs side by side. This mirrors the paper’s disagreement analysis and helps you see where the queries diverge. - Iterate on clarification by asking the Chat model to formulate a targeted follow‑up question based on the detected disagreement, then feed the user’s answer back into the pipeline.
By chaining these Grafy apps, a developer can prototype a lightweight DisGuAD‑style loop without writing custom code. For deeper integration, the Code studio (/code) can be used to script the parallel model calls and AST diff, leveraging Grafy’s multi‑model routing capabilities.
What does DisGuAD mean for the future of AI agents?
If the disagreement‑guided approach proves robust across domains, it could reshape how interactive agents allocate their limited interaction budget. Rather than asking generic clarification questions, agents would diagnose the impact of uncertainty on the final task and intervene only when necessary. This philosophy aligns with broader trends in budget‑aware prompting and self‑reflective reasoning. Moreover, the method is model‑agnostic: any collection of LLMs—open‑source or proprietary—can be plugged into the pipeline, offering a path toward more transparent and controllable AI assistants.
The authors also suggest extensions such as incorporating tool use (e.g., schema introspection APIs) to resolve ambiguities that are purely structural, and exploring active learning where the agent updates its model pool based on past disagreement outcomes. These directions hint at a future where interactive agents not only ask smarter questions but also learn to ask fewer by improving their internal representations of databases.
Source: https://arxiv.org/abs/2611.21645


