Web2BigTable: A Bi-Level Multi-Agent LLM System for Internet-Scale Information Search and Extraction

Abstract: Agentic web search increasingly faces two distinct demands: deep reasoning over a single target, and structured aggregation across many entities and heterogeneous sources. Current systems struggle on both fronts. Breadth-oriented tasks demand schema-aligned outputs with wide coverage and cross-entity consistency, while depth-oriented tasks require coherent reasoning over long, branching search trajectories. We introduce \textbf{Web2BigTable}, a multi-agent framework for web-to-table search that supports both regimes. Web2BigTable adopts a bi-level architecture in which an upper-level orchestrator decomposes the task into sub-problems and lower-level worker agents solve them in parallel. Through a closed-loop run--verify--reflect process, the framework jointly improves decomposition and execution over time via persistent, human-readable external memory, with self-evolving updates to each single-agent. During execution, workers coordinate through a shared workspace that makes partial findings visible, allowing them to reduce redundant exploration, reconcile conflicting evidence, and adapt to emerging coverage gaps. Web2BigTable sets a new state of the art on WideSearch, reaching an Avg@4 Success Rate of \textbf{38.50} ($7.5\times$ the second best at 5.10), Row F1 of \textbf{63.53} (+25.03 over the second best), and Item F1 of \textbf{80.12} (+14.42 over the second best). It also generalises to depth-oriented search on XBench-DeepSearch, achieving 73.0 accuracy. Code is available at https://github.com/web2bigtable/web2bigtable.

• The paper introduces a bi-level multi-agent framework where an orchestrator decomposes queries and worker agents perform parallel extraction.
• It employs a run-verify-reflect loop to self-evolve skills, significantly improving extraction success rates over static baselines.
• Experimental results demonstrate a 7.5x performance gain in breadth-oriented tasks and robust multi-hop reasoning in depth-oriented searches.

Web2BigTable: Bi-Level Multi-Agent Framework for Internet-Scale Web-to-Table Extraction

Introduction and Problem Landscape

Web2BigTable addresses the increasing demand for agentic web search systems capable of both deep, multi-hop reasoning over complex queries (depth-oriented search) and large-scale, schema-aligned aggregation across many heterogeneous sources (breadth-oriented search). Prior frameworks, including both monolithic and hierarchical agent architectures, either suffer from context window bottlenecks, compounded error propagation, or static, non-adaptive decomposition strategies, constraining their efficacy in structuring information at internet scale. The essential challenge is to design a system that maintains high inter-row consistency, wide entity coverage, and supports robust, adaptive coordination between concurrent agents under an evolving utility landscape.

System Architecture

Web2BigTable introduces a bi-level, memory-mediated multi-agent framework with two principal layers:

1. Orchestrator: An upper-level reasoning agent executes task decomposition, classifying user queries into structural archetypes (e.g., split-by-entity, split-by-category, split-by-source) and partitioning the target schema across sub-problems, leveraging a persistent orchestrator skill bank ($S_o$). For each decomposition, the orchestrator instantiates natural-language subtask specifications, output constraints, and initializes the shared working memory (workboard).
2. Worker Agents: A pool of asynchronous, parallel LLM workers, each with independent trajectories, resolves sub-tasks using a shared, evolving repository of execution skills ($S_w$). Workers coordinate via a globally readable, regionally writable Markdown workboard, which preserves all intermediate states, partial outputs, and enables live adaptation to emerging evidence and detected coverage gaps.

Adaptation throughout occurs solely through external, persistent, human-readable memory—including all acquired skills and strategies—eschewing any fine-tuning or gradient-based updates on the underlying LLMs. This separation of reasoning and learning, and the decoupling of working and long-term memory, allows for both rapid coordination and slow-timescale skill evolution.

Self-Evolving Skill Learning

The core innovation lies in the run-verify-reflect training loop:

• Run: For every task, the orchestrator and workers execute decomposition and extraction, recording all tool calls, reasoning chains, and partial tables.
• Verify: Outputs are evaluated against gold-standard tables using cell-type-specific comparators (exact match, numeric tolerance, URL normalization, semantic LLM judgement).
• Reflect: Structured error reports are aggregated, clustering recurring decomposition or retrieval failures, which are then synthesized into new skill entries by LLM-powered reflection routines. These skills are versioned, human-editable, and criteria-based. Worker-level adaptation includes autonomous discovery (via BM25, embedding search) and dynamic synthesis of new skills when gaps are encountered, supporting instant propagation of improved Python tool scripts and knowledge entries across the agent pool.

Persistent memory separation enables a clean distinction between across-task skill consolidation ($S_o$, $S_w$) and per-query state ($m_e$), avoiding catastrophic forgetting and amplifying framework adaptability.

Parallel and Asynchronous Coordination

The workboard mechanism is crucial for intra-episode agent collaboration. Workers asynchronously read the global state, observe peer progress, avoid redundant searches, and dynamically redirect their local plans to fill detected coverage or verification gaps. Write access is slot-tag restricted, while the global state remains readable, facilitating asynchronous consensus with minimal coordination overhead and enabling natural information cascades as faster workers supply context for those lagging behind.

This configuration effectively handles high-cardinality schema tasks (hundreds of entities/columns), with dynamic subtask reallocation (e.g., gap detection, secondary verification rounds) triggered directly by orchestrator-learned decomposition rules and workboard evidence.

Experimental Results

WideSearch (Breadth-Oriented)

Web2BigTable delivers a Success Rate of 38.50 (7.5x over nearest multi-agent baseline at 5.10), Row F1 of 63.53 (+25.03 improvement), and Item F1 of 80.12 (+14.42 improvement). These gains are independent of backbone LLM strength: ablating learned orchestrator skills collapses performance (Success Rate drops from 38.50 to 7.0). The main source of superiority is the learned, task-adaptive decomposition, which eliminates the systematic coverage gaps of generic or statically-designed plans.

Single-agent or non-adaptive multi-agent baselines, including those leveraging models strictly stronger than those in Web2BigTable (e.g., Claude-4.5-Sonnet, GPT-5 High), plateau far below these results. Representative tasks (e.g., extracting all Taylor Swift concert events, or full AMD Zen CPU release tables) see single agents retrieving only $\approx$20\% of the required items, versus 94–96% for the bi-level framework with learned strategies.

XBench-DeepSearch (Depth-Oriented)

Accuracy reaches 73.0, outperforming proprietary and open-source baselines by 1–17 points and demonstrating robust generalization to multi-hop, cross-source reasoning. Disabling learned orchestrator skills results in a 32-point drop (73.0 to 41.0), affirming the centrality of self-evolved decomposition.

Ablation and Case Studies

• Component ablation reveals orchestrator skill evolution as the dominant contributor, with shared workboard (coordination) and worker skill progress as significant but secondary drivers.
• Case studies confirm that generic time-based decompositions are insufficient for high-cardinality extraction tasks; learned entity- or category-based splits, with dedicated verification workers, achieve nearly complete schema coverage.
• Live skill evolution enables not only rapid exploitation of new evidence but resilient error recovery (e.g., auto-repair/reflection on tool failure).

Implications and Theoretical Extensions

Web2BigTable empirically supports the thesis that large-scale web-to-table extraction is a fundamentally dual-memory search-and-aggregation problem: monolithic, context-limited agents are provably bottlenecked. The results indicate that persistent, modular skill memories, updated by high-level semantic error analysis rather than gradient descent, enable orders of magnitude gains on extraction coverage, reliability, and adaptability.

The architecture generalizes to any structured schema search under open-world information constraints and provides a template for multi-agent, coordination-centric LLM collectives that can be extended to more complex Stackelberg or potential games with rigorous convergence guarantees. The authors propose future work (Memento-Team) to formalize bilevel Stackelberg games with memory-based adaptation, offering theoretical convergence of the system under stochastic reflection and bounded communication.

From a practical standpoint, the memory-banked, script-enhanced, multi-agent paradigm provides an immediately usable blueprint for next-generation agentic systems in enterprise intelligence, scientific discovery, and any domain requiring comprehensive, schema-consistent, verifiable information integration.

Conclusion

Web2BigTable establishes a new empirical upper bound for internet-scale, agentic web search and extraction by integrating self-evolving, memory-driven task decomposition and robust, asynchronously coordinated tool use. The bilevel design—combining orchestrator-level strategy evolution, per-worker skill adaptation, and persistent memory mediation—enables performance unattainable by either monolithic or static multi-agent systems, independent of the underlying LLM backbone. This framework advances the design principles for scalable, verifiable, and self-improving agentic systems, providing direct pathways for future development in both research and applied AI deployment.