ReToolSQL: Agentic Reinforcement Learning for Robust Text-to-SQL

2608.27796 ↗ · 2026-08-28 · cs.AI

Pratik Kakkar, Chandra Dhir, Ravi Shankar, Pareekshit Reddy Gaddam, Anup Shirgaonkar

The finding

Headline claim

A two-stage SFT-then-agentic-RL pipeline over multi-turn tool-use trajectories lets a single dense 31B model (Gemma 4 instruct) reach 74.32% execution accuracy single-pass (74.77% with execution-based self-consistency) on BIRD-SQL dev, ranking first on the single-model dev leaderboard at time of writing.

The test

Text-to-SQL execution accuracy (EX) on the BIRD-SQL development benchmark (12,751 question-SQL pairs, 95 noisy cross-domain databases). Ablations cover SFT-only vs RFT-only vs SFT-to-RFT, model scale, entropy scheduling, pass@k coverage on hard questions, and self-consistency sampling; results compared against leaderboard pipeline systems.

Effect size & scope

Agentic RFT alone: 73.66% EX single-pass, 74.12% with self-consistency. SFT-to-RFT: 74.32% single-pass, 74.77% with self-consistency. This beats pipeline systems like CHESS (71.1% test) and CHASE-SQL (73.0% test) and rivals XiYan-SQL (75.63% test), though it trails Agentar-Scale-SQL (81.67% test). Effect holds on BIRD dev, a single benchmark; the headline ranking is on the dev set, not test.

Limitations

The authors concede (implicitly) that results are on the development set, and the strong prior pipelines report test-set numbers, so the #1 claim is not apples-to-apples; the tool suite is read-only and constrained to SELECT/WITH; the model is one size (31B) of one family (Gemma 4); self-consistency multiplies inference cost; no human annotation beyond the benchmark is claimed, but BIRD hints/evidence may leak into training. Unstated: no production or enterprise-schema evaluation, no cost/latency comparison against simpler baselines, and dev-set leaderboard position can reflect overfitting to a public benchmark the field has extensively tuned against.

Counterpoint

BIRD-SQL is a saturated, well-contaminated benchmark that many groups iterate on, so a leaderboard-topped number may reflect benchmark gaming rather than general capability; the comparison set is heterogeneous (dev vs test, different model sizes and prompts); no open-source code or third-party replication is cited in the provided text; small margins over prior work (roughly 1.3 points over XiYan-SQL) with a self-consistency decoding trick doing part of the work; and the abstract framing 'enterprise-grade' is PR language not backed by any enterprise data in the paper.

Economy implication

Little or nothing yet for the macro AI-economics debate. The narrow signal: RL with verifiable rewards plus tool use continues to let mid-size open models match much larger or pipeline-heavy systems on a verifiable task, which supports cheap, self-hosted text-to-SQL for enterprises and slightly erodes the case that frontier-scale or multi-agent orchestration is needed for structured data work in the next 12 to 24 months.

Who this matters for

Technical Capability: Technical readers should care because it demonstrates that multi-turn tool-grounded RFT converts pass@k coverage into single-pass accuracy, a concrete recipe distinct from single-turn RLVR.

Labor & Knowledge Work: Text-to-SQL accuracy near pipeline-system levels from a single 31B model weakly signals that ad-hoc enterprise data-analysis labor can be automated with modest, self-hosted compute, though no labor outcomes are measured.

Bears on (advisory · papers never write evidence)

[1.3] Agentic reliability (multi-step completion without human correction) is improving materially, not just peak single-shot.

[3.4] App-layer companies retain margin after the model commoditizes their feature.

[B1] Agentic reliability gains will translate into enterprise ROI.

Abstract

Recent work has shown that reinforcement learning from execution feedback can substantially improve text-to-SQL performance, often enabling smaller models to match or exceed much larger systems. However, most existing approaches treat SQL generation as a single-turn task, limiting the model's ability to recover from errors through iterative refinement. We present ReToolSQL, a two-stage training framework for text-to-SQL that combines (i) a supervised warm-start on rejection-sampled reasoning traces with (ii) agentic reinforcement fine-tuning (RFT) over multi-turn tool-use trajectories. The key insight is that the two stages act on complementary axes, the supervised fine-tuning (SFT) on verified privileged-teacher traces expands the set of solvable questions (raising pass@k coverage on the hardest cases), while RFT converts that expanded capability into higher single-pass accuracy by teaching the model when to verify, what evidence to retrieve, and how to repair faulty SQL from execution feedback. Applied to Gemma 4 instruction-tuned (31B), RFT alone achieves 73.66% execution accuracy (EX) on the BIRD-SQL development benchmark (74.12% EX with self-consistency). Initializing RFT from the SFT checkpoint (SFT$\to$RFT) yields our strongest model at 74.32% EX single-pass and 74.77% EX with self-consistency. At the time of writing, this ranked first on the BIRD single-model development-set leaderboard. The approach uses composite rewards anchored on execution correctness, requires no human annotation beyond the benchmark itself, and operates within a single dense 31B model, showing that a properly designed SFT$\to$RFT pipeline over tool-use trajectories is a practical path toward robust enterprise-grade text-to-SQL.