Skip to content

WebSwarm: Recursive Multi-Agent Orchestration for Deep-and-Wide Web Search

🕒 Published (v1): 2026-07-09 16:28 UTC · Source: Arxiv · link

Why this paper was selected

Recursive multi-agent orchestration for deep-wide search; canonical meta-harness decomposition pattern

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

WebSwarm is a recursive multi-agent orchestration framework for complex web search that dynamically constructs a delegation tree during inference rather than committing to a fixed decomposition plan upfront. Each node in the tree couples a local objective with one of four search modes (atom, deep, wide, entity_collect) and can spawn, delegate to, and receive evidence from child nodes. It outperforms ReAct single-agent and five multi-agent baselines across four benchmarks covering deep, wide, and interleaved search tasks.

Problem

Single ReAct-style agents cannot simultaneously handle search depth (multi-hop dependency resolution) and width (broad entity/attribute coverage) due to context limits and long trajectories. Existing multi-agent systems address coverage via parallel execution but fail on three axes: (1) shallow recursive depth — decomposition stops at the root level; (2) fixed collaboration mode — one global strategy regardless of local subtask type; (3) weak evidence-grounding — task splitting follows query surface semantics rather than actual web information structure, causing redundant retrieval or wrong expansion dimensions.

Method

WebSwarm builds a recursive delegation tree \(T = (V, E)\) at inference time. The root node receives the original query \(q_0\); each node \(v\) holds a local objective \(q_v\) and a search mode \(m_v \in \{\text{atom}, \text{deep}, \text{wide}, \text{entity\_collect}\}\):

  • atom: direct ReAct tool-calling for narrow fact lookups.
  • deep: serial searcher→verifier chain for unknown-target identification under multi-constraint reasoning.
  • wide: parallel divide-and-conquer over known entities/dimensions; children can themselves be deep/wide/entity_collect, enabling nesting.
  • entity_collect: multi-path parallel recall + dedup + verification for open-set enumeration.

A node either solves locally or generates child delegations \(C_v = \{(q_i, m_i)\}\) (objective–mode pairs). Children return results \(r_i\) upward; the parent updates \(R_v \leftarrow R_v \cup \{r_i\}\) and decides to expand further, revise, or aggregate: \(r_v = \text{Aggregate}(q_v, R_v)\).

Two guiding signals prevent blind delegation: 1. Web-Probing Agent — before wide expansion, performs lightweight search to produce a structural hint \(h_v = \text{WebProbing}(q_v)\) summarizing whether evidence is concentrated (few hub pages) or dispersed along an organizational axis (time, entity, event). Delegation is then conditioned on \(h_v\): \(C_v = \text{Delegate}(q_v, m_v, R_v, h_v)\). 2. Experience transfer — for batches of homogeneous sibling nodes, a small scout subset \(C_v^s\) executes first; trajectories \(\tau_i\) are distilled into experience \(k_v = \text{ExtractExperience}(\{\tau_i\})\) (reliable sources, query patterns, invalid paths), which is injected into remaining siblings' solving context.

Backbone: GLM-4.5; 200 max action steps; 2 scout nodes; 3 parallel paths for entity_collect.

Key Contributions

  • Progressive recursive delegation framework: instantiates objective–mode pairs dynamically as evidence accumulates rather than from a static upfront plan.
  • Four typed search modes that map local subtask bottlenecks to distinct collaboration protocols, composable across tree levels.
  • Web-structure-guided expansion: lightweight probing agent grounds decomposition dimension in observed web organization, not just query surface semantics.
  • Within-instance experience transfer across homogeneous sibling nodes without cross-instance leakage.
  • Empirical evaluation on four benchmarks (BrowseComp-Plus, WideSearch, DeepWideSearch, GISA) demonstrating consistent gains over six baselines.

Results

All gains below are WebSwarm (GLM-4.5) vs. ReAct (GLM-4.5) unless noted:

  • BrowseComp-Plus (deep): ACC 68.00 vs. 50.50 (+17.50 pts); beats strongest multi-agent baseline by +3.50 pts.
  • WideSearch-EN (wide): SR 7.00 vs. 4.00 (+3.00); Item F1 74.37 vs. 64.61 (+9.76); Row F1 44.14 vs. 33.23 (+10.91).
  • DeepWideSearch-EN (deep+wide): SR 6.58 vs. 3.95 (+2.63); Item F1 58.40 vs. 46.63 (+11.77); Row F1 29.64 vs. 20.08 (+9.56).
  • GISA (general): Overall 62.30 vs. 55.54 (+6.76); Item +13.64, Set +9.76, List +15.46, Table +3.91.
  • WebSwarm with GLM-4.5 matches or exceeds ReAct with Kimi-K2 and Qwen3-235B-A22B-2507 on most metrics, despite weaker backbone.

Limitations

  • Evaluation samples from BrowseComp-Plus (200) and English-only subsets of WideSearch/DeepWideSearch — full-set and multilingual generalization not demonstrated.
  • Recursive delegation depth and the number of scout nodes are fixed hyperparameters; no adaptive budget control is described.
  • Web-Probing Agent adds latency and API cost before every wide expansion; cost-accuracy tradeoff is not systematically characterized.
  • Experience transfer is intra-instance only; useful cross-task knowledge is deliberately excluded, which may limit efficiency on repetitive task families.
  • Backbone is GLM-4.5; generalization experiments to other models are included but limited in scope.
  • Success rate (SR) remains low across all methods on table-output tasks (≤7%), suggesting the structured aggregation problem is far from solved.

Relevance to Harnesses / Meta-Harnesses

WebSwarm is a direct instance of a meta-harness: it is a framework whose primary job is to dynamically construct, route, and coordinate other agents rather than to solve tasks directly. The recursive delegation tree, typed node modes, and top-down/bottom-up feedback loop are all harness-level control structures that operate above the individual tool-calling agents. The Web-Probing Agent and experience-transfer mechanism are meta-harness components that inform orchestration policy at runtime — analogous to how a meta-harness might probe environment state or reuse prior run artifacts to guide sub-agent dispatch. The paper's decomposition of "how to orchestrate" (meta-level) from "how to search" (agent-level) is a clean architectural pattern relevant to anyone designing harnesses that must adapt their topology to task evidence rather than committing to a static pipeline.