betaFeedback

WorksComputer Science

TableRoute: Capability-Aware Routing for Scalable Table Question Answering

Abstract

Table question answering with large language models remains difficult to scale: tables range from compact to million-token sizes, while questions require precise grounding of columns, values, and computations. Existing methods often specialize in a fixed inference strategy, which is brittle across different table scales and model capabilities. Full-table reading is efficient for compact inputs but suffers from irrelevant context. Table reduction helps long inputs but depends on reliable evidence localization, while execution is required when tables exceed the model context window and remains sensitive to schema and value grounding errors. We propose TableRoute, a capability-aware routing framework with evidence-conditioned inference for scalable TableQA. TableRoute first generates validated question–table evidence and identifies the required operations, then routes each instance among these three strategies according to serialized table length and calibrated estimates of how reliably the base model handles these operations. The validated evidence supports the selected route by grounding columns, values, and conditions. Across WikiTQ, WTQ-L, BirdQA, and TableBench, TableRoute consistently improves accuracy through complementary routing and evidence conditioning across table scales, while reducing online token cost. Code will be made available upon publication.

Introduction

Table question answering (TableQA) requires answering natural language questions grounded in tables (Pasupat and Liang, [18]). Recent TableQA systems increasingly use LLMs as backbones, but the task remains challenging because tables encode information through both cell contents and schema, requiring schema–value alignment, evidence localization, cell normalization, and exact computation (Cao and Liu, [2]; Wang et al., 2025c).

Despite recent progress, TableQA remains difficult in practical settings where table size can range from compact inputs to million-token scale. Our analysis shows that semantic mismatch and computation errors persist across scales: models may map questions to wrong columns or values, and textual reasoning often fails on exact numerical operations. As tables grow longer, relevant evidence becomes harder to locate among irrelevant rows. When tables exceed the model context window, DIRECT reading becomes infeasible and program EXECUTE is required, but generated programs can still fail due to incorrect schema grounding, value matching, or operation parameters. These failures echo recent analyses of TableQA reasoning and long-table REDUCE (Zhang et al., 2024; [2]; [8]; Wang et al., 2025b). Together, these challenges motivate three complementary, question-dependent inference strategies for scalable TableQA: DIRECT answering, table REDUCE, and program EXECUTE. Motivated by model routing, which matches queries to model capabilities ([16]; Song et al., 2025), a scalable system should consider table size, the base model’s direct-reasoning capability, and the operations required by the question. The same input length may remain manageable for lookup-style reasoning but become unreliable for aggregation or arithmetic. Moreover, every strategy requires reliable grounding to table columns, values, and conditions. Figure 1 summarizes this motivation.

Figure 1. Motivation for scalable TableQA.

We propose TABLEROUTE, a capability-aware framework combining validated evidence with single-route selection. Given a question, table, and base model, TABLEROUTE grounds question spans to table columns, values, and conditions, and identifies required operations. It compares the table length against a calibrated reliable range for the base model and required operations. Inputs within this range use DIRECT, longer context-fit inputs use REDUCE, and over-window inputs use EXECUTE. The selected route reuses the validated evidence to ground direct reasoning, guide operation-based reduction, or constrain program generation.

Our Contributions.

(1) Capability-Aware Routing. We formulate scalable TableQA as per-question selection among DIRECT, REDUCE, and EXECUTE using reliable table-size ranges calibrated to base-model capability and operations. (2) Evidence-Conditioned Inference. We introduce a shared evidence layer that identifies required operations and provides structurally checked column, value, and condition grounding for route-specific inference. (3) Across-Scale Improvements. Experiments across table scales and backbones demonstrate accuracy gains from routing and evidence conditioning, with lower online token cost.

Related Work

Direct reasoning for TableQA. A common approach to LLM-based TableQA is to provide the serialized full table as context and answer directly from the question–table prompt. This paradigm can be enhanced through chain-of-thought prompting in TaCo (Wei et al., 2022; Zheng et al., 2023), row-wise traversal in RoT (Zhang et al., 2025). While effective when relevant evidence is accessible, direct reasoning becomes less reliable on long tables due to irrelevant context and lost-in-the-middle effects [13]. TABLEROUTE limits direct reasoning to reliable table-size ranges calibrated for each model and operation.

Table reduction for TableQA. Reduction-based methods construct question-relevant contexts before answering. Binder decomposes questions into executable SQL sub-programs [4]; Dater decomposes evidence and questions before answer filling (Ye et al., 2023); Chain-of-Table transforms tables during reasoning (Wang et al., 2024); TabSQLify uses Text-to-SQL to select sub-tables (Nahid and Rafiei, 2024); TabScope reduces tables through operation-aware decomposition (Wang et al., 2026c). Recent methods improve evidence selection through graph reranking, graph traversal, entity-oriented retrieval, or structured decomposition and verification [11, 15] (Wang et al. 2026b; Yang et al. 2025). While better suited to long tables, these methods may discard evidence needed for multi-step reasoning or introduce invalid operations through incorrect localization and decomposition. Our REDUCE instead generates and verifies a compact operation list grounded in validated columns, values, and conditions.

Program execution for TableQA. Program-based methods answer questions through executable operations. Text-to-SQL methods improve SQL generation through schema linking, decomposition, verification, or multi-agent orchestration, including TQ-SQL, DAIL-SQL, MAC-SQL, and DeepEye-SQL [6, 9] (Qu et al. 2024; Wang et al. 2025a). H-STAR further combines SQL execution with textual reasoning [1]. Python-based methods such as TablerRAG and TALON use generated programs or tool calls to explore and compute over large tables [3, 8]. Execution is necessary when the complete input exceeds the model context window, but remains sensitive to value mismatch, incorrect column grounding, and operation errors. TABLEROUTE conditions the execution route on validated columns, values, and conditions to constrain schema linking, value matching, and program generation.

Adaptive routing for TableQA. The above strategies are complementary: full-table answering suits compact inputs, reduction handles long context-fit tables, and execution is necessary for over-window tables. Recent systems combine them through LLM self-routing, post-hoc answer selection, adaptive textual–symbolic reasoning, or multi-agent collaboration [2] (Zhang et al. 2024; Yu et al. 2025; Wang et al. 2026a). Self-routing is inexpensive but may misjudge route suitability, while answer selection and multi-agent methods improve robustness by running multiple paths at higher cost, as analyzed in § 3. TABLEROUTE instead calibrates route reliable range and inferences using single route with validated evidence. Table 6 in Appendix § 9 compares their routing basis, evidence use, executed paths, and inference cost.

MethodDirect QATable ReductionProgram ExecutionPre-exec. RoutingSingle-route InferenceValidated EvidenceModel-specific Boundary
Binder✗✓✓✗✓✗✗
Dater✗✓✗✗✓✗✗
Chain-of-Table✗✓✗✗✓✗✗
SynTQA✓✗✓✗✗✗✗
TableRAG✗✓✓✗✗✗✗
TALON✗✓✓✗✗✗✗
TableMaster✓✓✓✓✗✗✗
TABLEROUTE✓✓✓✓✓✓✓

Table 6. Comparison between TABLEROUTE and representative multi-strategy or long-table TableQA systems. Direct QA denotes full-table answer generation. Table reduction denotes explicit construction of a smaller sub-table. Program execution denotes SQL-, Python-, or tool-based answer execution. Pre-execution routing means that the route is selected before answer generation. Single-route inference means that only one selected route is executed for each question. Validated evidence denotes typed and executable question–table grounding that is checked before being used by downstream routes. Model-specific boundary denotes a calibrated routing threshold that depends on the base model capability and required operations.

Empirical Analysis of Scalable TableQA

Before introducing Tableroute, we examine how TableQA behavior changes across table scales and inference strategies. We group examples into short tables with fewer than 4K table tokens, long tables that remain within the model context window, and massive tables whose inputs exceed the context window. We ask three questions: which errors dominate across scales, how table size and required operations affect full-table answering, and whether existing route-switching strategies effectively exploit route complementarity. Additional setup and results are provided in Appendix § 10.

RQ1: What errors dominate TableQA across table scales?

Setup. We manually analyze 200 randomly sampled incorrect cases for each table scale and assign the first responsible failure to one of five categories: semantic mismatch, computation error, evidence localization, reduction or execution error, and others. We include representative direct reasoning, table reduction, and program execution baselines. Detailed definitions and annotation procedures are provided in Appendix § 10.

Results. Table 1 shows that semantic mismatch is the largest error category, accounting for 42.3% of failures overall and remaining prominent at every scale. On long tables, computation and evidence localization errors account for 28.0% and 26.0% of failures, respectively. On massive tables, reduction or execution errors rise to 41.0%. Representative Text-to-SQL results in Appendix § 10.§ 2 further show that execution remains sensitive to schema and value grounding. These results indicate that switching inference strategies does not eliminate

Error TypeShortLongMassiveOverall
Semantic mismatch44.031.052.042.3
Computation error24.028.0–17.4
Evidence localization17.026.0–14.3
Reduction or execution error7.011.041.019.7
Others8.04.07.06.3
Semantic + computation68.059.052.059.7

Table 1. Error distributions (%) over 200 sampled failures per scale. For massive tables, evidence localization and computation failures are counted as reduction or execution errors because the answer generation step is programmatic.

semantic grounding errors, and each route must therefore preserve explicit mappings from question spans to table columns and cell values, combining with the corresponding grounding conditions.

RQ2: How do table sizes and operation types affect full-table answering?

Setup. We analyze full-table answering on WikiTQ using multiple diagnostic LLMs. For each model, we group examples by table tokens and report accuracy trends in Figure 2(a). To test whether this length effect depends on the operations required by questions, we further group examples by operation types and report accuracy across table-length bins in Figure 2(b).

Full-table QA accuracy versus table tokens and accuracy by operation types and table length

Figure 2. Full-table QA accuracy as table size increases. In (a), diagnostic models are re-binned into token ranges. In (b), questions are grouped by operator category (definitions in Appendix § 16), with results pooled across models.

Results. Figure 2(a) shows that full-table accuracy generally decreases as table size increases, but different base models begin to degrade at different table sizes and decline at different rates. Figure 2(b) further shows that this effect varies across required operations. Aggregation and arithmetic exhibit the steepest declines, while the remaining categories show smaller or less uniform changes across table-size ranges. Table size is therefore a strong indicator of full-table reliability, but a single length-only profile cannot describe every model and operation category. The reliable table-size range of full-table answering depends on both the base model and the operations required by the question.

RQ3: How reliably do existing strategies switch among TableQA routes?

Setup. The preceding analysis shows that no single inference route is suitable across all table scales and questions. We compare two existing switching strategies. LLM self-routing asks the model to select a route before answering, while answer selection executes multiple routes and chooses among their outputs [2] (Zhang et al. 2024). We use GPT-4o-mini as the common base model and report both accuracy and relative token cost. Oracle routing is included only as an analysis upper bound that selects the correct output whenever any candidate route succeeds.

Results. Table 2 confirms route complementarity. Oracle routing exceeds the strongest single route by 11.0 points on WTQ-L and 7.9 points on BirdQA. However, self-routing remains substantially below the oracle, indicating that model self-assessment does not reliably identify the best route. Answer selection narrows the accuracy gap but raises token cost to 4.15× on WTQ-L and 3.76× on BirdQA by executing multiple routes. These results show that route complementarity is substantial, but existing switching strategies either estimate route suitability unreliably or incur the cost of multi-route inference.

StrategyWTQ-LBirdQA
Acc.Relative Cost (×)Acc.Relative Cost (×)
CoT only58.11.00––
DATER only54.73.1561.82.76
DeepEye-SQL only––69.71.00
LLM Self-routing60.41.4866.81.34
Answer Selection62.04.1569.03.76
Oracle Routing69.1–77.6–

Table 2. Comparison of route-switching strategies. CoT, DATER, and DeepEye-SQL represent the DIRECT, REDUCE, and EXECUTE routes, respectively. Oracle Routing is an analysis-only upper bound. Cost is reported relative to the corresponding single-route baseline.

Method

We propose TABLEROUTE, a capability-aware framework for single-route TableQA. Given a question qq, table TT, and base model MM, it generates validated question–table evidence and identifies the required operations. It then selects one route based on the input table length and the estimated reliability of full-table answering, and reuses the validated evidence for route-specific inference. Figure 3 presents the overall framework.

Figure 3. Overview of TABLEROUTE. TABLEROUTE generates validated evidence and required operations, performs capability-aware routing, and reuses the evidence for DIRECT, REDUCE, or EXECUTE inference.

Question Grounding and Operations

Before routing, TABLEROUTE produces a validated evidence set E(q,T)={ei}i=1m(q,T)E(q,T)=\{e_i\}_{i=1}^{m(q,T)} and a required-operation set O(q,T)O(q,T) per question–table pair. Here, m(q,T)m(q,T) is the number of retained evidence items, allowing multiple grounding relations per question. The evidence supports the selected route, while the required operations inform routing.

Evidence Generation. TABLEROUTE first generates candidate question–table evidence and required operations in a structured format, then validates them against TT. Each retained evidence item is represented as

ei=(ui,ci,ϕi),(1)e_i = (u_i, c_i, \phi_i), \tag*{(1)}

where uiu_i is the question span triggering grounding, cic_i is the resolved table column, and ϕi\phi_i is the condition over cic_i, specifying how a grounded value is matched or compared. If no condition is required, ϕi=∅\phi_i = \varnothing. Validation checks column resolution, type compatibility, value parsing, and condition executability, removing invalid candidates without computing answers. Throughout this paper, validated evidence refers to evidence that passes these structural and executability checks. If no evidence is retained, the selected route proceeds with its standard input. Prompts and validation details are provided in Appendix § 11.

Operation Grouping. The required-operation set O(q,T)\mathcal{O}(q,T) covers seven fine-grained types. To avoid sparse per-type calibration subsets, we group them by their burden on direct full-table reasoning. The retrieval-oriented LIGHT group contains PROJECTION, FILTER, and NEIGHBOR, while the reasoning-intensive HEAVY group contains SORT, TOPK, AGGREGATE, and COMPUTE. We denote the assigned group by z(q,T)∈{LIGHT,HEAVY}z(q,T) \in\{\mathrm{LIGHT}, \mathrm{HEAVY}\}, where any question requiring a HEAVY operation is assigned to HEAVY. The grouping is used only for capability calibration, while the original operations remain available to the selected route when needed.

For example, in “How many Australian teams scored above 10?”, the evidence grounds Australian as Country = Australia and above 10 as Score >10> 10. O(q,T)={FILTER,AGGREGATE}\mathcal{O}(q,T) = \{\mathrm{FILTER}, \mathrm{AGGREGATE}\}. Since it requires aggregation, it is assigned z(q,T)=HEAVYz(q,T) = \mathrm{HEAVY}.

Capability-Aware Routing

Since full-table reliability depends on table size, base model, and required operations, we calibrate reliable size ranges for each model–operation group using held-out full-table predictions from the WikiTQ ([18]) training set and SLQA ((Wang et al., 2025b)). Calibration excludes evaluation question–table pairs and is performed offline, with the ranges fixed during evaluation.

Table Size. Consistent with § 3, we measure table size as the token length of the serialized table. For table TT and model MM, we define

sizeM(T)=Tok⁡M(S(T)),(2)\mathit{size}_M(T) = \operatorname{Tok}_M(S(T)), \tag*{(2)}

where S(T)S(T) is the serialized table and Tok⁡M\operatorname{Tok}_M is the tokenizer of model MM. This isolates the table-size variation while keeping the prompt template fixed.

Reference Accuracy. For each model, we use tables with sizeM(T)≤2,048\mathit{size}_M(T) \le2{,}048 tokens as a common small-table reference range, matching the first size range in our empirical analysis. Let A^Mshort\widehat{A}^{\mathrm{short}}_M denote the model’s full-table accuracy within this range. We allow an accuracy drop of ϵ=0.10\epsilon= 0.10 and define τM=A^Mshort−ϵ\tau_M = \widehat{A}^{\mathrm{short}}_M - \epsilon. This target specifies the minimum accuracy that larger table-size ranges must reliably maintain. The same reference range and tolerance are used across models, operation groups. The calibrated limits are reused during evaluation.

Range Calibration. For each model MM and operation group z∈{LIGHT,HEAVY}z \in\{\mathrm{LIGHT}, \mathrm{HEAVY}\}, we independently examine whether full-table performance remains above the reliability target τM\tau_M as table size increases. We collect the held-out question–table pairs assigned to group zz and measure each table by its serialized token size sizeM(T)\mathit{size}_M(T). These pairs are ordered by sizeM(T)\mathit{size}_M(T) and partitioned into consecutive 256-token table-size bins. Each bin therefore contains the question–table pairs whose tables fall within the same token-size interval. Adjacent bins are merged until each resulting calibration bin contains at least nmin⁡=50n_{\min} = 50 examples. For a fixed model–group pair (M,z)(M,z), let bb index a resulting calibration bin. Let nbn_b denote the number of examples in bin bb, and kbk_b the number answered correctly. For kb>0k_b > 0, we compute the one-sided Clopper–Pearson lower confidence bound as

LM,z,b=QBeta(α∣kb,nb−kb+1).(3)L_{M,z,b} = Q_{\mathrm{Beta}}\left(\alpha\mid k_b, n_b - k_b + 1\right). \tag*{(3)}

When kb=0k_b = 0, we set LM,z,b=0L_{M,z,b} = 0. Here, QBetaQ_{\mathrm{Beta}} denotes the Beta-distribution quantile function, whose shape parameters kbk_b and nb−kb+1n_b - k_b + 1 are determined by the observed outcomes rather than tuned. We use α=0.05\alpha= 0.05, giving a one-sided 95% lower confidence bound.

For each (M,z)(M,z) pair, starting from the smallest tables, we retain consecutive calibration bins satisfying LM,z,b≥τML_{M,z,b} \ge\tau_M. The reliable range ends before the first bin whose lower bound falls below τM\tau_M. The upper endpoint of the retained bins defines BMzB^z_M, the upper limit of the reliable table-size range for model MM and operation group zz. Thus, each base model obtains separate boundaries for the LIGHT and HEAVY groups.

Using the lower confidence bound rather than observed accuracy alone reduces the risk that a small or noisy bin produces an overly optimistic reliable range. All defaults are fixed globally. The calibrated reliable ranges and routing distributions are reported in Appendix § 12.

Route Selection. Let ℓM(q,T)\ell_M(q,T) denote the token length of the complete DIRECT prompt, including the instruction, question, evidence, serialized table, and output format. Let W(M)W(M) denote the usable context-window budget of model MM, and r∗(q,T,M)r^*(q,T,M) the selected route.

We set r∗(q,T,M)=EXECUTEr^*(q,T,M) = \mathrm{EXECUTE} when ℓM(q,T)>W(M)\ell_M(q,T) > W(M). For inputs that fit within the context window, the table size size⁡M(T)\operatorname{size}_M(T) and calibrated range limit BMz(q,T)B_M^{z(q,T)} determine the route:

r∗(q,T,M)={DIRECT,size⁡M(T)≤BMz(q,T),REDUCE,size⁡M(T)>BMz(q,T).(4)r^*(q,T,M) = \begin{cases} \mathrm{DIRECT}, & \operatorname{size}_M(T) \le B_M^{z(q,T)},\\ \mathrm{REDUCE}, & \operatorname{size}_M(T) > B_M^{z(q,T)}. \end{cases} \tag*{(4)}

Thus, the complete prompt length identifies over-window inputs, while the calibrated table-size range determines the DIRECT–REDUCE decision. Validated evidence supports the selected route but does not modify the range. After evidence generation, routing requires only operation grouping, token counting, and comparison with the stored range. It requires no additional routing LLM call and uses only one inference route.

Route Inference

After routing, TABLEROUTE provides the validated evidence and, when needed, the required operations to the selected inference route. Each instance is answered using only that route.

DIRECT answers from the full serialized table. Validated evidence is included in the prompt to highlight relevant columns, values, and conditions without removing other table content.

REDUCE uses validated evidence and required operations to generate a sequence of projection, filtering, neighbor retrieval, sorting, and top-kk operations, with aggregation or computation when needed. After validating their schema and arguments, it applies the sequence to construct a question-focused sub-table for answer generation.

EXECUTE uses validated evidence to guide schema linking, value matching, condition construction, and program generation. The program is applied to the table, and the final answer is obtained from the program output.

Post-Routing Support. Computational support is generated only after route selection. When grounded aggregation or arithmetic can be executed deterministically, results such as counts, sums, averages, differences, or ratios are added as optional context for final answer generation. This support is separate from the operations used by REDUCE to construct a reduced table and does not affect evidence generation, operation grouping, calibration, or routing. If unavailable or invalid, inference proceeds without it.

Route-specific prompts and fallback rules are provided in Appendix E.

Experiments

We evaluate TABLEROUTE through three questions. EQ1: Across-scale effectiveness. Does TABLEROUTE improve TableQA performance across short, long, and massive tables? EQ2: Failure mitigation. Does TABLEROUTE reduce the grounding, localization, computation, and program errors identified in § 3? EQ3: Generalization and efficiency. Does TABLEROUTE generalize across datasets and diverse base LLMs while maintaining efficient single-route inference?

Experimental Setup

Base Models. Our main experiments use three base LLMs from different model families: Qwen2.5-72B (Yang et al., 2024), LLaMA3.3-70B ([5]), and GPT-4o-mini ([7]). They cover open- and closed-source settings and different model scales. To broaden the backbone coverage, we also evaluate GPT-5-mini ([17]). Detailed model and decoding settings are provided in Appendix G.

The route implementations follow § 4.3, with EXECUTE instantiated using DeepEye-SQL ([9]).

Benchmarks. Our primary evaluation for TABLEROUTE uses three benchmarks covering different table scales and reasoning settings. WikiTableQuestions (WikiTQ) ([18]) contains mostly short tables with varying lengths. WTQ-L ([8]) derived from WikiTQ, contains longer tables with substantial row-count variation. BirdQ ([8]; [10]) derived from BIRD-SQL ([10]), is dominated by massive tables, with over-context instances requiring program execution. We further use TableBench (Wu et al., 2025) as a composite benchmark for supplementary generalization evaluation, covering fact checking, numerical reasoning, and data analysis. The dataset statistics are shown in Appendix F.

Baselines. We compare our TABLEROUTE with four groups of baselines. Direct answering in-

Only applicable baselines are shown.

cludes End-to-End QA with full-table prompting and RoT Zhang et al., 2025 with row-wise traversal. Reduction-based methods include Binder Cheng et al., [4] with SQL-based decomposition, Dater Ye et al., 2023 with evidence and question decomposition, and RowColRetrieval Jin et al., [8] with row–column retrieval. Execution-based methods include Python QA with code generation, TableRAG Chen et al., [3] with program-guided retrieval, DeepEye-SQL Li et al., [9] with staged Text-to-SQL generation and revision, and TALON Jin et al., [8] with multi-agent tool use. Hybrid methods include GraphOTTER Li et al., [11] with graph reasoning, Table-Critic Yu et al., 2025 with critic-based refinement, TUNES Nguyen et al., [15] with entity-oriented search, H-STAR Abhyankar et al., [1] with hybrid SQL–text reasoning. All matched baselines use the same models and metrics as TABLEROUTE.

Evaluation Metrics. For WikiTQ, WTQ-L, and BirdQA, we report exact-match (EM) accuracy using the official WikiTableQuestions evaluation protocol Pasupat and Liang, [18]. For the supplementary TableBench evaluation in Appendix § 14.§ 2, we report ROUGE-L Lin, [12], following prior work (Wu et al., 2025; Zhang et al., 2025).

Main Results (EQ1)

Table 3 reports results on WikiTQ, WTQ-L, and BirdQA. TABLEROUTE achieves the best accuracy across all benchmark–backbone combinations. Averaged over the three base LLMs, it outperforms the strongest baseline by 2.1 points on WikiTQ (RoT), 3.2 points on WTQ-L (TALON), and 5.3 points on BirdQA (DeepEye-SQL). Gains on WTQ-L reflect both routing and evidence conditioning, while BirdQA improvements primarily reflect evidence-conditioned inference advantage. Against the strongest matched baselines with at least two same backbones, paired McNemar tests show significant improvements on all three benchmarks (p<0.001p < 0.001).

WTQ (Mostly Short)
MethodQwenLLaMAGPTAvg.
End-to-End QA42.651.156.350.0
Python QA41.953.551.248.9
GraphOTTER55.355.150.353.6
Binder58.557.061.459.0
Dater60.263.859.861.3
RowColRetrieval53.4/55.254.3
TableRAG59.7/55.257.5
TALON69.664.671.068.4
Table-Critic77.270.173.973.7
H-STAR/75.874.975.4
TUNES/76.875.476.1
RoT77.378.774.276.7
TABLEROUTE (ours)79.179.777.578.8
Δ\Delta+1.8+1.0+2.1+2.1
WTQ-L (Mostly Long)
MethodQwenLLaMAGPTAvg.
End-to-End QA34.040.255.543.2
Python QA36.3/53.845.1
Binder60.3/61.060.7
Dater51.2/54.753.0
RowColRetrieval49.9/47.248.6
TableRAG59.6/52.155.9
RoT35.041.7/38.4
TALON66.659.567.064.4
TABLEROUTE (ours)68.267.067.667.6
Δ\Delta+1.6+7.5+0.6+3.2
BirdQA (Mostly Massive)
MethodQwenLLaMAGPTAvg.
Binder59.2/60.860.0
RowColRetrieval42.7/48.445.6
TableRAG53.5/54.754.1
DeepEye-SQL69.172.369.770.4
TALON70.066.972.069.6
TABLEROUTE (ours)73.678.774.875.7
Δ\Delta+3.6+6.4+2.8+5.3

Table 3. Main results on WikiTQ, WTQ-L, and BirdQA. We report exact-match accuracy (%) under Qwen2.5-72B, LLaMA3.3-70B, and GPT-4o-mini. Bold indicates the best and underlining indicates the second-best result in each column. Δ\Delta denotes the performance gain of TABLEROUTE over the best baseline. We report results under the matched setting whenever implementation is available; unavailable or inapplicable entries are marked by “/”.

Table 22 in Appendix § 14.§ 1 shows that TABLEROUTE achieves the highest accuracy across all four model and row-count settings on WTQ-L, outperforming the strongest baseline by 0.5 to 2.5 points.

MethodGPT-4o-miniGPT-4o-miniQwen2.5-72BQwen2.5-72B
< 200≥ 200< 200≥ 200
End-to-End QA56.454.236.125.0
Python QA52.155.634.635.4
Binder58.560.658.558.5
Dater53.752.852.445.3
RowColRetrieval47.650.048.750.0
TableRAG51.450.058.358.3
TALON66.866.766.265.0
TABLEROUTE67.767.268.765.5

Table 22. Accuracy (%) on WTQ-L for tables below and above 200 rows.

Failure Mitigation Analysis (EQ2)

Computational questions. RQ1 identifies computation errors as a frequent failure mode on short and long tables. Table 4 compares TABLEROUTE with CoT Wei et al., 2022 across computational question types. TABLEROUTE improves on all listed types, with larger gains on ratio (+9.1), average (+8.7), and difference (+3.9). The smaller gain on counting (+1.1) suggests that precise evidence localization and filtering remain challenging. Overall, TABLEROUTE better handles questions requiring derived computation.

Computation Type#QCoTTABLEROUTEΔ\Delta
Count170473.774.8+1.1
Diff.10365.068.9+3.9
Sum10578.180.0+1.9
Avg.2356.565.2+8.7
Extrema8572.976.5+3.6
Ratio1163.672.7+9.1

Table 4. Averaged accuracy by computational question types over base LLMs on WikiTQ. Δ\Delta denotes absolute gain over CoT. # Q means number of questions.

Semantic mismatch. We manually analyze semantic mismatch, the largest error category in

RQ1. We randomly sample 200 WikiTQ errors and categorize all errors on WTQ-L and BirdQA. Semantic mismatch accounts for 31.5%, 20.2%, and 34.5% of the analyzed errors, respectively, compared with 44.0%, 31.0%, and 52.0% in Table 1. Combined with higher accuracy, these lower proportions suggest that TABLEROUTE reduces semantic-mismatch errors across table scales.

Generalization and Efficiency (EQ3).

Generalization. Using GPT-5-mini, TABLEROUTE outperforms the strongest baseline by 0.8, 1.7, and 3.5 points on WikiTQ, WTQ-L, and BirdQA, respectively, demonstrating generalization to an additional base LLM. On TableBench, with RoT used as the DIRECT backbone, TABLEROUTE improves ROUGE-L from 44.8 to 48.7 under LLaMA3.3-70B. These results suggest that the combined evidence-and-routing framework generalizes across backbones, table scales, and table-reasoning tasks. GPT-5-mini and TableBench results are provided in Appendices § 14.§ 3 and § 14.§ 2.

Token Efficiency. Figure 4 reports average online LLM token consumption per question. For TABLEROUTE, the total includes evidence generation, route-specific planning or program generation, and answer generation. Evidence is generated once per question–table pair, while routing is deterministic and uses no additional LLM call.

Figure 4. Average total online LLM token consumption per question on a logarithmic scale. Full-table End-to-End QA is not reported for BirdQA because most inputs exceed the model context window.

Offline calibration is excluded from these totals. The six model–operation limits require 1,952 held-out pairs, 10.17M input tokens, and 79 minutes. Additional latency and evidence-extraction cost analyses are provided in Appendix § 14.§ 4.

Including all online stages, TABLEROUTE consumes 1.4K, 7.3K, and 24.6K LLM tokens per question on WikiTQ, WTQ-L, and BirdQA, respectively, compared with 19.4K, 64.1K, and 160.4K

for TALON. On WikiTQ, its cost is also close to End-to-End QA (1.2K). Thus, TABLEROUTE substantially reduces online inference cost relative to TALON across all three datasets.

Ablation Study. Table 5 shows that validated evidence is especially important on WTQ-L and BirdQA, where its removal reduces accuracy by 3.8 and 4.9 points. Computational support contributes 2.0 and 2.1 points on WikiTQ and WTQ-L, respectively. Fixed-route ablations demonstrate route complementarity; controlled router comparisons in Appendix § 12.§ 6 isolate the benefit of capability-aware selection. On WTQ-L, per-model calibration raises accuracy from 66.1 to 66.9, while LIGHT/HEAVY ranges improve it to 67.6. Analyses of semantic routing, per-operation calibration, and calibration transfer are provided in Appendix § 12.7.

SettingWikiTQWTQ-LBirdQA
TABLEROUTE78.867.675.7
w/o Validated Evidence76.3 (↓2.5)63.8 (↓3.8)70.8 (↓4.9)
w/o Computational Support76.8 (↓2.0)65.5 (↓2.1)–
DIRECT-only75.2 (↓3.6)41.0 (↓26.6)–
REDUCE-only73.8 (↓5.0)61.3 (↓6.3)–
EXECUTE-only64.6 (↓14.2)59.5 (↓8.1)70.4 (↓5.3)
ModelGlobalPer-ModelPer-Model+Group
GPT66.4 (↓1.2)67.0 (↓0.6)67.6
LLaMA65.5 (↓1.5)66.4 (↓0.6)67.0
Qwen66.4 (↓1.8)67.3 (↓0.9)68.2
Avg.66.1 (↓1.5)66.9 (↓0.7)67.6

Table 5. Component, fixed-route, and routing-calibration ablations in EM accuracy (%). Parentheses denote drops from TABLEROUTE in (a) and Per-Model+Group in (b). Route-only rows assign applicable instances to the route. Global uses one range across models and groups, Per-Model one per base LLM, and Per-Model+Group separate LIGHT and HEAVY ranges per base LLM. “–” denotes an inapplicable setting.

Conclusion

We propose TABLEROUTE, a scalable TableQA framework combining capability-aware routing with evidence-conditioned inference. Given a question, table, and base LLM, it generates validated evidence and required operations, then selects direct answering, table reduction, or program execution using table size and reliability ranges calibrated for each model and operation group. Experiments across datasets, table scales, and base LLMs demonstrate complementary benefits from routing and evidence conditioning, improving accuracy while reducing online token consumption.

Limitations

TABLEROUTE requires a one-time calibration to establish reliable ranges for each base LLM. Its LIGHT/HEAVY grouping compresses fine-grained operations into two routing categories and therefore omits distinctions among some operation patterns. We assume textual or programmatic table access, leaving visually structured tables, noisy spreadsheets, and multi-table documents with implicit layout relations for future work.

Ethics Statement

All datasets and models used in this paper are publicly available, and their usage strictly adheres to the corresponding licenses and terms of use.

Comparison with (Multi-)Strategy TableQA Systems

Table 6 summarizes the differences between TABLEROUTE and representative multi-strategy or long-table TableQA systems. The goal of this comparison is not to claim that one framework strictly subsumes another, but to clarify the design choices that distinguish TABLEROUTE. In particular, TABLEROUTE performs pre-execution single-route selection, uses a calibrated model-specific routing boundary, and reuses the same validated evidence across direct answering, table reduction, and program execution.

Details for Empirical Analysis

This appendix provides details for the diagnostic analysis in § 3. The goal of this analysis is to motivate the design of TABLEROUTE, rather than to serve as the final benchmark evaluation. Final benchmark results are reported in § 5.

Failure Categorization Details

For RQ1, we analyze 200 randomly sampled incorrect cases for each table-scale regime. Across all regimes, we include TALON (Jin et al. [8]) as a representative long-table exploration baseline. We additionally include CoT-style full-table answering (Wei et al. (2022)) for short tables, RoT (Zhang et al. (2025)) for long tables, and DeepEye-SQL (Li et al. [9]) for massive tables. For each incorrect case, we identify the first responsible failure and categorize it into one of the following groups.

Semantic mismatch. This category includes failures where the model or generated program maps the question to the wrong table semantics. Typical cases include selecting the wrong column, matching the wrong cell value, confusing semantically similar headers, misinterpreting a constraint, or using an incorrect operation implied by the question.

Computation error. This category includes failures where the relevant evidence is correctly identified but the numerical computation is wrong through LLM reasoning. Examples include incorrect counting, aggregation, comparison, difference, ratio, percentage, or arithmetic over table values.

Evidence localization error. This category includes failures where the model fails to locate the required evidence in the table. Examples include overlooking relevant rows, columns, or cells, attending to an irrelevant table region, or failing to retrieve the row needed for a comparison or lookup.

Reduction or execution error. This category includes failures introduced after a reduction or execution-style route is chosen. Examples include incomplete reduced tables, invalid SQL or Python programs, incorrect filters, wrong aggregation functions, missing ordering constraints, or erroneous program parameters.

Others. This category includes failures that do not fit the above groups, such as formatting failures, or cases where multiple errors are inseparable.

Massive-table cases. For massive tables, answers are obtained mainly through executable operations rather than direct inspection of the full serialized table. Therefore, localization or computation failures caused by generated executable operations are counted as reduction or execution errors. This convention explains why computation and evidence-localization entries are marked as “–” for massive tables in Table 1.

Table-scale regimes and token bins. In § 3, table size is measured by the number of tokens in the serialized table. We use three benchmark-scale regimes: short tables, which can be serialized and directly read with limited irrelevant context; long tables, which still fit within the model context window but make full-table reading less reliable due to additional rows or columns; and massive tables, whose serialized form exceeds the model context window and therefore requires execution-based access. This benchmark-scale taxonomy is distinct from the calibration token bins used in Figure 2(b) and Appendix § 12.§ 2. For the calibration analysis, we group context-fit examples into Short (≤2048\le2048 tokens), Mid (2560–6144 tokens), and Long (≥7168\ge7168 tokens) bins to estimate how full-table answering degrades with table length and question type.

Execution Baselines for Massive Tables

For massive tables, full-table prompting is infeasible and answers are obtained mainly through executable operations. Table 7 reports representative Text-to-SQL results on BirdQA. Although execution avoids placing the full table in the prompt, performance remains sensitive to schema grounding, value matching, and operation construction.

MethodAcc.
Bird ([10])55.8
DAIL-SQL ([6])54.8
TA-SQL ((Qu et al., 2024))56.1
MAC-SQL ((Wang et al., 2025a))59.6
DeepEye-SQL ([9])69.7

Table 7. Representative Text-to-SQL results on BirdQA for massive-table settings using GPT-4o-mini.

This supports the RQ1 observation that massive-table failures are dominated by semantic mismatch and reduction or execution errors.

Evidence Generation Details

This appendix describes the implementation of the evidence generation module in § 4.1. The goal is to obtain lightweight, verifiable question–table alignments without serializing the full table into the LLM prompt.

Compact Table Profile

For each question-table pair, we construct a compact table profile P(T)P(T), which is a bounded-size summary of the table used only for evidence extraction. It contains four components: (1) all column names; (2) an inferred type for each column, chosen from text, number, and date; (3) up to five head non-null values per column; and (4) up to five representative rows.

The value and row budgets are set to five to keep the profile short while still exposing common surface forms to the evidence extractor. We use head non-null values because they are deterministic and inexpensive to obtain. Representative rows are selected by lexical overlap with the question. Specifically, each row is converted into a string by concatenating its cell values, and the row is scored by the number of shared normalized tokens with the question. Here, normalized tokens are lowercased whitespace tokens after removing simple punctuation. The top-scoring rows are selected; if all rows have zero overlap, we use the first five rows as a deterministic fallback.

For large tables, the LLM only observes P(T)P(T) rather than the full serialized table. The later validation step is applied to the table view available to the pipeline. A table view refers to the in-memory table or retrieved table slice that the current route can access; for short and long tables this is typically the full table, while for massive tables it may be a database-backed or retrieved view.

Column Type Inference

Column types are inferred with a lightweight parser. For each column, we consider its non-empty cells. A column is assigned type number if at least 80% of its non-empty cells can be parsed as numbers, and type date if at least 80% can be parsed as dates. If neither condition holds, the column is treated as text. The 80% threshold is used to avoid classifying mixed or noisy columns as numeric or date columns due to a few parseable values.

For number parsing, comma separators are removed before numeric conversion. For date parsing, invalid values are coerced to missing values. The current implementation does not perform full semantic normalization for currencies, percentages, units, or domain-specific date ranges; these cases may be filtered out during validation or handled by downstream route-specific reasoning.

Structured Evidence Schema and Prompt

The evidence extractor uses a zero-shot instruction prompt with temperature set to 0 for deterministic structured output. The model receives the question and compact table profile, and returns a list of evidence candidates. Each candidate contains the fields in Table 8.

FieldDescription
semantic_unitQuestion phrase to be grounded.
column_hintNatural-language hint for the target column.
grounding_typeExpected value type: text, number, or date.
operatorCondition operator.
valueMain literal value.
value2Second value for between; empty otherwise.

Table 8. Evidence candidate schema.

The supported operators are equality, inequality, comparison, containment, and range matching: ==, !=, >, >=, <, <=, contains, and between.

A compact version of the prompt template is shown below. Line breaks are added for readability.

Given a question and a compact table profile,
extract evidence items that link question spans
to table columns and values.

Return only a JSON list. Each item contains:
semantic_unit, column_hint, grounding_type,
operator, value, and value2.
grounding_type: text, number, or date.
operator: ==, !=, >, >=, <, <=, contains,
between.
Question: {question}
Table profile: {table_profile}

If JSON parsing fails, we retry once with a shorter prompt that preserves the schema but removes explanatory instructions. A single retry is used to recover from formatting errors without introducing substantial extra cost. If parsing still fails, the evidence list is set to empty and downstream inference proceeds without evidence. The current implementation focuses on typed row-selection evidence; aggregation and arithmetic are handled by route-specific reasoning modules rather than represented as executable evidence items.

Column Resolution

Column resolution maps a generated column_hint to an actual table column. For each candidate, we first remove columns whose inferred type is incompatible with the candidate’s grounding_type. We then score each remaining column by lexical similarity between the normalized hint hh and normalized column header cc:

s(h,c)=SeqMatch⁡(h,c)+λsub⋅Substr⁡(h,c).(5)s(h,c) = \operatorname{SeqMatch}(h,c) + \lambda_{\mathrm{sub}} \cdot\operatorname{Substr}(h,c). \tag*{(5)}

Here, SeqMatch⁡(h,c)\operatorname{SeqMatch}(h,c) is the SequenceMatcher ratio, and Substr⁡(h,c)\operatorname{Substr}(h,c) is 1 if either string is a substring of the other and 0 otherwise. We set λsub=0.3\lambda_{\mathrm{sub}} = 0.3 to reward exact containment, which often occurs when a generated hint is a shortened or expanded version of a table header.

The best-scoring column is selected if its score is at least 0.35; otherwise, the evidence is marked unresolved and dropped. The threshold is selected on the calibration split and then fixed for all evaluations. A relatively low threshold is used because the evidence is later checked by typed execution, so column resolution is allowed to be recall-oriented while validation controls precision.

Typed Validation

Typed validation checks whether a resolved evidence item can be executed against the resolved column. This step is used to filter hallucinated or unsupported evidence before it is passed to downstream routes.

For text columns, we support ==, !=, and contains with case-insensitive comparison. For number and date columns, we support ==, !=, >, >=, <, <=, and between. An evidence item is dropped if the column cannot be resolved, the inferred type is incompatible with the evidence type, the evidence value cannot be parsed, the operator is unsupported for the resolved type, or the condition cannot be executed. We refer to the last two cases as not executable.

An executable condition is not dropped solely because it matches zero rows. Instead, it is retained with an empty-match flag. An empty-match item is used only as a soft constraint, meaning that it can inform prompting, decomposition, or program repair, but it is not applied as a mandatory filter that would remove all rows. This design avoids over-filtering when the evidence is semantically plausible but fails due to surface-form mismatch or limited normalization.

Route Integration and Cost Accounting

The same retained evidence list is shared across all routes. In DIRECT, evidence is inserted as auxiliary grounding context. In REDUCE, executable conditions are converted into filtering or decomposition constraints; a between condition is decomposed into lower- and upper-bound constraints. In EXECUTE, evidence constrains column selection, value grounding, and program repair. If no evidence is retained, the selected route proceeds without evidence. Evidence generation is performed once per question-table pair. All input and output tokens used for evidence generation are included in the reported token cost.

Evidence Statistics

Table 9 reports summary statistics for evidence generation. Avg cand. is the average number of evidence candidates generated per question. Kept and Dropped are rates over generated candidates. Empty-match is computed among retained evidence items.

DatasetAvg cand.KeptDroppedEmpty
WikiTQ1.8720.7360.26430.1%
WTQ-L1.7730.8110.18915.5%

Table 9. Summary statistics for evidence generation.

Table 10 reports validation failure counts. Unres. col. counts candidates whose column hint cannot be mapped to a table column. Type mis. counts candidates removed because the evidence type is incompatible with the resolved column type. Parse fail counts candidates whose value cannot be parsed under the predicted type. Not exec. counts candidates with unsupported operators or execution failures. For WTQ-L, all values are averaged over the three base models.

Table 10 reports validation failure counts and their rates among generated evidence candidates. Unresolved column means that the column hint cannot be mapped to a table column. Type mismatch means that the evidence type is incompatible with the resolved column type. Parse failure means that the value cannot be parsed under the predicted type.

Failure typeWikiTQWTQ-L
Unresolved column1180 / 813256 / 596
Type mismatch105 / 813214 / 596
Parse failure600 / 813234 / 596
Not executable971 / 813257 / 596

Table 10. Validation failure breakdown among generated evidence candidates.

Evidence Generation

Prompt. Figure 5 shows the prompt used to generate evidence candidates and required operations.

Prompt for evidence and required-operation generation

Figure 5. Prompt for evidence and required-operation generation.

Evidence Example. Figure 6 illustrates the complete evidence generation process. The evidence extractor observes only the question and compact table profile, then produces evidence candidates and required operations. The candidates are subsequently resolved and validated against the table.

Input and generated output and validation and retained evidence panels

Figure 6. An example of evidence and required-operation generation. The extractor produces structured candidates from the compact table profile. Validation resolves column hints and checks type compatibility and executability before retaining the evidence.

Routing Calibration Details

This appendix provides implementation details for the capability-aware routing mechanism in § 4.2. We describe the calibration data, the effects of table size and required operations, the construction of operation groups, the reliable-range calibration procedure, and the routing ablations.

Calibration Data and Table Size

We calibrate the routing ranges using held-out examples from the WikiTQ (Pasupat and Liang, [18]) training set and SLQA (Wang et al., 2025b). WikiTQ mainly provides short and medium tables, while SLQA supplies additional large-table examples. SLQA is used only for calibration and is excluded from all reported test sets.

Following § 4.2, we measure table size by the serialized-table token count size⁡M(T)\operatorname{size}_{M}(T) under model MM. We use size⁡M(T)≤S0\operatorname{size}_{M}(T) \le S_{0} as the small-table reference range and define τM=A^Mshort−ϵ\tau_{M} = \hat{A}_{M}^{\mathrm{short}} - \epsilon. We set S0=2,048S_{0} = 2{,}048 tokens, matching the first size range in our empirical analysis, and ϵ=0.10\epsilon= 0.10. These settings are shared across models, operation groups, and evaluation datasets.

Empirical Motivation: Length and Operation Effects

For descriptive analysis, we divide context-fit examples into short (≤2,048\le2{,}048 table tokens), medium (2,0492{,}049–6,1446{,}144), and long (>6,144> 6{,}144) regions. These regions are used only to summarize performance trends and are distinct from the finer calibration bins introduced below.

Across the three base models, direct-route accuracy decreases from 76.33% in the short region to 63.90% in the long region. Table 11 reports the trend by model.

ModelShortMediumLong
Qwen0.7500.6560.617
GPT0.7960.7220.642
LLaMA0.7400.6440.658
Avg.0.7630.6740.639

Table 11. Direct-route accuracy across table-size regions. GPT, LLaMA, and Qwen denote GPT-4o-mini, LLaMA3.3-70B, and Qwen2.5-72B, respectively.

Required operations also exhibit different full-table performance. For this descriptive analysis, each example is assigned its most demanding identified operation type. Table 12 reports the pooled accuracy and number of examples for each type.

OperationAcc.nn
Projection0.7361,214
Sort0.729380
Top-k0.726357
Neighbor0.720214
Filter0.686948
Compute0.686102
Aggregate0.614817

caption: Average direct-route accuracy by required operation type.

:::

Table Table 13 further reports the interaction between operation type and table size. Aggregation and computation show the largest declines, while retrieval-oriented operations exhibit smaller reductions.

OperationShortLongΔ\Delta
Projection0.7850.687-0.098
Filter0.7790.610-0.169
Neighbor0.7630.691-0.072
Sort0.7810.648-0.133
Top-k0.7930.612-0.181
Aggregate0.7470.449-0.298
Compute0.8890.526-0.363

caption: Operation-by-table-size effect. Δ\Delta denotes long minus short accuracy.

:::

Operation Groups

The operation groups follow the definition in § 4.1 and are summarized in Table 14.

GroupOperation types
LIGHTPROJECTION, FILTER, NEIGHBOR
HEAVYSORT, TOPK, AGGREGATE, COMPUTE

caption: Operation groups used for reliable-range.

:::

For each base model, held-out question–table pairs are divided into LIGHT and HEAVY subsets before calibration. The subsets are calibrated independently, yielding BMLIGHTB_M^{\mathrm{LIGHT}} and BMHEAVYB_M^{\mathrm{HEAVY}}. The original operation types remain available when explicitly required by the selected inference route.

Reliable Range Calibration

Following § 4.2, we calibrate reliable table-size ranges independently for each base model and operation group. Within each (M,z)(M,z) pair, held-out question–table pairs are ordered by their serialized table size sizeM(T)size_M(T) and initially divided into 256-token bins. Adjacent bins are merged until each contains at least nmin⁡=50n_{\min}=50 examples. We then apply the lower-confidence-bound criterion in Equation (3) to obtain the upper endpoint BMzB_M^z of each reliable range.

All calibration settings are shared across models and operation groups, as summarized in Table 15.

SettingSymbolDefault
Reference table sizeS0S_02,048
Accuracy toleranceϵ\epsilon0.10
Initial bin width—256
Minimum bin sizenmin⁡n_{\min}50
One-sided tailα\alpha0.05

caption: Default settings for reliable-range calibration.

:::

Table 16 reports the six resulting reliable ranges. Because table size is measured using each model’s tokenizer, the range limits are interpreted separately for each model.

ModelA^Mshort\hat{A}^{\mathrm{short}}_MτM\tau_MLIGHT rangeHEAVY range
GPT0.7960.696sizeM(T)≤4,608size_M(T) \leq4{,}608sizeM(T)≤3,072size_M(T) \leq3{,}072
LLaMA0.7400.640sizeM(T)≤4,352size_M(T) \leq4{,}352sizeM(T)≤3,328size_M(T) \leq3{,}328
Qwen0.7520.652sizeM(T)≤4,096size_M(T) \leq4{,}096sizeM(T)≤2,816size_M(T) \leq2{,}816

caption: Calibrated reliable table-size ranges for each base model and operation group. Range limits are measured in serialized table tokens.

:::

The shorter HEAVY ranges reflect the greater sensitivity of comparison- and computation-intensive questions to increasing table size. Calibration is performed once offline. At inference time, the router only identifies the operation group, counts table tokens, and compares the resulting size with the stored range limit. No additional LLM call is required for route scoring.

Route Distribution

Table 17 compares model-only calibration with the full model- and operation-group-specific calibration on WTQ-L. The latter routes more context-fit examples to REDUCE, while the over-window EXECUTE proportion remains unchanged.

ModelCalibrationDir.Red.Exec.
GPTModel-only48.8142.568.63
GPTModel+Group44.3547.028.63
LLaMAModel-only41.9749.408.63
LLaMAModel+Group40.4850.898.63
QwenModel-only46.7344.648.63
QwenModel+Group38.9952.388.63

Table 17. Route distribution on WTQ-L (%). Model-only uses one reliable range per model, while Model+Group uses separate LIGHT and HEAVY ranges.

Controlled Router Comparisons

To isolate the contribution of capability-aware routing, we compare TABLEROUTE against three alternative routing strategies: length-only, LLM-based, and learned routing. All methods use GPT-5-mini with identical evidence conditioning and inference backbones, differing only in route selection.

As shown in Table 18, TABLEROUTE consistently outperforms the alternative routers, improving over length-only routing by 0.8 and 1.1 points on WikiTQ and WTQ-L, respectively. The improvement further increases to 2.7 points on long-table questions requiring HEAVY operations.

Routing StrategyWikiTQWTQ-L
Length-only81.768.5
LLM-based82.068.8
Learned82.269.0
TABLEROUTE82.569.6

Table 18. Controlled router comparison using GPT-5-mini. All strategies share the same evidence conditioning and inference backbones. Results are reported in EM accuracy (%).

To separate routing from evidence conditioning, we additionally compare routing strategies without the shared evidence layer. TABLEROUTE still outperforms length-only routing by 0.7 and 0.9 points on WikiTQ and WTQ-L, respectively. These results demonstrate that capability-aware selection provides an independent, albeit modest, contribution beyond evidence conditioning.

Calibration Transfer and Alternative Routing Strategies

We further evaluate the transferability of calibrated routing boundaries and compare alternative routing strategies. Table 19 summarizes the results.

SettingWikiTQWTQ-L
Original three backbones (average)
Model-specific calibration78.867.6
Cross-model calibration78.667.3
LLM semantic routing79.068.6
GPT-5-mini
Per-operation calibration82.469.4
LIGHT/HEAVY calibration82.569.6
Oracle routing84.976.2

Table 19. Calibration transfer and alternative routing strategies on WikiTQ and WTQ-L. Results are reported in EM accuracy (%). Oracle routing is an analysis-only upper bound.

Calibration Transfer. We examine cross-model transfer by calibrating each of the three original backbones using data from the other two. This setting achieves 78.6% and 67.3% accuracy on WikiTQ and WTQ-L, respectively, compared with 78.8% and 67.6% under model-specific calibration. The small differences suggest that calibrated boundaries transfer reasonably well across the evaluated model families.

Semantic Routing. We compare our lightweight calibrated router with an LLM-based semantic scorer. The semantic scorer achieves 79.0% and

68.6% on WikiTQ and WTQ-L, improving over our router by 0.2 and 1.0 points, respectively. However, it requires an additional LLM call for route selection. Our approach therefore offers a favorable accuracy–cost trade-off.

Per-Operation Calibration. We further compare the LIGHT/HEAVY grouping with finer-grained calibration over seven operation types using GPT-5-mini. Per-operation calibration achieves 82.4% and 69.4% on WikiTQ and WTQ-L, slightly below the two-group approach (82.5% and 69.6%). This suggests that finer-grained calibration provides no additional benefit under the evaluated setting, potentially due to sparser calibration subsets. An oracle selecting a correct output whenever any candidate route succeeds achieves 84.9% and 76.2%, indicating remaining room for improved route selection.

Route-Specific Interface Details

We report implementation details for the route-specific interfaces described earlier. After routing, TABLEROUTE adapts retained evidence to the selected route through a fixed interface. DIRECT uses a QA prompt, REDUCE uses an operation-list interface, and EXECUTE uses an execution-oriented interface. The deterministic operators used by REDUCE are defined in Appendix § 16.

Direct QA Interface

The DIRECT route uses a QA prompt over the serialized table. The prompt contains the question, the table, and formatted retained evidence. The evidence provides grounding context, such as resolved columns and grounded values, but it is not executed as a hard filter in this route.

For computation-related questions, TABLERROUTE may additionally provide numerical hints computed by the deterministic AGGREGATE and COMPUTE operators defined in Appendix § 16. These hints are appended to the QA prompt as auxiliary support rather than treated as mandatory answers. If no evidence or numerical hint is available, the route falls back to the standard QA prompt.

Reduce Operation-List Interface

The REDUCE route uses an operation-list interface. A base-model planner generates a list of operations from the question, table schema, table content, and retained evidence. Each operation contains three fields: operator_name, arguments, and explanation. The operator_name is selected from the predefined operator set: PROJECTION, FILTER, SORT, TOPK, NEIGHBOR, AGGREGATE, and COMPUTE. These operators cover column selection, row filtering, ordering, top-kk selection, relative-row lookup, aggregation, and arithmetic transformation. Their deterministic semantics are given in Appendix § 16.

After generation, the operation list is parsed and checked by rule-based guards. The guards verify that referenced columns exist, operator arguments are well-formed, and the resulting plan can be executed by the table operator engine. The executor applies valid operators to produce a reduced table. For computation-related questions, it also produces a reduction context that stores outputs from AGGREGATE and COMPUTE, such as counts, sums, differences, or ratios. This context is appended to the final QA prompt as numerical support.

Schema-Only Reduction Analysis

We analyze whether REDUCE can rely only on the table schema when the full table is not prompt-visible. This is a reduction-only ablation: all examples are forced to use REDUCE, and no routing decision is applied. Table 20 reports accuracy on WikiTQ using LLaMA3.3-70B. Schema-only reduction improves when evidence is added, but it remains below full-table-visible reduction. This supports our routing choice: when a table exceeds the model input budget, REDUCE lacks the row- and value-level grounding needed to construct reliable operation lists.

SettingAcc.
Schema-only reduction66.5
Schema-only reduction + evidence68.0
Best schema-only reduction70.1
Full-table-visible reduction70.9

Table 20. Reduction-only ablation on WikiTQ. “Full-table-visible” means the planner can inspect the serialized table when generating the operation list.

Evidence Use in Reduce

Only retained evidence items are used by the REDUCE planner. The fields directly used as grounding constraints are resolved_column, operator, value, and value2. These fields provide column-value constraints that guide projection and filtering operations. Other evidence fields, such as semantic_unit, grounding_type, and matched_preview, are used only as prompt context or diagnostics.

Validated evidence can be converted into constraints in the operation list. However, empty-match or uncertain evidence is treated as a soft hint rather than a mandatory filter. It may guide the planner towards relevant columns or values, but it is not forced into the operation list as a hard condition. If no evidence is retained, the evidence string is set to None, and the planner still attempts to generate an operation list from the question and table schema.

Execute Interface

The EXECUTE route uses an execution-oriented interface. The prompt is conditioned on the question, table access, and evidence-derived constraints. It guides the model to generate an executable plan whose result is verified through execution. Validated evidence is used to ground column and value choices whenever available. If no evidence is retained, execution proceeds from the question and table schema or table access alone.

Route-Specific Prompt Templates

Figure 7 shows the prompt templates used by the three inference routes. Validated evidence is provided as grounding context or constraints rather than treated as a mandatory answer.

!DIRECT Inference Prompt: You are a TableQA assistant. Answer the question using the table as the primary evidence source. Use validated evidence and optional computational support only as helpful context. Return exactly: <think> Your reasoning </think> <answer> Your final answer </answer> Question: {question} Validated Evidence: {evidence} Computational Support: {computation} Table: {table}. (a) DIRECT inference prompt. REDUCE Planning Prompt: You are a TableQA decomposer. Generate the minimal executable operation list needed to answer the question. Allowed operators: PROJECTION, FILTER, NEIGHBOR, SORT, TOPK, AGGREGATE, COMPUTE. Use validated evidence to ground columns, values, and conditions. Do not invent unsupported content. Return exactly: <think> Brief planning rationale </think> <answer> [ { "operator_name": "...", "arguments": {...}, "explanation": "..." } ] </answer> Question: {question} Validated Evidence: {evidence} Required Operations: {required_operations} Table Schema: {schema} Table: {table}. (b) REDUCE planning prompt. EXECUTE Inference Prompts: [Schema Linking] Select only the tables and columns required by the question. Use validated evidence and matched values to ground columns and conditions. Question: {question} Table Schema: {schema} Matched Values: {matched_values} Validated Evidence: {evidence} [SQL Generation] Generate SQLite-compatible SQL that answers the question. Return exactly: <reasoning> Brief SQL rationale </reasoning> <result> SQLite query </result> [SQL Revision] Repair the candidate SQL using execution or checker feedback. Correct schema, value, condition, or operation errors. Candidate SQL: {candidate_sql} Checker Feedback: {feedback} [SQL Selection] Select the candidate SQL most likely to execute correctly and answer the question. Candidates: {candidate_sqls}. (c) EXECUTE schema-linking and program-generation prompts. bbox=0.12,0.09,0.88,0.92

Figure 7. Route-specific prompt templates used by TABLEROUTE: (a) full-table answering with DIRECT, (b) operation planning with REDUCE, and (c) program generation with EXECUTE.

Fallback Behavior

The route-specific interfaces are designed to fail softly. If the REDUCE planner output cannot be parsed, the parser returns an empty operation list and the upper-level pipeline applies the configured fallback. If no valid reduction remains after validation and repair, the route either proceeds with an empty reduction result or falls back to a head subtable when this option is enabled. For DIRECT and EXECUTE, missing evidence does not abort inference; the route proceeds with the available question, table, and schema information.

Dataset Statistics.

Table 21 summarizes the scale differences across benchmarks. WikiTQ and TableBench are dominated by short tables, with average serialized lengths below 1K tokens. WTQ-L has a larger average length of 3.8K tokens and at least 49 rows per table, matching the long-table setting where full-table reading remains possible but becomes less reliable. In contrast, BirdQA contains massive scale tables, with maximum rows exceeding one million and an average serialized length of 5.7M tokens, far beyond standard LLM context windows. These statistics support our benchmark grouping into short, long, and massive table settings.

Dataset#QMin RowsMax RowsMin ColsMax ColsAvg. Tokens
WikiTQ4,3445517321842.6
WTQ-L336495173113,819.0
TableBench8286176420512.8
BirdQA314251,056,3202745,669,661.2

Table 21. Dataset statistics. Avg. Tokens denotes the average token length of the full serialized table.

Row-Count Bucket Analysis on WTQ-L

In addition to the aggregate results in Table 3, Table 22 reports accuracy below and above 200 rows for GPT-4o-mini and Qwen2.5-72B. TABLEROUTE achieves the best accuracy in all four model–bucket settings, outperforming the strongest baseline by 0.5–2.5 points. These results show that its gains persist across the evaluated row-count ranges rather than being driven by one bucket.

TableBench Generalization Results

Table 23 reports the supplementary TableBench result. TableBench covers broader table-centric reasoning tasks beyond standard TableQA. Using LLaMA3.3-70B, TABLEROUTE improves over both CoT and RoT, indicating that the evidence-and-routing framework can generalize beyond the three main TableQA benchmarks.

Base LLMCoTRoTTABLEROUTE
LLaMA3.3-70B38.244.848.7

Table 23. Generalization results on TableBench. Scores are reported with ROUGE-L.

GPT-5-mini Generalization Results

Table 25 reports the supplementary results using GPT-5-mini as the base LLM. Across WikiTQ, WTQ-L, and BirdQA, TABLEROUTE outperforms the strongest baseline by 0.8, 1.7, and 3.5 points, respectively. The larger gains on WTQ-L and BirdQA show that long and massive tables continue to benefit from capability-aware routing under a stronger base LLM.

MethodWikiTQWTQ-LBirdQA
CoT ((Wei et al., 2022))76.455.9–
RoT ((Zhang et al., 2025))81.756.5–
TALON ([8])71.967.972.6
TABLEROUTE82.569.676.1
Δ\Delta+0.8+1.7+3.5

Table 25. Exact-match accuracy (%) using GPT-5-mini. Bold denotes the best result and underlining the strongest baseline. Δ\Delta is the absolute improvement of TABLEROUTE over the strongest baseline.

Evidence Extraction Cost and End-to-End Latency

Evidence Extraction Cost. We investigate whether a smaller model can reduce the overhead of evidence generation. On WTQ-L, we replace the evidence extractor with GPT-5-nano while keeping the remaining pipeline unchanged. QA accuracy decreases from 69.0% to 68.0%, while total token consumption increases by 3.1%. These results suggest that using a smaller extractor does not necessarily improve the accuracy–efficiency trade-off.

End-to-End Latency. We further measure end-to-end latency on BirdQA using the original GPT-4o-mini DeepEye-SQL configuration. The evidence-enhanced DeepEye-SQL pipeline takes 139.1 seconds per question on average, compared with 136.6 seconds for the original DeepEye-SQL pipeline, representing a 1.9% increase. This indicates that evidence conditioning introduces modest additional latency under the evaluated setting.

Detailed Experimental Settings

Base LLMs and serving. For open-source models, we use a local inference backend based on swift.llm with HuggingFace model weights. For GPT-4o-mini, we use the OpenAI Chat Completions API. QA decoding uses a maximum genera-

tion budget of 2048 new tokens and model default input budget. All temperatures are set to 0 unless otherwise specified.

Execution route configuration. The EXECUTE route follows the official open-source implementation of DeepEye-SQL ([9]). We use its staged pipeline as the program-generation backbone, including value retrieval, schema linking, SQL generation, SQL revision, and execution-aware SQL selection.

Operator Definitions

We define a set of deterministic table operators in Table 24 used by the REDUCE route. Given a filled reduction template, the operation generator produces an executable operator list. The executor then applies these operators to obtain a reduced table and auxiliary computation information. Table-reduction operators modify the current table state, while computation-support operators update auxiliary information used by the final reasoner.

OperatorPseudo-code
projectionFunction Projection(TT, columnscolumns): verify all columns exist in TT T′←T[columns]T' \leftarrow T[columns] return T′T'
filterFunction Filter(TT, conditionsconditions): mask←mask \leftarrow evaluate each column–operator–value condition combine masks with specified logic T′←T[mask]T' \leftarrow T[mask] return T′T'
sortFunction Sort(TT, columncolumn, orderorder): build typed sort key from numeric, date, or textual values T′←T' \leftarrow sort T′T' by columncolumn in orderorder return T′T'
top_kFunction TopK(TT, kk): T′←T' \leftarrow first kk rows of TT return T′T'
neighborFunction Neighbor(TT, anchoranchor, order_columnorder\_column, directiondirection): sort TT by order_columnorder\_column find row matching anchoranchor select adjacent row according to directiondirection return selected row as T′T'
aggregateFunction Aggregate(TT, group_bygroup\_by, aggregationsaggregations): compute statistics such as count, sum, avg, min, max store results in auxiliary dictionary zz return zz
computeFunction Compute(zz, operationoperation, leftleft, rightright, aliasalias): read operands from zz or constants compute add, subtract, multiply, or divide z[alias]←z[alias] \leftarrow computed value return updated zz

Table 24. Pseudo-code definitions of operators used in the REDUCE route.

References

  1. [1]Nikhil Abhyankar, Vivek Gupta, Dan Roth, and Chandan K. Reddy. 2025. H-S-TAR: llm-driven hybrid sql-text adaptive reasoning on tables. In NAACL, pages 8841–8863.
  2. [2]Lang Cao and Hanbing Liu. 2026. TableMaster: A recipe to advance table understanding with language models. ICLR.arxiv.org/abs/2501.19378
  3. [3]Si-An Chen, Lesly Miculicich, Julian M Eisenschlos, Zifeng Wang, Zilong Wang, Yanfei Chen, Yasuhisa Fujii, Hsuan-Tien Lin, Chen-Yu Lee, and Tomas Pfister. 2024. TableRAG: Million-token table understanding with language models. In NeurIPS, pages 74899–74921.arxiv.org/abs/2410.04739
  4. [4]Zhoujun Cheng, Tianbao Xie, Peng Shi, Chengzu Li, Rahul Nadkarni, Yushi Hu, Caiming Xiong, Dragomir Radev, Mari Ostendorf, Luke Zettlemoyer, Noah A. Smith, and Tao Yu. 2023. Binding language models in symbolic languages. In ICLR.arxiv.org/abs/2210.02875
  5. [5]Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, and 1 others. 2024. The Llama 3 herd of models. CoRR, abs/2407.21783.arxiv.org/abs/2407.21783
  6. [6]Dawei Gao, Haibin Wang, Yaliang Li, Xiuyu Sun, Yichen Qian, Bolin Ding, and Jingren Zhou. 2024. Text-to-sql empowered by large language models: A benchmark evaluation. Proc. VLDB Endow., 17(5):1132–1145.arxiv.org/abs/2308.15363
  7. [7]Aaron Hurst, Adam Lerer, Adam P. Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, Aleksander Madry, Alex Baker-Whitcomb, Alex Beutel, and 1 others. 2024. GPT-4o system card. CoRR, abs/2410.21276.arxiv.org/abs/2410.21276
  8. [8]Ruochun Jin, Xiyue Wang, Dong Wang, Haoqi Zheng, Yunpeng Qi, Silin Yang, and Meng Zhang. 2025. TALON: A multi-agent framework for long-table exploration and question answering. In EMNLP, pages 27397–27413.DOI
  9. [9]Boyan Li, Chong Chen, Zhujun Xue, Yinan Mei, and Yuyu Luo. 2026. DeepEye-SQL: a software-engineering-inspired text-to-sql framework. Proc. ACM Manag. Data, 4(3).DOI
  10. [10]Jinyang Li, Binyuan Hui, Ge Qu, Jiaxi Yang, Binhua Li, Bowen Li, Bailin Wang, Bowen Qin, Ruiying Geng, Nan Huo, Xuanhe Zhou, Chenhao Ma, Guoliang Li, Kevin Chen-Chuan Chang, Fei Huang, Reynold Cheng, and Yongbin Li. 2023. Can LLM already serve as a Database interface? A big bench for large-scale database grounded text-to-sqls. In NeurIPS.
  11. [11]Qianlong Li, Chen Huang, Shuai Li, Yuanxin Xiang, Deng Xiong, and Wenqiang Lei. 2025. GraphOTTER: Evolving llm-based graph reasoning for complex table question answering. In COLING, pages 5486–5506.arxiv.org/abs/2412.01230
  12. [12]Chin-Yew Lin. 2004. ROUGE: A package for automatic evaluation of summaries. In Text Summarization Branches Out, pages 74–81. ACL.
  13. [13]Nelson F. Liu, Kevin Lin, John Hewitt, Ashwin Paran-jape, Michele Bevilacqua, Fabio Petroni, and Percy Liang. 2024. Lost in the Middle: How language models use long contexts. Transactions of the Association for Computational Linguistics, 12:157–173.arxiv.org/abs/2307.03172
  14. [15]Thi-Nhung Nguyen, Hoang Ngo, Dinh Q. Phung, Thuy-Trang Vu, and Dat Quoc Nguyen. 2025. Improving table understanding with llms and entity-oriented search. CoRR, abs/2508.17028.arxiv.org/abs/2508.17028
  15. [16]Isaac Ong, Amjad Almahairi, Vincent Wu, Wei-Lin Chiang, Tianhao Wu, Joseph E. Gonzalez, M. Waleed Kadous, and Ion Stoica. 2024. Routellm: Learning to route llms with preference data. CoRR, abs/2406.18665.arxiv.org/abs/2406.18665
  16. [17]OpenAI. 2026. Openai GPT-5 system card. CoRR, abs/2601.03267.
  17. [18]Panupong Pasupat and Percy Liang. 2015. Compositional semantic parsing on semi-structured tables. In ACL/IJCNLP, pages 1470–1480.arxiv.org/abs/1508.00305

Paper details

vlnc:W_uhyvu679
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents