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.
| Method | Direct QA | Table Reduction | Program Execution | Pre-exec. Routing | Single-route Inference | Validated Evidence | Model-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 Type | Short | Long | Massive | Overall |
| Semantic mismatch | 44.0 | 31.0 | 52.0 | 42.3 |
| Computation error | 24.0 | 28.0 | – | 17.4 |
| Evidence localization | 17.0 | 26.0 | – | 14.3 |
| Reduction or execution error | 7.0 | 11.0 | 41.0 | 19.7 |
| Others | 8.0 | 4.0 | 7.0 | 6.3 |
| Semantic + computation | 68.0 | 59.0 | 52.0 | 59.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).

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.
| Strategy | WTQ-L | BirdQA | ||||
| Acc. | Relative Cost (×) | Acc. | Relative Cost (×) | |||
| CoT only | 58.1 | 1.00 | – | – | ||
| DATER only | 54.7 | 3.15 | 61.8 | 2.76 | ||
| DeepEye-SQL only | – | – | 69.7 | 1.00 | ||
| LLM Self-routing | 60.4 | 1.48 | 66.8 | 1.34 | ||
| Answer Selection | 62.0 | 4.15 | 69.0 | 3.76 | ||
| Oracle Routing | 69.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 , table , and base model , 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 and a required-operation set per question–table pair. Here, 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 . Each retained evidence item is represented as
where is the question span triggering grounding, is the resolved table column, and is the condition over , specifying how a grounded value is matched or compared. If no condition is required, . 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 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 , 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 . . Since it requires aggregation, it is assigned .
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 and model , we define
where is the serialized table and is the tokenizer of model . This isolates the table-size variation while keeping the prompt template fixed.
Reference Accuracy. For each model, we use tables with tokens as a common small-table reference range, matching the first size range in our empirical analysis. Let denote the model’s full-table accuracy within this range. We allow an accuracy drop of and define . 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 and operation group , we independently examine whether full-table performance remains above the reliability target as table size increases. We collect the held-out question–table pairs assigned to group and measure each table by its serialized token size . These pairs are ordered by 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 examples. For a fixed model–group pair , let index a resulting calibration bin. Let denote the number of examples in bin , and the number answered correctly. For , we compute the one-sided Clopper–Pearson lower confidence bound as
When , we set . Here, denotes the Beta-distribution quantile function, whose shape parameters and are determined by the observed outcomes rather than tuned. We use , giving a one-sided 95% lower confidence bound.
For each pair, starting from the smallest tables, we retain consecutive calibration bins satisfying . The reliable range ends before the first bin whose lower bound falls below . The upper endpoint of the retained bins defines , the upper limit of the reliable table-size range for model and operation group . 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 denote the token length of the complete DIRECT prompt, including the instruction, question, evidence, serialized table, and output format. Let denote the usable context-window budget of model , and the selected route.
We set when . For inputs that fit within the context window, the table size and calibrated range limit determine the route:
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- 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 ().
| WTQ (Mostly Short) | ||||
| Method | Qwen | LLaMA | GPT | Avg. |
| End-to-End QA | 42.6 | 51.1 | 56.3 | 50.0 |
| Python QA | 41.9 | 53.5 | 51.2 | 48.9 |
| GraphOTTER | 55.3 | 55.1 | 50.3 | 53.6 |
| Binder | 58.5 | 57.0 | 61.4 | 59.0 |
| Dater | 60.2 | 63.8 | 59.8 | 61.3 |
| RowColRetrieval | 53.4 | / | 55.2 | 54.3 |
| TableRAG | 59.7 | / | 55.2 | 57.5 |
| TALON | 69.6 | 64.6 | 71.0 | 68.4 |
| Table-Critic | 77.2 | 70.1 | 73.9 | 73.7 |
| H-STAR | / | 75.8 | 74.9 | 75.4 |
| TUNES | / | 76.8 | 75.4 | 76.1 |
| RoT | 77.3 | 78.7 | 74.2 | 76.7 |
| TABLEROUTE (ours) | 79.1 | 79.7 | 77.5 | 78.8 |
| +1.8 | +1.0 | +2.1 | +2.1 | |
| WTQ-L (Mostly Long) | ||||
| Method | Qwen | LLaMA | GPT | Avg. |
| End-to-End QA | 34.0 | 40.2 | 55.5 | 43.2 |
| Python QA | 36.3 | / | 53.8 | 45.1 |
| Binder | 60.3 | / | 61.0 | 60.7 |
| Dater | 51.2 | / | 54.7 | 53.0 |
| RowColRetrieval | 49.9 | / | 47.2 | 48.6 |
| TableRAG | 59.6 | / | 52.1 | 55.9 |
| RoT | 35.0 | 41.7 | / | 38.4 |
| TALON | 66.6 | 59.5 | 67.0 | 64.4 |
| TABLEROUTE (ours) | 68.2 | 67.0 | 67.6 | 67.6 |
| +1.6 | +7.5 | +0.6 | +3.2 | |
| BirdQA (Mostly Massive) | ||||
| Method | Qwen | LLaMA | GPT | Avg. |
| Binder | 59.2 | / | 60.8 | 60.0 |
| RowColRetrieval | 42.7 | / | 48.4 | 45.6 |
| TableRAG | 53.5 | / | 54.7 | 54.1 |
| DeepEye-SQL | 69.1 | 72.3 | 69.7 | 70.4 |
| TALON | 70.0 | 66.9 | 72.0 | 69.6 |
| TABLEROUTE (ours) | 73.6 | 78.7 | 74.8 | 75.7 |
| +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. 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.
| Method | GPT-4o-mini | GPT-4o-mini | Qwen2.5-72B | Qwen2.5-72B |
| < 200 | ≥ 200 | < 200 | ≥ 200 | |
| End-to-End QA | 56.4 | 54.2 | 36.1 | 25.0 |
| Python QA | 52.1 | 55.6 | 34.6 | 35.4 |
| Binder | 58.5 | 60.6 | 58.5 | 58.5 |
| Dater | 53.7 | 52.8 | 52.4 | 45.3 |
| RowColRetrieval | 47.6 | 50.0 | 48.7 | 50.0 |
| TableRAG | 51.4 | 50.0 | 58.3 | 58.3 |
| TALON | 66.8 | 66.7 | 66.2 | 65.0 |
| TABLEROUTE | 67.7 | 67.2 | 68.7 | 65.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 | #Q | CoT | TABLEROUTE | |
| Count | 1704 | 73.7 | 74.8 | +1.1 |
| Diff. | 103 | 65.0 | 68.9 | +3.9 |
| Sum | 105 | 78.1 | 80.0 | +1.9 |
| Avg. | 23 | 56.5 | 65.2 | +8.7 |
| Extrema | 85 | 72.9 | 76.5 | +3.6 |
| Ratio | 11 | 63.6 | 72.7 | +9.1 |
Table 4. Averaged accuracy by computational question types over base LLMs on WikiTQ. 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.
| Setting | WikiTQ | WTQ-L | BirdQA |
| TABLEROUTE | 78.8 | 67.6 | 75.7 |
| w/o Validated Evidence | 76.3 (↓2.5) | 63.8 (↓3.8) | 70.8 (↓4.9) |
| w/o Computational Support | 76.8 (↓2.0) | 65.5 (↓2.1) | – |
| DIRECT-only | 75.2 (↓3.6) | 41.0 (↓26.6) | – |
| REDUCE-only | 73.8 (↓5.0) | 61.3 (↓6.3) | – |
| EXECUTE-only | 64.6 (↓14.2) | 59.5 (↓8.1) | 70.4 (↓5.3) |
| Model | Global | Per-Model | Per-Model+Group |
| GPT | 66.4 (↓1.2) | 67.0 (↓0.6) | 67.6 |
| LLaMA | 65.5 (↓1.5) | 66.4 (↓0.6) | 67.0 |
| Qwen | 66.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 ( tokens), Mid (2560–6144 tokens), and Long ( 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.
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 , 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 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.
| Field | Description |
semantic_unit | Question phrase to be grounded. |
column_hint | Natural-language hint for the target column. |
grounding_type | Expected value type: text, number, or date. |
operator | Condition operator. |
value | Main literal value. |
value2 | Second 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 and normalized column header :
Here, is the SequenceMatcher ratio, and is 1 if either string is a substring of the other and 0 otherwise. We set 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.
| Dataset | Avg cand. | Kept | Dropped | Empty |
| WikiTQ | 1.872 | 0.736 | 0.264 | 30.1% |
| WTQ-L | 1.773 | 0.811 | 0.189 | 15.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 type | WikiTQ | WTQ-L |
| Unresolved column | 1180 / 8132 | 56 / 596 |
| Type mismatch | 105 / 8132 | 14 / 596 |
| Parse failure | 600 / 8132 | 34 / 596 |
| Not executable | 971 / 8132 | 57 / 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.

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.

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 under model . We use as the small-table reference range and define . We set tokens, matching the first size range in our empirical analysis, and . 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 ( table tokens), medium (–), and long () 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.
| Model | Short | Medium | Long |
| Qwen | 0.750 | 0.656 | 0.617 |
| GPT | 0.796 | 0.722 | 0.642 |
| LLaMA | 0.740 | 0.644 | 0.658 |
| Avg. | 0.763 | 0.674 | 0.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.
| Operation | Acc. | |
| Projection | 0.736 | 1,214 |
| Sort | 0.729 | 380 |
| Top-k | 0.726 | 357 |
| Neighbor | 0.720 | 214 |
| Filter | 0.686 | 948 |
| Compute | 0.686 | 102 |
| Aggregate | 0.614 | 817 |
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.
| Operation | Short | Long | |
| Projection | 0.785 | 0.687 | -0.098 |
| Filter | 0.779 | 0.610 | -0.169 |
| Neighbor | 0.763 | 0.691 | -0.072 |
| Sort | 0.781 | 0.648 | -0.133 |
| Top-k | 0.793 | 0.612 | -0.181 |
| Aggregate | 0.747 | 0.449 | -0.298 |
| Compute | 0.889 | 0.526 | -0.363 |
caption: Operation-by-table-size effect. denotes long minus short accuracy.
:::
Operation Groups
The operation groups follow the definition in § 4.1 and are summarized in Table 14.
| Group | Operation types |
| LIGHT | PROJECTION, FILTER, NEIGHBOR |
| HEAVY | SORT, 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 and . 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 pair, held-out question–table pairs are ordered by their serialized table size and initially divided into 256-token bins. Adjacent bins are merged until each contains at least examples. We then apply the lower-confidence-bound criterion in Equation (3) to obtain the upper endpoint of each reliable range.
All calibration settings are shared across models and operation groups, as summarized in Table 15.
| Setting | Symbol | Default |
| Reference table size | 2,048 | |
| Accuracy tolerance | 0.10 | |
| Initial bin width | — | 256 |
| Minimum bin size | 50 | |
| One-sided tail | 0.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.
| Model | LIGHT range | HEAVY range | ||
| GPT | 0.796 | 0.696 | ||
| LLaMA | 0.740 | 0.640 | ||
| Qwen | 0.752 | 0.652 |
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.
| Model | Calibration | Dir. | Red. | Exec. |
| GPT | Model-only | 48.81 | 42.56 | 8.63 |
| GPT | Model+Group | 44.35 | 47.02 | 8.63 |
| LLaMA | Model-only | 41.97 | 49.40 | 8.63 |
| LLaMA | Model+Group | 40.48 | 50.89 | 8.63 |
| Qwen | Model-only | 46.73 | 44.64 | 8.63 |
| Qwen | Model+Group | 38.99 | 52.38 | 8.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 Strategy | WikiTQ | WTQ-L |
| Length-only | 81.7 | 68.5 |
| LLM-based | 82.0 | 68.8 |
| Learned | 82.2 | 69.0 |
| TABLEROUTE | 82.5 | 69.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.
| Setting | WikiTQ | WTQ-L |
| Original three backbones (average) | ||
| Model-specific calibration | 78.8 | 67.6 |
| Cross-model calibration | 78.6 | 67.3 |
| LLM semantic routing | 79.0 | 68.6 |
| GPT-5-mini | ||
| Per-operation calibration | 82.4 | 69.4 |
| LIGHT/HEAVY calibration | 82.5 | 69.6 |
| Oracle routing | 84.9 | 76.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- 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.
| Setting | Acc. |
| Schema-only reduction | 66.5 |
| Schema-only reduction + evidence | 68.0 |
| Best schema-only reduction | 70.1 |
| Full-table-visible reduction | 70.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.
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 | #Q | Min Rows | Max Rows | Min Cols | Max Cols | Avg. Tokens |
| WikiTQ | 4,344 | 5 | 517 | 3 | 21 | 842.6 |
| WTQ-L | 336 | 49 | 517 | 3 | 11 | 3,819.0 |
| TableBench | 828 | 6 | 176 | 4 | 20 | 512.8 |
| BirdQA | 314 | 25 | 1,056,320 | 2 | 74 | 5,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 LLM | CoT | RoT | TABLEROUTE |
| LLaMA3.3-70B | 38.2 | 44.8 | 48.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.
| Method | WikiTQ | WTQ-L | BirdQA |
| CoT ((Wei et al., 2022)) | 76.4 | 55.9 | – |
| RoT ((Zhang et al., 2025)) | 81.7 | 56.5 | – |
| TALON ([8]) | 71.9 | 67.9 | 72.6 |
| TABLEROUTE | 82.5 | 69.6 | 76.1 |
| +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. 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.
| Operator | Pseudo-code |
| projection | Function Projection(, ): verify all columns exist in return |
| filter | Function Filter(, ): evaluate each column–operator–value condition combine masks with specified logic return |
| sort | Function Sort(, , ): build typed sort key from numeric, date, or textual values sort by in return |
| top_k | Function TopK(, ): first rows of return |
| neighbor | Function Neighbor(, , , ): sort by find row matching select adjacent row according to return selected row as |
| aggregate | Function Aggregate(, , ): compute statistics such as count, sum, avg, min, max store results in auxiliary dictionary return |
| compute | Function Compute(, , , , ): read operands from or constants compute add, subtract, multiply, or divide computed value return updated |
Table 24. Pseudo-code definitions of operators used in the REDUCE route.
References
- [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]Lang Cao and Hanbing Liu. 2026. TableMaster: A recipe to advance table understanding with language models. ICLR.arxiv.org/abs/2501.19378
- [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]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]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]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]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]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]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]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]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]Chin-Yew Lin. 2004. ROUGE: A package for automatic evaluation of summaries. In Text Summarization Branches Out, pages 74–81. ACL.
- [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
- [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
- [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
- [17]OpenAI. 2026. Openai GPT-5 system card. CoRR, abs/2601.03267.
- [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


