You're researching a complex question: "Which EV makers adopted 800V high-voltage platforms in 2024, and who are their respective suppliers?"
With traditional search, you might first search "2024 800V EV makers" to get a list of brands, then search each brand for suppliers. By the third brand you discover some suppliers are also chip vendors, so you open a new thread to investigate their other customers. Soon you're lost—which brands you've checked, which suppliers are unverified, which threads intersect.
This is exactly the dilemma facing current LLM search agents. A single ReAct-style agent (one that loops through "think-act-observe") is constrained by a long trajectory and a limited context window, forgetting earlier findings as the search progresses. Existing multi-agent systems can search in parallel, but they typically decompose the task once at the root and never adjust—while in real searches, new evidence keeps spawning new subtasks and dependencies.
WebSwarm's core idea: Recursive delegation + progressive decomposition
WebSwarm, from Renmin University and Kuaishou (arXiv:2607.08662), organizes the search process as a dynamically growing "task tree." Each node contains two parts: a local objective and a search mode. A node can either solve its goal itself or spawn child nodes.
It's like how you'd work on the EV question: one node gathers the brand list (wide search), then each brand gets a child node to find suppliers (deep search); when a child discovers a supplier is also a chip vendor, it spawns an even deeper node to look up that vendor's technical details. As each level resolves, evidence flows back up, and parent nodes decide whether to expand, revise, or aggregate.
WebSwarm has two key guiding mechanisms:
1. Web-Structure Probing
Before formally expanding the search, WebSwarm runs a lightweight probe of how task-relevant information is organized on the web. For "800V platform" queries, probing might reveal information structured as "brand → model → supplier → tech specs." This structural information guides subsequent 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 for 10 brands), the effective search strategy discovered by the first child is reused by later siblings—like summarizing a workflow ("check official spec pages → industry reports → supplier news") after the first brand and applying it to the rest.
Results: dominant performance on hard tasks
WebSwarm was tested on four benchmarks: BrowseComp-Plus (deep search), WideSearch (wide search), DeepWideSearch (interleaved deep+wide), and GISA (general information seeking).
Key numbers:
- Deep search (BrowseComp-Plus): +17.50 accuracy points over ReAct; +3.50 points 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.
Two findings from ablations
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 per-node solution quality.
Cross-model generalization
WebSwarm is model-agnostic. With weaker models, recursive delegation provides extra structure to support long-horizon search; with stronger models, mode-guided node solving unlocks more of the model's capability. The framework's value doesn't depend on the underlying model's strength.
Limitations and outlook
The paper candidly notes limits: it only addresses inference-time multi-agent orchestration, not data construction or training; search cost (tool-call count) grows with recursion depth; and it currently targets information-seeking tasks, not yet more complex tool-use scenarios.
Author's take
What I appreciate most about WebSwarm is its "progressive" philosophy. Most multi-agent systems make one grand decomposition at the start, then execute rigidly. But the essence of real search is "learning what else to search as you search"—information needs emerge dynamically. WebSwarm formalizes this intuition into a growing tree, with Web-Structure Probing and Experience Reuse as reins to control its growth and prevent it from becoming weeds.
More broadly, this answers an important engineering question: when should you use multi-agent systems? The answer isn't "when the task is big," but "when the task's needs change with intermediate results." If your task can be fully specified upfront, a single agent with a good prompt suffices. But if your task, like deep research, requires improvising along the way, 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