The challenge begins with a fundamental mismatch. Large language models are built to process linear sequences of text, while tables are inherently two-dimensional structures. To make a table readable by a model, engineers must flatten it into text, usually in Markdown or JSON format. For a small table this works reasonably well. But for an industrial-scale table with hundreds of thousands of rows, the flattened version can exhaust the model’s context window entirely, leaving no room for the model to actually reason about the question. Even when the table fits, researchers have documented a phenomenon known as Loss in the Middle, in which models pay less attention to information buried in the middle of long inputs.

A team of researchers at the Institute of Artificial Intelligence (TeleAI) at China Telecom, led by Sishi Xiong and Ziyang He, set out to tackle these bottlenecks head-on. Their starting point was a simple observation: for any given question, the vast majority of cells in a large table are irrelevant noise. A question about average sales per publisher does not need the model to read every customer review column. Rather than forcing the model to digest the entire table, TableZoomer first builds a compact summary and then zooms in on only the parts that matter.

The framework’s first innovation is schema-based representation. Instead of feeding the model the full verbalized table, a component called the Table Describer parses the spreadsheet using the Pandas toolkit and generates a structured JSON schema. This schema captures each column’s data type, statistical properties such as maximum, minimum, mean and median values for numerical data, unique categories for categorical data, and a handful of randomly sampled cell values as examples. The result reduces the token complexity of the table representation from O(M times N), where M and N are the numbers of rows and columns, down to O(N), a reduction of orders of magnitude. Crucially, the schema is generated only once per table and can be reused across many questions.

Next comes the zooming mechanism, which the authors describe as query-aware table focusing. A Query Planner, guided by chain-of-thought prompting, decomposes the user’s question into atomic sub-queries and classifies them as either column-only queries, which can be answered from aggregate statistics, or row-column queries, which require identifying both relevant rows and columns. The Table Refiner then performs three operations: column selection to discard irrelevant features, entity linking to match names mentioned in the question with their surface forms in the table using a Longest Common Subsequence algorithm with an overlap threshold of 0.6, and table zooming to produce a minimal, query-relevant sub-schema. On the benchmark datasets, this column selection compressed the original column counts to just 5.2, 19.8 and 22.6 percent of their original sizes on DataBench, TableBench and WikiTableQA respectively.

Once the table has been zoomed, the framework turns to execution. Rather than asking the model to reason about numbers in natural language, a strategy prone to numerical hallucination, TableZoomer employs the Program-of-Thoughts approach, prompting the language model to generate executable Python code. The code runs in an isolated environment, and if execution fails, an error feedback mechanism returns the code and error traces to the model for self-correction. The entire workflow is orchestrated through the ReAct paradigm, an iterative cycle of thought, action and observation, with reasoning rounds capped at five. An Answer Formatter finally packages the result into whatever strict output format the task demands, from pure numbers to complete sentences.

The performance numbers are striking. When implemented with the Qwen3-8B-Instruct model, TableZoomer achieved accuracy improvements of 19.34 percent on the large-scale DataBench dataset and 25 percent on the Fact Checking task of TableBench compared with conventional Program-of-Thoughts methods, plus an 11.84 percent gain on TableBench’s Numerical Reasoning task. Perhaps most remarkably, the framework narrows the gap between models of different sizes: the TableZoomer-enhanced Qwen3-8B outperformed the much larger baseline Qwen3-32B model. For companies weighing the cost of deploying large models, this suggests that a well-designed agent framework can let smaller, cheaper models punch far above their weight.

Scalability proved to be another standout strength. The researchers sorted DataBench tables by cell count into large subsets averaging 1,519,065 cells, medium subsets averaging 18,131 cells and small subsets averaging 2,882 cells. Textual chain-of-thought reasoning degraded severely as table size grew, while code-based Program-of-Thoughts held up better. TableZoomer, however, showed minimal performance degradation across all three size categories, an attribute the authors attribute to the Table Describer and Table Refiner components excelling at locating essential information within massive tables. The framework also proved remarkably robust to how tables are serialized: while a baseline model’s accuracy fluctuated by up to 9.18 percentage points across Pandas-String, Markdown, JSON and structured formats, TableZoomer varied by only 0.57 points, staying between 86.59 and 87.16 percent.

Ablation studies on DataBench using Qwen3-8B confirmed which components matter most. Simply replacing the full-table Markdown text with the schema representation improved accuracy by 6.51 percentage points. Adding the table zooming mechanism then pushed accuracy from 74.33 to 86.40 percent, marking it as the framework’s core engine. Removing entity linking cost 1.73 points, and the ReAct reflection loop delivered a modest but consistent additional gain. Case studies illustrated the practical differences: where a baseline program-of-thoughts method misread a hierarchical Parent ID column and returned the number 150 instead of the category name Attractions, TableZoomer’s schema-level semantic annotations enabled an extra lookup that produced the correct answer. In another case, the framework’s denoising stage recovered a string-encoded dictionary field that stumped the baseline, correctly extracting an overall rating.

Efficiency analysis showed TableZoomer’s core workflow requires a minimum of five language model invocations, spanning the Table Describer, Query Planner, Code Generator, Answer Formatter and ReAct reflection, with the schema generated once and reused across multi-turn question answering. Competing frameworks often demand more: Chain-of-Table scales its inference count with the number of planning and execution operations, PoTable typically needs at least eight calls, and TableMaster at least six. On WikiTableQA, TableZoomer using LLaMA3.1-70B trailed only TableMaster, by 1.43 percent, while outperforming the second-ranked PoTable by 10.96 percent. The authors are candid about limitations: the predefined fixed workflow remains a bottleneck, and they plan to explore a central brain module that autonomously selects optimal action paths, as well as extending the framework toward vision-language models that could perceive table layouts directly. The source code is publicly available on GitHub, inviting the community to build on a framework that may well redefine how machines read the world’s spreadsheets.

Subject of Research: Large language model agent framework for table question answering over large-scale tabular data

Article Title: TableZoomer: a collaborative agent framework for large-scale table question answering

Article References: Xiong, S., He, Z., He, Z., Zhao, Y., Pan, C., Zhang, J., Song, S., & Li, Y. (2025). TableZoomer: a collaborative agent framework for large-scale table question answering. Vicinagearth, 2(1), Article 11. https://doi.org/10.1007/s44336-025-00016-x

Image Credits: AI Generated

DOI: 10.1007/s44336-025-00016-x

Keywords: table question answering, large language models, TableZoomer, agent framework, Program-of-Thoughts, ReAct, schema representation, entity linking, DataBench, TableBench, numerical reasoning, code generation