InfoSeeker: A Scalable Hierarchical Parallel Agent Framework for Web Information Seeking
InfoSeeker uses Host–Manager–Worker parallelism, reaching 8.38% WideSearch success and 3–5× faster execution.
Key Findings
Methodology
InfoSeeker operationalizes Simon’s near-decomposability through a strategic Host, domain Managers, and tool-using Workers. The Host generates high-level steps; a Manager applies Decomp, dispatches parallel subtasks, validates them with Reflect, and compresses outputs with Aggr. Workers use MCP to perform search, browsing, code, and filesystem actions. Only step-level summaries are returned upward, creating a MapReduce-style control loop.
Key Results
- On WideSearch-en, InfoSeeker obtains 8.38% Avg@4 and 9.50% Max@4 success, exceeding the strongest listed multi-agent baseline, OpenAI o3-high at 5.10% Avg@4. It also reaches 50.13% Row F1 and 70.27% Item F1, indicating gains in both table completeness and attribute correctness.
- On BrowseComp-zh, a 289-question benchmark spanning 11 domains, InfoSeeker achieves 52.9% accuracy. This surpasses OpenAI DeepResearch at 42.9% and BrowseMaster at 46.5%, demonstrating robustness on native Chinese web navigation, multi-hop retrieval, and cross-page evidence alignment.
- Efficiency gains are substantial: relative to OpenAI and Gemini Deep Research, InfoSeeker is 3.3× and 2.6× faster on WideSearch, and 3.9× and 4.6× faster on BrowseComp-zh. In a 20-query study, increasing Workers from 1 to 17 reduces latency from 911 to 162 seconds, a 5.7× speed-up.
Significance
The paper reframes agentic search from merely deeper reasoning to large-scale evidence synthesis. It targets context saturation, cascading errors, and serial latency—persistent obstacles in practical deep research. Academically, it suggests that architectural decomposition can matter more than simply enlarging context windows. Industrially, heterogeneous models and parallel tool use provide a route to faster research systems with controllable cost and modular deployment.
Technical Contribution
The main contribution is a concrete three-level protocol based on near-decomposability. The Host maintains only step–response state; Managers encapsulate decomposition, reflection, and aggregation; Workers retain detailed MCP trajectories locally. Algorithm 1 combines dynamic replanning, strict context isolation, and MapReduce scheduling. This separates reasoning depth from execution width and permits collaboration between heterogeneous Managers, such as Search and Browser Managers, without exposing their internal state to the Host.
Novelty
Compared with ReAct-style systems such as MiroThinker and WebSailor, and with static DAG or tree-parallel methods, InfoSeeker parallelizes the workflow rather than merely model calls. Its distinctive idea is to combine dynamic decomposition, validation, retry, and summary compression with hierarchical context boundaries. The paper does not claim a new search engine or foundation model; its novelty is architectural and orchestration-level.
Limitations
- The system depends on gpt-5.1, gpt-5-mini, Firecrawl, Playwright, and other external APIs. Tool outages, anti-crawling measures, and CAPTCHAs can change outcomes, while robustness across models and concurrency budgets is not fully characterized.
- Parallel Workers increase calls, coordination overhead, and monetary cost: approximately $2 per WideSearch-en task and $1 per BrowseComp-zh task. The weak-coupling assumption may also fail when subtasks require shared, fine-grained state.
Future Work
Future work should investigate adaptive concurrency budgets, cross-Manager resource allocation, trustworthy summary verification, and stronger evidence provenance. More complete ablations, multilingual web tests, tool-failure analysis, and cost–accuracy curves are needed. A promising direction is a scheduler that dynamically chooses serial, parallel, or escalated execution based on dependency structure and uncertainty.
AI Executive Summary
Web search is increasingly a problem of assembling complete evidence from dozens of heterogeneous pages, not merely answering a single question. Existing deep-research agents often rely on long ReAct-style loops, causing context saturation, compounding early errors, and high latency. InfoSeeker treats this as a width-and-coordination problem.
Its architecture contains a strategic Host, domain-specific Managers, and parallel Workers. The Host plans globally; Managers decompose, verify, and aggregate; Workers use MCP-connected search, browser, Python, and filesystem tools. Because the Host receives only concise step-level reports, it avoids absorbing every tool trace. MapReduce-style execution allows weakly coupled investigations to proceed concurrently, while reflection enables revision when evidence is incomplete.
The system reaches 8.38% Avg@4 success and 70.27% Item F1 on WideSearch-en, and 52.9% accuracy on BrowseComp-zh. It is 2.6–4.6× faster than the reported commercial deep-research baselines, and 17 Workers reduce latency from 911 to 162 seconds in a controlled study. The work shows that organizational structure can jointly improve completeness, speed, and scalability, although API dependence, operating cost, and summary-induced information loss remain open challenges.
Deep Analysis
Background
Agentic search evolved from WebGPT, ReAct, and retrieval-augmented generation toward GPT-Researcher, Open Deep Search, and commercial Deep Research. These systems improved multi-hop reasoning, but many still execute long sequential trajectories. WideSearch exposes a complementary demand: exhaustive entity discovery, attribute verification, and schema-compliant synthesis across many sources, requiring controlled context and high execution throughput.
Core Problem
When an agent must aggregate dozens of pages, a monolithic context quickly becomes saturated. Sequential ReAct loops propagate early retrieval mistakes, while fixed workflows struggle with blocked pages, missing evidence, and changing task dependencies. The central challenge is to preserve global planning and verification while expanding execution width without exposing the planner to every intermediate trace.
Innovation
- ��Hierarchical isolation: the Host receives only step-level responses. •Manager autonomy: each domain owns decomposition, reflection, and aggregation. •Workflow-level parallelism: independent subtasks run in Worker pools rather than only parallel token generation. •Dynamic escalation: blocked search can be handed to a Browser Manager. •Heterogeneous scaling: gpt-5.1 plans and gpt-5-mini executes, balancing fidelity and throughput.
Methodology
- ��The Host receives Q and maintains Ĉt=(Q,q0,y0,…,qt−1,yt−1), producing (qt, Manager).
- ��The Manager applies Decomp to create {qk_t} and dispatches them concurrently.
- ��Each Worker uses MCP tools through multi-turn interaction and returns a local result, not its full trace.
- ��Reflect returns accept or revise; revision creates new subtasks when evidence is insufficient.
- ��Aggr compresses accepted results into yt, which updates the Host state.
- ��Sequential time is Tseq=ΣΔ(qk), whereas sufficient parallel capacity yields Tpar≈max Δ(qk), plus coordination overhead.
Experiments
WideSearch-en requires complete structured tables from dozens of sources and reports Success Rate, Row F1, Item F1, Avg@4, and Max@4. BrowseComp-zh contains 289 expert-curated questions across 11 domains and reports final Accuracy. Baselines include OpenAI o3-high, Claude Sonnet 4, Gemini Deep Research, OpenAI DeepResearch, WebSailor, and BrowseMaster. Host and Managers use gpt-5.1; Workers use gpt-5-mini. Tools include Firecrawl, Playwright, Python, and Filesystem.
Results
InfoSeeker achieves 8.38% Avg@4 and 9.50% Max@4 on WideSearch, with 50.13% Row F1 and 70.27% Item F1. On BrowseComp-zh, its 52.9% accuracy exceeds BrowseMaster’s 46.5% and OpenAI DeepResearch’s 42.9%. It is 3.3× and 2.6× faster than OpenAI and Gemini Deep Research on WideSearch, and 3.9× and 4.6× faster on BrowseComp-zh.
Applications
The architecture fits market intelligence, product comparison, literature review, policy monitoring, and multilingual fact checking. Deployment requires reliable search and browsing tools, evidence storage, concurrency controls, and domain-specific Managers. The heterogeneous model design can reduce cost by assigning expensive reasoning to the Host and scalable execution to Workers.
Limitations & Outlook
The framework assumes that tasks can be decomposed into weakly coupled subtasks; gains may fall when entities, attributes, or causal reasoning require shared fine-grained state. External APIs, anti-crawling systems, CAPTCHAs, and irregular Chinese web layouts remain failure sources. The paper reports strong aggregate results and Worker scaling, but limited ablation, error taxonomy, cost curves, and long-term online reliability analysis.
Plain Language Accessible to non-experts
Imagine a huge restaurant research project. You must find every restaurant meeting certain rules, then check each cuisine and address. One person could do it, but the menus are scattered across the internet, notes would overflow, and one early copying mistake could contaminate the final list.
InfoSeeker behaves like a well-run kitchen. The Host is the head chef: it decides the overall sequence but does not read every menu. Managers are station leaders—one handles online search, another handles difficult webpages. Workers are cooks who each investigate a small order. They work at the same time and return cleaned-up findings instead of dumping every messy step on the head chef.
A station leader checks missing or conflicting information and sends a task back when needed. If a site is blocked, the job can move from ordinary search to interactive browsing. Because many jobs happen simultaneously, waiting time is closer to the slowest job than to the sum of all jobs. In the paper, 17 Workers reduce latency from 911 to 162 seconds. The trade-off is more tool calls, coordination, and cost.
ELI14 Explained like you're 14
Suppose your class gets a giant internet assignment: find every restaurant that matches certain rules, then collect each one’s cuisine and address. Doing it alone sounds awful. Your browser fills with tabs, your notes become chaos, and one wrong restaurant name can mess up everything that follows.
InfoSeeker is like a smart class team. The Host is the team captain, deciding what to investigate next. Managers are group leaders who split the big job into smaller missions. Workers are classmates who search sites, open pages, and record facts. They work at the same time, then send short conclusions upward instead of forwarding every confusing tab.
The group leaders also ask, “Is this address real? Did we miss anyone?” If a website blocks normal searching, another group knows how to browse it interactively. That is why more Workers can make the job much faster: 17 Workers took 162 seconds in one study, while one Worker took 911 seconds!
But adding people is not magic. More Workers cost more and can create more coordination problems. The clever part is not simply “use many bots”; it is giving each bot a clear job, checking results, and letting the captain see only useful summaries. That keeps the whole project organized instead of turning it into a giant pile of tabs.
Glossary
Near-decomposability
A complex system can be divided into semi-autonomous modules that interact heavily internally but communicate mainly through high-level summaries. It combines local independence with global coordination.
InfoSeeker uses this principle to define Host, Manager, and Worker boundaries.
Context isolation
Different layers are deliberately restricted to different information scopes, preventing irrelevant traces from filling the model context. It also limits propagation of local errors.
The Host sees only step–response pairs (qt, yt).
MapReduce
A Map phase creates parallel subtasks, while a Reduce phase aggregates their outputs into one result. The pattern is useful for large collections of weakly coupled evidence.
Managers dispatch Workers and compress their results.
Model Context Protocol (MCP)
MCP is a standardized interface for connecting models with external tools. It supports operations such as search, browsing, code execution, and file access.
Workers perform tool interactions through MCP.
Row-level and Item-level F1
Row F1 evaluates entity-level recall and precision in a generated table; Item F1 evaluates attribute correctness within matched entities. They measure structural completeness and fine-grained factual quality.
WideSearch uses both metrics alongside strict Success Rate.
Open Questions Unanswered questions from this research
- 1 Does parallel decomposition harm quality when subtasks are strongly dependent? A dependency-aware controller is needed to choose serial, parallel, or merged execution dynamically.
- 2 Can summaries hide counterexamples or critical evidence? Future systems need citation-level verification, contradiction detection, and calibrated uncertainty.
- 3 What is the optimal Worker pool under changing API prices, rate limits, and failure rates? The current study does not provide a complete cost–accuracy model.
Applications
Immediate Applications
Market and product intelligence
Companies can use a Search Manager to collect competitor prices, specifications, reviews, and channels in parallel, then validate duplicate entities and produce structured tables. Required components include compliant web access, evidence storage, and concurrency controls.
Multilingual fact checking
Newsrooms and research teams can use a Browser Manager for Chinese or mixed-language websites. Multiple Workers cross-check pages and archives, while the Host produces a concise report linked to verified evidence.
Long-term Vision
A scalable research-agent platform
Specialized legal, medical, financial, and scientific Managers could be added without changing Host logic. With reliable citations, governance, and cost control, the architecture could become infrastructure for enterprise-scale deep research.
Abstract
Recent agentic search systems have made substantial progress by emphasising deep, multi-step reasoning. However, this focus often overlooks the challenges of wide-scale information synthesis, where agents must aggregate large volumes of heterogeneous evidence across many sources. As a result, most existing large language model agent systems face severe limitations in data-intensive settings, including context saturation, cascading error propagation, and high end-to-end latency. To address these challenges, we present \framework, a hierarchical framework based on principle of near-decomposability, containing a strategic \textit{Host}, multiple \textit{Managers} and parallel \textit{Workers}. By leveraging aggregation and reflection mechanisms at the Manager layer, our framework enforces strict context isolation to prevent saturation and error propagation. Simultaneously, the parallelism in worker layer accelerates the speed of overall task execution, mitigating the significant latency. Our evaluation on two complementary benchmarks demonstrates both efficiency ($ 3-5 \times$ speed-up) and effectiveness, achieving a $8.4\%$ success rate on WideSearch-en and $52.9\%$ accuracy on BrowseComp-zh. The code is released at https://github.com/agent-on-the-fly/InfoSeeker