TALON: A Multi-Agent Framework for Long-Table Exploration and Question Answering

Ruochun Jin, Xiyue Wang, Dong Wang, Haoqi Zheng, Yunpeng Qi, Silin Yang, Meng ZhangEMNLP 2025

TL;DR

This paper introduces TALON, a novel multi-agent framework designed to tackle the challenge of answering questions over extremely long tables. By employing a collaborative system of planning, tool execution, and critical evaluation agents, TALON significantly improves accuracy and efficiency, setting a new state-of-the-art in long-table question answering.

What Problem Does This Paper Address?

Table Question Answering (TQA) is crucial for making tabular data accessible. However, existing methods struggle with "long tables" – those with many rows (e.g., over 30). Simply feeding entire long tables into Large Language Models (LLMs) often fails due to context window limitations, leading to information loss. While approaches like Retrieval-Augmented Generation (RAG) and Text-to-SQL aim to mitigate this, they often falter in accurately retrieving relevant information or understanding complex table structures and data types (e.g., treating numerical data as text). This results in inaccurate answers, especially when dealing with numerical constraints or complex queries.

Methods

TALON is a multi-agent framework that mimics human reasoning for exploring long tables. It comprises three specialized agents:

  1. Planning Agent: This agent acts as the orchestrator. It iteratively generates reasoning steps and selects the most appropriate tools to use, guided by intermediate feedback. It uses a ReAct-style approach, allowing for concurrent tool invocations to improve efficiency. A self-consistency mechanism is employed to ensure robustness by sampling multiple reasoning paths and selecting the most consistent one.
  2. Tool Agent: This agent is equipped with a comprehensive toolkit for interacting with tabular data. The tools fall into three categories:
  3. Content Retrieval: get_value, get_row, fuzzy_match for locating and extracting specific data.
  4. Structure Analysis: get_column_meaning, process_column_format for understanding column semantics and normalizing data types.
  5. Data Manipulation: python_code for generating and executing Python scripts for complex computations.
  6. Critic Agent: This agent acts as a quality control layer. It reviews the planning agent's strategies, detects and resolves loops (redundant actions), and corrects any errors in tool execution or generated code. This ensures robust and reliable reasoning.

Crucially, TALON does not require the entire table to be loaded into the LLM prompt. Instead, it loads tables into memory as Pandas DataFrames and uses only the table schema (column names and data types) for initial planning, making it highly scalable.

Datasets

The authors constructed two new benchmarks for evaluating TALON on long tables:

  • WTQ-L: A large subset of the WikiTableQuestion dataset, specifically including tables with 50 to over 500 rows. This dataset was further stratified into tables with 50-100, 100-200, and 200+ rows for fine-grained analysis.
  • BirdQA: Derived from the BIRD-SQL dataset, this benchmark features extremely large tables with an average of 44,000 rows, simulating real-world complexity.

Key Insights and Ideas

  • Mimicking Human Reasoning: The multi-agent approach, where agents iteratively gather information and refine focus, closely mirrors how humans tackle complex data exploration tasks.
  • Specialized Toolkit is Key: The diverse set of tools, especially get_column_meaning and process_column_format, is vital for accurately interpreting table structure and handling data that isn't in a standard numerical format.
  • Schema-Only Input for Planning: By relying on table schema for planning rather than full table content, TALON achieves remarkable scalability for very long tables.
  • Critic Agent for Robustness: The critic agent's role in loop resolution and code correction is essential for preventing errors and ensuring the system doesn't get stuck in unproductive cycles.
  • Tool Usage Reflects Task Needs: Analysis shows get_row and get_value are frequently used, highlighting the importance of precise data retrieval. python_code is critical for complex datasets like BirdQA, demonstrating the need for computational capabilities.

Key Results

TALON achieved state-of-the-art performance across multiple LLMs and datasets:

  • Average Accuracy Improvement: TALON demonstrated average accuracy improvements of 7.5% on WTQ-L and 12.0% on BirdQA compared to the second-best performing methods.
  • Consistent Performance: The framework showed robust and stable performance across different LLM backbones (GPT-4o-mini, Qwen2.5-72B-Instruct, DeepSeek-V3).
  • Scalability: Token consumption remained largely stable regardless of table length, unlike methods that scale poorly with table size.
  • Comparison to Text-to-SQL: On the BirdQA benchmark, TALON outperformed mainstream Text-to-SQL approaches, achieving 72.0% accuracy compared to the next best at 59.6%.

Limitations and Future Work

The authors acknowledge several limitations:

  • Limited LLM Testing: Experiments were conducted on only three LLMs; testing on more models could provide broader evidence.
  • Dataset Scarcity: The scarcity of long-table datasets is a challenge, and the authors plan to construct more benchmarks.
  • Structured Tables Focus: TALON is designed for structured tables with well-defined schemas. Handling hierarchical or flattened tables without explicit schemas would require preprocessing and is a direction for future work.

Future work will focus on expanding the dataset landscape and exploring more complex table formats.

Summary updated

BibTeX
@inproceedings{jin2025talon,
  author = {Ruochun Jin and Xiyue Wang and Dong Wang and Haoqi Zheng and Yunpeng Qi and Silin Yang and Meng Zhang},
  title = {{TALON: A Multi-Agent Framework for Long-Table Exploration and Question Answering}},
  booktitle = {Conference on Empirical Methods in Natural Language Processing},
  year = {2025},
}
Figure