Web2BigTable: Scalable Web-to-Table LLM System

• Web2BigTable is a bi-level multi-agent LLM system designed for scalable, schema-aligned table extraction from the web.
• It decomposes complex extraction tasks into parallelizable subtasks orchestrated by an upper-level coordinator and worker agents using persistent skill banks.
• The system employs a closed-loop Run–Verify–Reflect cycle and a shared workboard to achieve state-of-the-art performance in both breadth and depth tasks.

Web2BigTable is a bi-level multi-agent LLM system designed for Internet-scale information search and extraction, with an explicit focus on schema-aligned table construction from web sources. It addresses the dual demands of breadth—high-coverage, consistent aggregation across many entities—and depth—deep, coherent reasoning over long, branching tasks. The system decomposes complex web-to-table problems into parallelizable subtasks, orchestrated by persistent external memory and self-evolving skill banks, thus surpassing the scalability limitations of monolithic and fixed-pipeline agentic systems (Huang et al., 29 Apr 2026).

1. Formalization of Web-to-Table Search

Given a natural-language query $q$ specifying a relational schema of $C$ attributes (columns) and an unspecified entity set (rows), Web2BigTable operates over the open-web environment $W$ (comprising search and browsing capabilities). Each instance is denoted as $T = (q, W)$. The output $X$ is a table whose rows index entities and columns correspond to the requested attributes. Every table cell must be independently verified against web sources. The space of possible tables is denoted $\mathcal{X}$. The policy $\pi$ aims to maximize a global utility $U(X) \in [0, 1]$, concretely defined during training as $U(X) := \mathrm{ItemF1}(X, X^{\text{gold}})$, where $X^{\text{gold}}$ is a reference table.

Single-agent policies are limited by the capacity of the model's context window, particularly when $C$0 is large. Web2BigTable circumvents this bottleneck by factorizing $C$1 into a bi-level composition: an upper-level orchestrator policy $C$2, leveraging decomposition skills $C$3, produces a partition of $C$4 into $C$5 subtasks $C$6; a pool of $C$7 lower-level worker policies $C$8, sharing worker skills $C$9 and coordinating via a shared workboard $W$0, solves each $W$1 in parallel. The joint policy is:

$W$2

where each $W$3 is the execution skill for worker $W$4 and the final output is $W$5.

2. System Architecture and Memory Organization

The Web2BigTable architecture is organized into two explicit levels, each governed by distinct roles and memory regimes.

Orchestrator (Upper Level):

• Reads decomposition skills $W$6 (maintained as SKILL.md files).
• Routes the task via classification strategies (e.g., split-by-entity, split-by-category).
• Emits $W$7 distinct subtask specifications $W$8, each forming a self-contained extraction instruction with an associated schema and scope.

Workers (Lower Level):

• Retrieve execution skills $W$9 through the Memento-Skills mechanism.
• Execute a ReAct loop that interleaves reasoning and tool use to satisfy $T = (q, W)$0.
• Interact using a Markdown-based shared workboard $T = (q, W)$1, constrained to writing into their individual $T = (q, W)$2 slots with file lock protection.

External memory is delineated into:

• Short-term (workboard $T = (q, W)$3): Contains a task checklist, tagged result slots, and shared context. Supports global reads but restricts writes to per-worker slots.
• Long-term (skill banks $T = (q, W)$4, $T = (q, W)$5): Persistent on disk and fixed at inference.

This design enables parallel task decomposition without exceeding LLM context constraints and provides a foundation for scalable cooperation.

3. Bi-Level Training via the Run–Verify–Reflect Cycle

The training paradigm consists of episodic execution structured in three phases:

1. Run: Perform inference under the active skill banks, generating a candidate table $T = (q, W)$6.

2. Verify: Compare $T = (q, W)$7 to $T = (q, W)$8 and construct structured error reports $T = (q, W)$9 including missing coverage, low-accuracy columns, and process anomalies.

3. Reflect: Apply LLM-driven reflect operators $X$0 and $X$1 to update the orchestrator and worker skill banks by appending new SKILL.md entries as dictated by $X$2:

$X$3

No parameter fine-tuning of LLMs occurs; adaptation is mediated entirely by skill-bank evolution.

The two core procedures, TrainWeb2BigTable and Infer, illustrate the high-level control flow. The orchestrator adaptively selects decomposition strategies that ensure each worker’s context window is not exceeded, e.g., partitioning by product line or event tour.

4. Worker Coordination and Conflict Management

The shared workboard $X$4 is central to dynamic coordination. Its strictly partitioned design prohibits write conflicts and enables emergent cooperative behaviors:

• Redundancy Avoidance: Workers read the global state and skip entities already extracted in other slots.
• Coverage Gap Detection: Workers detect missing information in the aggregated results and can initiate corrective actions or insert "NA" markers.
• Refined Search Domains: At each step, a worker sharpens its search over $X$5, where $X$6 is the set of entities already present in $X$7.

These mechanisms permit fully asynchronous and parallel execution with dynamic task adaptation.

5. Evaluation Metrics

Web2BigTable’s empirical performance is established on structured benchmarks with the following criteria:

Metric	Definition	Application
AvgSR@4	$X$8	WideSearch (breadth tasks)
Row F1	Harmonic mean of per-row precision and recall	Measures entity coverage
Item F1	Harmonic mean of per-cell precision and recall (cell types considered)	Measures detailed accuracy

On XBench-DeepSearch (depth tasks), single-run accuracy is judged by an LLM grader.

6. Empirical Results and Ablations

On the WideSearch benchmark (200 held-out tasks), Web2BigTable, using "GPT-5 mini" as orchestrator and "Gemini 3 Flash" as workers with 20 training queries for skill bank evolution, achieves:

• AvgSR@4 = 38.50
• Row F1 = 63.53
• Item F1 = 80.12

These outcomes represent significant improvements over the next best multi-agent baseline (OpenAI o3-high in a standard hierarchy), which records AvgSR@4 ≈ 5.10, Row F1 ≈ 38.50, and Item F1 ≈ 65.70. This constitutes a 7.5× increase in end-to-end success rate, with +25.03 and +14.42 point improvements in Row and Item F1, respectively.

On XBench-DeepSearch (50 held-out tasks), Web2BigTable generalizes to achieve 73.0 accuracy, surpassing Minimax-M2 and MiroFlow (each at 72.0), without any model parameter tuning.

Ablation experiments demonstrate that the orchestrator skill bank $X$9 is essential: removing it drops WideSearch Success Rate from 38.50 to 7.00, and XBench accuracy from 73.0 to 41.0. Disabling the shared workboard or worker skill evolution yields further, but less drastic, degradations.

7. Innovations and Contributions

• Bi-Level Memory-Mediated Architecture: Rigorous separation between upper-level orchestrator (permanent decomposition memory $\mathcal{X}$0) and lower-level workers (execution memory $\mathcal{X}$1 plus ephemeral workboard $\mathcal{X}$2) facilitates scaling to hundreds of table rows while bypassing LLM context saturation.
• Closed-Loop Run–Verify–Reflect: Adaptation is achieved through autonomous, LLM-driven pipelines ($\mathcal{X}$3, $\mathcal{X}$4), incrementally appending SKILL.md files that encapsulate decompositions and execution protocols, maintaining training-free operation at the parameter level.
• Asynchronous Coordination via Workboard: The Markdown-based workboard architecture, with its explicit read/write asymmetry, efficiently supports dynamic avoidance of redundant work, coverage-gap identification, and conflict-free parallel search.
• State-of-the-Art Performance: Achieves new records on benchmarks such as WideSearch and XBench-DeepSearch in both breadth and depth regimes, outperforming both monolithic and conventional hierarchical multi-agent baselines.

Together, these properties position Web2BigTable as a reference framework for scalable, schema-guided search and extraction from the Internet, with a memory-centric, skill-evolving agentic paradigm (Huang et al., 29 Apr 2026).