WebSwarm: Making Search Agents Divide Work Recursively Like a Swarm

Imagine researching this complex question: "Which EV makers adopted 800V high-voltage platforms in 2024, and who are their suppliers?"

With traditional search, you might first search for a list of brands, then search each brand's suppliers one by one. At the third brand, you notice some suppliers are also chip vendors—so you open a new thread to investigate their other customers. Soon you're lost: which brands have you checked, which suppliers remain unverified, and how do the threads intersect?

This is exactly the predicament of current LLM search agents. A single ReAct-style agent (the "think–act–observe" loop type) is constrained by one long trajectory and a limited context window—it forgets earlier findings as the search continues. Existing multi-agent systems can search in parallel, but usually decompose the task once at the root and never revise it—while in real search, new evidence constantly spawns new subtasks and dependencies.

Core Idea: Recursive Delegation + Progressive Decomposition

WebSwarm, from a Renmin University and Kuaishou team (arXiv:2607.08662), organizes search as a dynamically growing task tree. Each node contains a local objective and a search mode. A node can solve its goal itself or spawn child nodes.

This mirrors how you'd work on the EV supplier question: first dispatch a node to collect brand names (wide search), then spawn a child per brand to find suppliers (deep search); if a child discovers a supplier is also a chip vendor, it spawns an even deeper node for that vendor's technical details. Evidence flows back up, and parents decide whether to expand, revise, or aggregate.

WebSwarm has two key guidance mechanisms:

1. Web-Structure Probing

Before formally expanding the search, WebSwarm runs a lightweight probe to see how task-relevant information is organized on the web. For "800V platform" queries, probing might reveal a hierarchy like "brand → model → supplier → technical specs." This structural information guides node expansion and avoids blind growth.

2. Experience Reuse

When a wide-search node spawns a batch of homogeneous child nodes (e.g., one supplier lookup per brand), the effective search strategy discovered by the first child is reused for subsequent siblings—like distilling "check the official tech-spec page → industry reports → supplier news" after the first brand and applying it to the rest.

Results: Crushing Performance on Hard Tasks

WebSwarm was tested on four benchmarks: BrowseComp-Plus (deep search), WideSearch (wide search), DeepWideSearch (interleaved deep+wide), and GISA (comprehensive information seeking).

Key numbers:

• Deep search (BrowseComp-Plus): +17.50 accuracy points over ReAct, +3.50 over the strongest multi-agent baseline.
• Wide search (WideSearch-EN): Row F1 +10.91, Item F1 +9.76.
• Deep+wide interleaved (DeepWideSearch-EN): Row F1 +9.56, Item F1 +11.77.

The hard-task results are most striking. On difficult samples where ReAct scores 0.0%, WebSwarm reaches 35.7%; on WideSearch-EN's hard subset, it improves from 24.5 to 55.8. Recursive delegation isn't icing on the cake for easy tasks—it's rescue for hard ones.

Two Ablation Findings

• Removing Web-Structure Probing degrades search efficiency—more redundant and misaligned node expansions.
• Removing Experience Reuse lowers Item F1—sibling nodes become less reliable.

The two are complementary: the former cuts exploration cost, the latter improves node-solving quality.

Cross-Model Generalization

WebSwarm is model-agnostic. With weaker models, recursive delegation provides extra structural scaffolding for long-horizon search; with stronger models, mode-guided node solving better exploits the model's capability. The framework's value doesn't depend on the underlying model's strength.

Limitations and Outlook

The paper candidly notes several limitations: it only addresses inference-time multi-agent orchestration (no data construction or training); search cost (tool calls) grows with recursion depth; and it currently targets information-seeking tasks, not yet more complex tool-use scenarios.

Takeaway

What's most appealing about WebSwarm is its progressive philosophy. Most multi-agent systems do one grand decomposition at the start, then execute rigidly. But the essence of real search is "learning what else to search while searching"—information needs emerge dynamically. WebSwarm formalizes this intuition into a growing tree, and uses web-structure probing and experience reuse as two reins to control growth direction.

From a broader engineering perspective, this answers a key question: when should you use multi-agent systems? The answer isn't "the task is big," but "the task's requirements change with intermediate results." If you can write a fixed SOP upfront, a single agent with a good prompt suffices. If your task, like deep research, requires "figuring it out as you go," a recursive delegation framework is worth the cost.

---

Paper: https://arxiv.org/abs/2607.08662 HTML full text: https://arxiv.org/html/2607.08662 Open-source code: https://github.com/songxiaoshuai/WebSwarm