acceptodds
Under review as a conference paper at ICLR 2027

RSI-SQL: Recursive Self-Improvement for Text-to-SQL

Abstract

Text-to-SQL agents can repair a query while retaining the grounding error that produced it. We introduce Recursive Self-Improvement for Text-to-SQL, a training-free framework that uses execution feedback to recursively update its own reasoning state. A Graph Grounding Agent revises intent and schema hypotheses, an Actor generates and tests SQL candidates, and a Critic assigns credit to the interactions supporting each trajectory. A typed Action Graph carries the revised hypotheses, observations, and credit into the next round of reasoning. This recursion connects candidate refinement to updates in the evidence used for subsequent decisions. A local analysis characterizes grounding discrepancy and the propagation of intermediate and terminal errors during lookahead. On all 1,534 BIRD development queries, a shared backbone across the three roles achieves 63.50% execution accuracy with Qwen2.5-14B-Instruct and 64.41% with Qwen2.5-Coder-14B-Instruct. Component comparisons reveal interference between retrieval and credit assignment, making their coordination central to the recursive improvement loop. Code is available at https://anonymous.4open.science/r/RSI-SQL-425F.

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
Agent memory, long-horizon, reasoning, Text-to-SQL

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_j3f3OpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper studies schema grounding and error correction in Text-to-SQL. The authors propose RSI-SQL, an inference-time multi-agent framework designed to iteratively refine database queries under database execution feedback. Operating with frozen model parameters, the framework coordinates three LLM-prompted roles: a Graph Grounding Agent that maintains hypothesis particles for schema linking, an Actor Agent that proposes candidate actions (GENERATE, REPAIR, POLL), and a Critic Agent that scores interactions to select candidate trajectories. An Action Graph tracks dependencies across a shallow search horizon (H=3H=3). The paper introduces continuous POMDP and Lipschitz perturbation bounds as theoretical framing, and evaluates the method primarily on BIRD-Dev, Spider-Dev, Spider-DK, and Spider2.0-SQLite using Qwen2.5-14B backbones.

Critical strengths

Sensible Operational Decomposition for Interactive Text-to-SQL: Decomposing complex database reasoning into specialized steps—schema grounding, speculative database polling, and execution-guided repair—is an intuitive operational workflow for interactive SQL generation. The qualitative breakdown of SQL error types (schema mismatch, intent ambiguity, execution semantics) provides descriptive context for understanding where iterative queries fail.

Critical weaknesses
  1. Severe Empirical Inconsistency, Cherry-Picking, and Test Regressions: The paper's primary empirical claim is contradicted within the manuscript. In Table 1, the authors report a headline accuracy of 64.41% on BIRD-Dev for Qwen2.5-Coder-14B. However, in Table 2, the exact same system across five runs crashes to 58.5 ± 0.6%—a 5.91-point drop that lies nearly 10 standard deviations away from the mean. The authors explicitly concede that Table 1 represents a single run ("Each entry is one run"), indicating that the headline claim is a cherry-picked outlier; the reproducible 5-run mean (58.5%) barely beats a simple single decoder (56.9%) by 1.6 points. Furthermore, the authors quietly admit in Section 5.5 and Appendix C.2 that on the official Spider-Test set, the coordinated system actually degraded performance by 5.9 percentage points (82.1% vs. 88.0% for the single decoder), demonstrating severe instability on unseen distributions.

  2. Misleading Nomenclature ("Recursive Self-Improvement") and Prohibitive Compute Cost: Branding this framework as "Recursive Self-Improvement (RSI)" represents substantial concept inflation. The backbone model is 100% frozen with zero model training, parameter updates, or policy learning (Appendix A.4); it is strictly an inference-time prompt loop (ReAct / Reflexion) unrolled for 3 steps. Despite this modest mechanism, answering a single query burns 78.4 model calls, 74.1K tokens, and 136.8 seconds (Table 3), yet the authors provide no compute-matched baseline comparisons (e.g., Best-of-78 sampling or majority voting). Finally, the continuous POMDP and Lipschitz formulations (Propositions 1 & 2) are cosmetic, as the authors concede in Appendix B.2 that they cannot numerically validate the theoretical bounds.

Questions for authors
  1. Resolution of the 9.85$\sigma$ Discrepancy Between Table 1 and Table 2 and Test Regressions: How do the authors reconcile the 5.91 percentage-point collapse from 64.41% in Table 1 to 58.5 ± 0.6% in Table 2 for Qwen2.5-Coder-14B on BIRD-Dev, where 64.41% lies 9.85 standard deviations away from the 5-run mean? If Table 1 is indeed an unrepresentative single outlier, how can the paper's headline claims be justified when the reproducible mean (58.5%) barely improves over the single decoder (56.9% by +1.6 points)? Furthermore, why did the coordinated system severely regress on Spider-Test (-5.9 points below the single decoder in Appendix C.2)?

  2. Compute-Matched Baseline Comparison: In the reported setting at search depth 3 (H=3H=3, Table 3), RSI-SQL requires 78.4 model calls and 136.8 seconds per query. How does a standard single-decoder model perform when granted an equivalent inference-compute budget (e.g., Best-of-78 sampling with execution filtering or majority voting over 78 sampled paths)?

Reviewer_YmWdOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes RSI-SQL, a training-free, inference-time framework for text-to-SQL in which one frozen backbone plays three roles. A Graph Grounding Agent keeps weighted intent and schema hypotheses and updates them in a particle-filter style. An Actor generates, repairs, and polls SQL candidates under a heuristic priority score. A Critic assigns fixed-weight heuristic credit, which is used for lexicographic trajectory selection. A typed Action Graph records dependencies among states, actions, observations, and candidates, and the updated state feeds the next round within each query. The paper also gives Lipschitz-type bounds on grounding discrepancy and finite-depth rollout error. With Qwen2.5-14B-Instruct and Qwen2.5-Coder-14B-Instruct, it reports 63.50% and 64.41% EX on the full BIRD-Dev set. It also reports results on Spider-DK, Spider-Dev, and Spider2.0-SQLite, plus component, cost, particle-count, and failure analyses.

Critical strengths
  • Well-chosen failure mode. The paper targets a real weakness of execution-guided repair: a grounding error, such as the literal 'accepted' versus the stored value 'yes', can survive many syntactically valid repairs, because successful execution does not imply correctness. Treating schema and value interpretation as an explicit, revisable set of hypotheses is a sensible response.
  • Inspectable reasoning state. The typed Action Graph, with its creation ordering and credit annotations, makes each final query traceable to the polls and hypotheses that supported it. This helps with debugging and supports the failure taxonomy in Section 5.5.
  • Backbone-aligned, full-set main evaluation. The main BIRD comparison uses all 1,534 dev queries with the same backbone in every role. This avoids the common confound of a stronger model in the grounding or critic role. The Spider2.0-SQLite gain (10.4 → 20.7 over five runs) suggests the loop helps most where value grounding is hardest.
Critical weaknesses
  • “Recursive self-improvement” is a misnomer. The backbone is frozen, all state is discarded after each query, and nothing that improves the system carries over to later queries. The POMDP, discount, and credit-assignment vocabulary also overstates what is implemented: credit is a fixed heuristic used only for ranking, and γ never enters the algorithm. Without this framing, the method combines known ingredients (hypothesis tracking, value polling, execution-guided repair, tree search, heuristic selection). Its novelty relative to MAC-SQL, CHESS, CHASE-SQL, Reflexion, and LATS is not articulated.
  • Baselines do not support the headline gains. With the same backbones, DAIL-SQL scores 34.31/42.09 on BIRD-Dev, far below the paper’s own single decoder (62.1/56.9, Table 2). The Actor/Critic base (53.59) is also below the Instruct single decoder, so the +29 and +9.9 point gains are measured against weakened references. Against the single decoder, RSI-SQL gains only 1.4–1.6 BIRD points while using about 78 LM calls and 137 s per query, and Appendix C.2 reports earlier losses (63.5 vs. 66.1 on BIRD; 82.1 vs. 88.0 on Spider-Test). The paper includes no compute-matched sampling-plus-selection baseline and no comparison with the strong open systems at similar scale that it cites (OmniSQL, SQL-R1, Arctic-Text2SQL-R1).
  • Contributions are not isolated, and results are inconsistent. The main BIRD table and the component study are single runs without confidence intervals. The component study compares parallel simplified settings instead of removing one part at a time from the full system, so the separate roles of the particle filter, Action Graph, and Critic remain unidentified. The unexplained collapse of Top-K + credit on Coder (54.37, −7.4 vs. retrieval alone) raises stability concerns. The same system name also yields 64.41 (Table 1) and 58.5 (Table 2) on BIRD-Dev with Coder, across six different evaluation units (Table 6).
  • The theory is detached from the method. Proposition 1 is a Lipschitz-plus-triangle-inequality step, and Proposition 2 is a standard simulation-lemma-style rollout bound; neither informs the choice of H, M, or the grounding operator. The representations s_t and A_t are not used by generation, and the authors acknowledge that Table 5 cannot validate the bounds. The appendix also reveals specification gaps: the 0.01 expansion trigger can never fire with M = 64, and the likelihood used to reweight particles is never defined.
Questions for authors

N.A.

Reviewer_yhyiOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces RSI-SQL (Recursive Self-Improvement for Text-to-SQL), a training-free, inference-time multi-agent framework designed to address persistent schema and value grounding errors that survive standard execution-guided SQL repair. Operating over a frozen LLM backbone shared across three roles, a Graph Grounding Agent that maintains and resamples weighted belief particles over user intent and schema links, an Actor that expands trajectories via GENERATE, REPAIR, and database POLL operations, and a Critic that assigns step- and hop-level credit. The framework couples iterative SQL refinement with explicit evidence tracking through a directed acyclic Typed Action Graph. Beyond the system design, the authors provide a local theoretical analysis in a surrogate representation space, deriving Lipschitz bounds on grounding value discrepancy (modeled via a regularized shrinkage operator) and characterizing how intermediate and terminal state perturbations accumulate across finite-depth lookahead rollouts. The approach is empirically validated across BIRD-Dev, Spider-Dev, Spider-DK, and Spider2.0-SQLite using Qwen2.5-14B-Instruct and Qwen2.5-Coder-14B-Instruct backbones, reaching 63.50% and 64.41% execution accuracy on the full 1,534-query BIRD-Dev set, supported by component ablations demonstrating negative interference between naive Top-K retrieval and credit assignment, inference cost measurements, particle-count scaling studies, and failure mode breakdowns.

Critical strengths
  1. Principled coupling of dynamic hypothesis grounding with iterative repair via a Typed Action Graph: Most existing multi-turn Text-to-SQL frameworks treat schema linking as a static preprocessing step or append raw execution outputs into an unstructured prompt history, allowing initial grounding errors (such as implicit value mappings like "accepted" → decision = 'yes') to persist through multiple syntactically valid repairs. RSI-SQL’s formulation, maintaining M weighted grounding hypotheses that are reweighted via database POLL observations and linked to candidate repairs through a directed acyclic Action Graph, directly targets this bottleneck. This is consequential to the overall assessment because it moves inference-time Text-to-SQL beyond surface-level syntax fixing toward genuine belief revision, yielding its strongest empirical gains (+10.3 to +14.1 percentage points) on Spider2.0-SQLite, where hidden domain semantics and complex schemas cause single-pass and naive repair baselines to fail.

  2. Actionable empirical discovery of negative interference between fragment retrieval and credit assignment: The component ablation on the full 1,534-query BIRD-Dev set uncovers a highly consequential phenomenon for agentic system design: combining standard Top-K embedding retrieval with step-level credit assignment severely degrades performance on Qwen2.5-Coder-14B (dropping accuracy by 8.16 points relative to credit alone, with an interaction contrast of -8.09), whereas pairing credit assignment with the full particle-based grounding graph yields a +10.04-point recovery. This finding is consequential because it empirically proves that trajectory evaluators/critics can be actively misled when conditioned on isolated, locally retrieved schema fragments, substantiating the paper's core thesis that evidence retrieval and credit assignment must be jointly coordinated rather than stacked as independent modules.

Critical weaknesses
  1. Reliance on weak, outdated LLM backbones: The evaluation relies exclusively on two relatively small 14B models from 2024 (Qwen2.5-14B-Instruct and Qwen2.5-Coder-14B-Instruct), reaching a peak BIRD-Dev accuracy of only 64.41% (single run). Why it is consequential: It is impossible to tell whether RSI-SQL’s complex recursive loop provides genuine algorithmic value for modern frontier or strong reasoning models, or if it merely acts as an expensive inference-time crutch compensating for the basic grounding failures of weaker 14B models.

  2. Strawman baselines and omission of modern SOTA Text-to-SQL pipelines: The authors compare against outdated or artificially weak baselines, such as DAIL-SQL performing at only 34.31%–42.09%, MAC-SQL evaluated on a tiny subset of 59 queries (23.05%–35.93%), or a basic single-pass decoder, while omitting empirical comparisons against strong modern methods they cite in Section 6 (e.g., CHESS, CHASE-SQL, XiYan-SQL, OpenSearch-SQL, Reasoning-SQL). Why it is consequential: Benchmarking exclusively against weak or crippled baselines inflates the apparent gains and obscures the true competitive standing of the method.

  3. Uncontrolled test-time compute (78.4 LLM calls/query) without compute-matched baselines: At depth H=3, RSI-SQL consumes an average of 78.4 LLM calls, 74.1K tokens, and 136.8 seconds per query (Table 3), yet the authors explicitly admit that accuracy at equal compute is unmeasured (and omit accuracy numbers for their Majority Vote baseline in Table 3). Why it is consequential: Without comparing against compute-matched sampling baselines (e.g., Best-of-N or self-consistency with execution filtering at N ≈ 78), one cannot attribute the accuracy gains to the proposed Action Graph rather than sheer test-time compute scaling.

  4. Contradictory results across tables and negative transfer on earlier evaluations: On BIRD-Dev, RSI-SQL with Qwen2.5-Coder-14B achieves 64.41% in Table 1, but drops to 58.5% in Table 2 (a marginal +1.6% gain over single-pass decoding, and lower than a single-pass 14B-Instruct decoder at 62.1%). Furthermore, Appendix C.2 reveals that earlier RSI-SQL configurations underperformed a single-pass Coder-14B decoder by -5.9 points on Spider-Test (82.1% vs. 88.0%) and -2.6 points on BIRD (63.5% vs. 66.1%). Why it is consequential: These discrepancies demonstrate that the recursive loop is highly fragile across configurations and frequently degrades performance via error reinforcement and over-polling.

  5. Incomplete ablations of the core architectural claims: In Figure 3, the ablation jumps directly from a simplified Top-K Retrieval + Credit variant to the Full RSI-SQL system (+6.50% and +10.04%), changing multiple components at once without isolating the particle filter (P_t) or the Typed Action Graph (G_t). Why it is consequential: Because there is no controlled experiment removing only particle resampling or only graph dependencies from the full pipeline, the individual empirical contribution of the paper's main proposed mechanisms remains unverified.

Questions for authors

N/A

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.