WideSeek: Advancing Wide Research via Multi-Agent Scaling

🍞 Top Bread (Hook): You know how for a school report you might need to list every volcano in a region, with their heights, locations, and eruption dates—following rules like “only active ones” and “not in this country”? That’s more than finding one fact; it’s gathering many facts under rules and putting them into a neat table.

🥬 Filling (The Actual Concept): Wide Research

• What it is: Wide Research is when an AI collects lots of related information across many sources at once, following complex rules, and organizes it completely (often into a table).
• How it works: 1) Break a big, rule-heavy request into smaller searches. 2) Run many searches in parallel. 3) Cross-check and combine answers. 4) Make sure the table covers everything (high recall) and is correct (high precision). 5) Deliver one clean summary.
• Why it matters: Without Wide Research, an AI might miss items or leave empty cells, like turning in a half-filled science chart.

🍞 Bottom Bread (Anchor): Imagine building a “Top 100 QS-ranked universities in China (2024)” table with columns for city, website, motto, and postal code. Wide Research is what helps the AI find all the right schools and fill every column.

🍞 Top Bread (Hook): Imagine a giant museum map where every painting, artist, and year is connected with strings. You can point to a spot and say, “Show me all works by these artists, except those painted after 1950.”

🥬 Filling (The Actual Concept): Knowledge Graphs

• What it is: A Knowledge Graph is a huge web of facts that connect things (entities) by relationships (edges), like “University—located in—China.”
• How it works: 1) Store entities (people, places, journals). 2) Link them with properties (founded in, ranked, located in). 3) Ask structured questions (queries) to fetch matching sets. 4) Pull attributes to fill table columns.
• Why it matters: Without a structured map, finding broad, related facts becomes slow and messy, like searching the whole internet without categories.

🍞 Bottom Bread (Anchor): To find “lakes in the Northwest Territories that don’t flow into the Buffalo River,” a Knowledge Graph lets the AI filter by location, then subtract any lake with that outflow.

🍞 Top Bread (Hook): Picture sorting your sticker collection with rules like “keep all animals OR all space stickers, but NOT any torn ones.”

🥬 Filling (The Actual Concept): Set Operators (AND/OR/NOT)

• What it is: These are logical building blocks to include (AND), choose among (OR), or exclude (NOT) items in a set.
• How it works: 1) Start with a big pile of possible items. 2) AND keeps only items that match all rules. 3) OR keeps items that match at least one rule. 4) NOT removes items matching a rule.
• Why it matters: Without these, you can’t express rich, real-world constraints like union, intersection, and differences.

🍞 Bottom Bread (Anchor): “Universities located in China AND QS rank ≤ 100” uses AND; “airports in Crete OR owned by Greece” uses OR; “games nominated for Most Anticipated BUT NOT GRAC 15+” uses NOT.

🍞 Top Bread (Hook): Imagine a team project where one kid plans tasks and many teammates collect pieces at the same time.

🥬 Filling (The Actual Concept): Multi-Agent Systems (Planner–Executor)

• What it is: Many cooperating AIs where a main planner splits work and helper agents execute searches in parallel.
• How it works: 1) Planner reads the big goal. 2) Planner creates sub-tasks. 3) Sub-agents use tools (search, open page) to fetch facts. 4) Results are checked and merged. 5) Repeat until complete.
• Why it matters: Without a team, one agent gets overwhelmed by long, complex tasks and misses items.

🍞 Bottom Bread (Anchor): To build a competitor analysis table for 50 companies, the planner spawns 50 helpers—each gathers facts for one company—then the planner merges them into one sheet.

🍞 Top Bread (Hook): Think of a video game where you try strategies, get points for good moves, and learn to do better next round.

🥬 Filling (The Actual Concept): Reinforcement Learning (RL)

• What it is: A way for AI to learn by trial and error using rewards for good outcomes and penalties for mistakes.
• How it works: 1) AI acts. 2) Gets a score (reward). 3) Adjusts its policy to get higher future scores. 4) Repeats many times.
• Why it matters: Without RL, the AI doesn’t systematically improve at complex multi-step tasks.

🍞 Bottom Bread (Anchor): If the final table has more correct cells, the AI gets a higher reward and learns that spawning more helpers or using better tools was a good idea.

The world before: Most research agents did Deep Research—long, careful chains to find one hard nugget (like the source of a single quote). That’s great for depth but weak for breadth—when you need hundreds or thousands of cells filled reliably. Benchmarks were often small and hand-made, training data was scarce, and most systems used fixed roles and a fixed number of agents.

The problem: Real jobs—like enterprise analytics, code repository mining, or building policy inventories—need Wide Research: huge recall under complex constraints, parallel browsing, robust cross-checks, and clean tables. Three blockers appeared: (1) No good breadth-focused benchmarks with training data; (2) Data synthesis methods optimized “depth” (paths) not “width” (complete sets); (3) Optimization didn’t train a whole multi-agent system end-to-end to broaden search paths.

Failed attempts: Static multi-agent scripts with pre-set roles often became rigid. Path-based synthetic datasets improved step-by-step reasoning but didn’t teach high-recall table building. Closed-source orchestration showed promise but didn’t co-train executors. Single-agent RL made deeper thinkers, not wider collectors.

The gap: We needed (a) a breadth-first benchmark with complex set logic and many domains, plus training splits; and (b) a flexible team architecture that can create as many helpers as needed and learn, as a whole, how to spread out and gather everything.

Real stakes: In daily life, this means complete shopping comparisons, thorough school project tables, safer infrastructure audits, fuller medical literature summaries, and faster, more accurate business reports. Missing even a few rows or columns can lead to bad decisions—like hiring the wrong vendor or citing incomplete science.

🍞 Top Bread (Hook): Imagine a head chef who can call in as many cooks as needed, all at once, to prepare a giant buffet—then tastes everything, fixes mistakes, and serves a perfect spread.

🥬 Filling (The Actual Concept): The Aha! Moment

• What it is: Treat wide info-seeking as set-building and table-filling, and train a planner that can spin up any number of helper agents in parallel, then optimize the entire team end-to-end using one shared reward.
• How it works: 1) Build a breadth-focused benchmark (WideSeekBench) using Knowledge Graphs and logical set rules. 2) Use a main planner to fork dynamic sub-agents. 3) Flatten everyone’s actions into one long trajectory. 4) Score the final table for correctness (Item F1) and penalize bad tool use. 5) Update the shared policy with GRPO so the team learns to scale smartly.
• Why it matters: Without dynamic spawning and team training, “more agents” looks busy but stays clumsy—like too many cooks without a plan.

🍞 Bottom Bread (Anchor): When asked for “all Chinese universities in QS Top 100 (2024) with city, website, motto, postal code,” the planner creates dozens of helpers, each grabs one school’s facts, and the planner assembles a complete, accurate table.

Multiple Analogies:

• Factory line: A foreman (planner) splits a big order into stations (sub-agents); products (rows) move in parallel; quality control (reward) keeps everyone aligned.
• Field trip: A teacher (planner) assigns groups to different exhibits; all groups return with notes that become a full class report.
• Newsroom: An editor (planner) sends reporters (sub-agents) to cover parts of a story; they file reports that become a comprehensive article.

Before vs After:

• Before: Single agent, long chains, often misses items; static teams with fixed roles; training focused on depth.
• After: Dynamic planner spawns as many helpers as needed; parallel search raises recall; whole team trained together; breadth-first benchmark to measure progress.

🍞 Top Bread (Hook): You know how a relay team wins when each runner knows exactly when to sprint and pass the baton?

🥬 Filling (The Actual Concept): Unified Trajectory and GRPO

• What it is: Turn the planner’s and all helpers’ steps into one story (a unified trajectory) and train with Group Relative Policy Optimization so credit/blame is shared fairly.
• How it works: 1) Interleave planner steps with each sub-agent’s mini-journey. 2) Give one global reward (more correct cells, fewer format/tool errors). 3) Normalize rewards across a group of sampled runs (GRPO) to stabilize learning. 4) Update the single shared model so both planner decisions and helper actions improve.
• Why it matters: Without a single story and group-based credit, you can’t teach who did what well when many agents act in parallel.

🍞 Bottom Bread (Anchor): If the final table improves when the planner creates three helpers instead of one—and those helpers make valid tool calls—the shared policy learns “three is better here” and repeats that move next time.

🍞 Top Bread (Hook): Think of sorting lots of puzzle pieces by using the box picture and simple rules like “edges first,” “blue sky parts together,” and “not these shapes.”

🥬 Filling (The Actual Concept): WideSeekBench (GBIS Benchmark)

• What it is: A 5,156-task benchmark for General Broad Information Seeking built from a Knowledge Graph with AND/OR/NOT constraints and diverse domains.
• How it works: 1) Sample seed entities by domain. 2) Compose logical constraints (AND/OR/NOT). 3) Retrieve target sets. 4) Select attributes with good coverage and diversity. 5) Generate human-like task prompts and column-wise rubrics. 6) Apply rule, LLM, and human filters for quality. 7) Provide a simulated environment for fair testing.
• Why it matters: Without a clean, scalable yardstick focused on breadth, you can’t meaningfully train or compare wide-search agents.

🍞 Bottom Bread (Anchor): Tasks include things like “television series that meet condition A OR B, excluding C, with columns for broadcaster, dates, seasons, episodes,” so agents must fill many rows and columns correctly.

Why it works (intuition):

• Parallel decomposition naturally matches OR-type breadth; dynamic spawning handles uneven workloads; set logic makes constraints clear; a single shared policy with unified reward makes credit assignment feasible; and column-wise rubrics keep evaluation fair across messy web formats.

Building Blocks (as mini-sandwiches):

• 🍞 Hook: Ever wish you could ask for “as many helpers as it actually takes” instead of guessing? 🥬 Concept: Dynamic Sub-Agents let the planner create k helpers on demand. They use tools and report back. Why it matters: Fixing k too small = missed items; too big = wasted steps. 🍞 Anchor: Big tables (e.g., 500+ cells) trigger more helpers; small ones use fewer.
• 🍞 Hook: Imagine getting graded on the finished poster, not each brushstroke. 🥬 Concept: Item F1 Reward scores how many table cells match ground truth, plus a penalty for tool/format errors. Why it matters: Encourages both completeness and clean execution. 🍞 Anchor: A table with many correct values but broken tool calls gets a lower score than a clean, equally correct one.
• 🍞 Hook: Think of warm-up exercises before the big game. 🥬 Concept: Supervised Fine-Tuning (Cold Start) uses teacher trajectories to teach good habits before RL. Why it matters: Starting from zero can wander; SFT points RL in the right direction. 🍞 Anchor: After SFT, the planner already knows when to split tasks and how to call tools politely.

At a high level: Input task (Q, A) → Planner reads query and history → [Step A] Decide to spawn k sub-agents or continue → [Step B] Sub-agents search/open pages and return sub-results → Planner aggregates, cross-checks, and iterates → Output final table T_ans. For training: Collect all steps → Linearize into one trajectory → Compute reward (Item F1 − format penalty) → GRPO update of the shared policy.

Step-by-step, like a recipe:

🍞 Top Bread (Hook): Imagine organizing a scavenger hunt where the leader decides how many friends to send out and where.

🥬 Filling (The Actual Concept): Step 1 — Planner Reads and Plans (Planner–Executor)

• What happens: The main agent (planner) sees Q (the natural-language request) and A (desired columns), recalls prior steps, and chooses an action: (a) create_sub_agent with k sub-tasks, or (b) finish and output.
• Why this exists: Without a planner, helpers don’t know what to do; without a finish option, the team never stops.
• Example: Query: “Find all Chinese universities ranked ≤100 (QS 2024); give name, city, website, motto, postal code.” The planner proposes k sub-agents, each to fetch one or a few universities.

🍞 Bottom Bread (Anchor): The planner writes small task notes like “Find Tsinghua: city, postal code, motto,” and hands them out.

🍞 Top Bread (Hook): Think of teammates each checking different shelves in a giant library at the same time.

🥬 Filling (The Actual Concept): Step 2 — Sub-Agents Execute with Tools

• What happens: Each sub-agent runs its own mini-journey: calls search, opens pages, extracts values, and composes a sub-result.
• Why this exists: Parallel work speeds up gathering and raises recall; tool use is how agents talk to the web-like environment.
• Example: A sub-agent searches “Tsinghua motto,” opens the official site, confirms city=Beijing, pulls postal code, returns a neat snippet.

🍞 Bottom Bread (Anchor): Ten helpers return with ten rows’ worth of facts; the planner starts building the table.

🍞 Top Bread (Hook): Imagine the leader pinning everyone’s notes to a big board to spot duplicates or gaps.

🥬 Filling (The Actual Concept): Step 3 — Aggregate, Cross-Validate, and Iterate

• What happens: The planner merges sub-results, removes duplicates, fills missing cells by spawning more helpers if needed, and ensures constraints (AND/OR/NOT) are satisfied.
• Why this exists: Without aggregation and checks, tables stay messy or incomplete.
• Example: If a row is missing “motto,” the planner sends a targeted helper to fetch just that missing value.

🍞 Bottom Bread (Anchor): The final board becomes a clean table with every required column filled where possible.

🍞 Top Bread (Hook): Before a big game, teams practice with drills and scoreboards to see what works.

🥬 Filling (The Actual Concept): Step 4 — Build the Training Playground (WideSeekBench)

• What happens: Use a Knowledge Graph to synthesize tasks: sample domains and entities; compose AND/OR/NOT constraints; retrieve target sets; pick attributes with enough coverage/diversity; create user-friendly prompts and per-column rubrics; filter via rules, LLM, and humans; offer a simulated environment (local docs + local search) for fair evaluation.
• Why this exists: Without data, you can’t train or test; without rubrics, you can’t score fairly across formats.
• Example: “Television series that are either sci-fi set on an island OR followed by ‘Ashes to Ashes,’ with columns for broadcaster, start/end date, seasons, episodes.”

🍞 Bottom Bread (Anchor): The benchmark delivers ground-truth tables to compare against and realistic prompts to solve.

🍞 Top Bread (Hook): Think of turning many walkie-talkie chats into one mission log to learn from later.

🥬 Filling (The Actual Concept): Step 5 — Linearize the Whole Team’s Steps (Unified Trajectory)

• What happens: Interleave planner turns with each sub-agent’s full mini-journey from that turn, creating one long sequence.
• Why this exists: Training needs a single chain to compute gradients and assign credit.
• Example: [Plan step t] → [Sub-agent 1: search→open→note] [Sub-agent 2: search→open→note] → [Next plan step] … → [Final answer]

🍞 Bottom Bread (Anchor): The mission log captures who did what, so learning can reward good moves and discourage bad ones.

🍞 Top Bread (Hook): Like grading the finished poster but also docking points for glue spills.

🥬 Filling (The Actual Concept): Step 6 — Compute Reward (Item F1 − Tool/Format Penalty)

• What happens: Compare final table T_ans to ground truth T* using Item F1 (cell-level match). Subtract a penalty based on invalid tool calls or format errors.
• Why this exists: Encourages completeness and careful execution.
• Example: If most cells match but the agent made many broken tool calls, the reward drops.

🍞 Bottom Bread (Anchor): Agents learn to both fill more cells and avoid sloppy tool use.

🍞 Top Bread (Hook): Think of team drills where everyone improves together, not just one star player.

🥬 Filling (The Actual Concept): Step 7 — Update Policy with GRPO (Group-Based RL)

• What happens: Sample several trajectories per query, compute group-relative advantages (how good each run is vs the group), and update the shared model so planner and executors co-improve.
• Why this exists: Normalizing within a group stabilizes learning when many actions happen in parallel.
• Example: Runs with more correct cells and clean tools get higher relative scores, nudging the policy toward those behaviors.

🍞 Bottom Bread (Anchor): Next time, the planner is more likely to spawn the “right number” of helpers and the helpers use tools more reliably.

The secret sauce:

• Dynamic sub-agents: The planner isn’t stuck with a fixed number; it scales up or down per task.
• Unified trajectory + GRPO: One story and group-relative credit make parallel training stable.
• Column-wise rubrics: Fair evaluation across messy web formats (aliases, dates, numbers, sets).
• KG-driven data pipeline: Teaches true breadth (set logic over large spaces), not just deep paths.

Concrete data example (mini):

• Input: “Find all lakes in the Northwest Territories, country=Canada, NOT outflow=Buffalo River. Columns: lake, elevation, coordinates, country.”
• Agents: Planner spawns helpers per lake; helpers fetch elevation and coordinates; planner filters out excluded lakes; final table matches the ground truth rows and cells.

🍞 Top Bread (Hook): Imagine a giant spelling bee where contestants must not just spell one word but correctly fill a whole dictionary page—fast and under rules.

🥬 Filling (The Actual Concept): The Tests and Why

• What they measured: Success Rate (complete pass), Row F1 (row-level overlap), and Item F1 (cell-level correctness). Item F1 is the main scoreboard because it reflects how many cells match ground truth.
• Why these matter: Wide tasks need completeness and correctness across many cells; a single right fact isn’t enough.

🍞 Bottom Bread (Anchor): A high Item F1 is like getting most answers in a giant table right, not just one question.

The competition:

• Proprietary models (e.g., GPT-5.2, DeepSeek-v3.2) and open-source models (Qwen3) were tested on WideSeekBench.
• The authors fine-tuned a Qwen3-8B base into several variants: WideSeek-8B-SFT (supervised), WideSeek-8B-RL (RL from scratch), and WideSeek-8B-SFT-RL (SFT then RL).

Scoreboard with context:

• On WideSeekBench, frontier proprietary models still struggle: GPT-5.2 Mean@4 Item F1 ≈ 21%, showing that broad info-seeking is hard even for strong systems.
• Open-source base models start low, but WideSeek training helps a lot. For example, SFT and RL greatly increase tool calls (up to ~29×) and sub-agent creation (up to ~6×) versus the 8B base, and lift Item F1 (e.g., SFT-RL ≈ 12.9%, +5.5 points over the base in this setting).
• Think of it like going from “barely finding anything” to “filling a noticeable chunk of the table,” while learning to use many more, better-organized helpers.

Generalization to Deep Research:

• On BrowseComp-Plus (a deep, step-by-step browsing task), the WideSeek scaffold helps the small model: a Qwen3-8B with WideSeek planning (≈14.2%) beats a larger 32B model using older ReAct planning (≈10.7%). With RL training on WideSeekBench, the WideSeek-8B-RL reaches ≈26.4% accuracy, showing skills transfer from wide to deep tasks.

Surprising findings:

• More hands isn’t automatically better: Proprietary models often spawned many sub-agents and made many tool calls but still had modest Item F1. Coordination and training matter.
• OR is easier than NOT: OR naturally splits into parallel sub-queries; NOT (set difference) demands careful exclusion and is a current bottleneck.
• Early stopping bias: Models distilled from teachers sometimes “give up” on massive tables; RL-from-scratch scaled tool use with volume more steadily, suggesting it learned to keep searching.

Volume and domains:

• As table size grows (e.g., [128, 4096] cells), everyone’s performance drops, confirming extreme breadth is very challenging.
• Across 18 domains, the trained WideSeek variants consistently beat their own baselines, indicating robust gains in coordination and recall.

Takeaway:

• Even strong models need specialized training to do Wide Research well. Dynamic multi-agent scaling plus unified RL makes a smaller open model much more capable and competitive in both wide and deep scenarios.

Limitations:

• Model size ceiling: Using an 8B base caps complex reasoning; larger backbones might lift Item F1 further.
• Hard NOT logic: Set difference (exclusions) remains a stumbling block; small mistakes there sink whole rows.
• Sparse/global reward: Scoring only at the end (with penalties) makes credit assignment tricky; more granular shaping could help.
• Simulated environment: While fair and reproducible, it’s not the wild web; real-world performance may vary with noisy pages and shifting facts.
• Distillation bias: SFT from frontier teachers sometimes bakes in refusal/early stopping on huge tasks, limiting breadth.

Required resources:

• Compute for SFT + RL (multi-rollouts, GRPO updates), plus memory for long unified trajectories.
• A tool-use sandbox (search/open) and the simulated corpus; optionally a local SPARQL/Knowledge Graph server for data work.
• Logging/monitoring to track sub-agent counts, tool calls, and reward trends.

When NOT to use:

• Tiny lookups or one-off questions (a simple search is faster).
• Ultra-low latency scenarios where spawning many agents is too slow or costly.
• Rapidly changing facts (e.g., “current CEO right now”) unless time anchoring and frequent refresh are added.
• Highly subjective tasks (opinions) that don’t map to structured tables and rubrics.

Open questions:

• Better credit assignment: Can we add intermediate, per-column rewards or self-checkpoints to guide learning earlier?
• Smarter NOT: How can agents robustly execute set differences across messy, conflicting sources?
• Dynamic stopping: When is “enough” enough—can the planner learn confidence-based halting per column/row?
• Communication: Would lightweight inter-agent messaging (beyond planner merges) boost de-dup and coverage?
• Cost-quality tradeoffs: What’s the optimal curve of sub-agent count and tool calls vs marginal Item F1 gains?
• Safety and truthfulness: How to reduce subtle hallucinations while maintaining recall at scale?

3-sentence summary: This paper reframes broad information gathering as set-based table building and introduces WideSeek, a dynamic multi-agent system that spawns helpers as needed and trains the whole team end-to-end. It also delivers WideSeekBench, a rigorous, breadth-first benchmark with logical constraints and per-column rubrics to fairly evaluate wide search. Experiments show that coordinated multi-agent scaling plus GRPO-based RL significantly improves an 8B model’s breadth skills and even transfers to deep tasks.

Main achievement: Showing that “scaling the number of agents” works only when the planner and executors are co-optimized via a unified trajectory and group-relative reinforcement learning—and providing the benchmark and recipe to do it.

Future directions: Train larger backbones; design finer-grained rewards (per column or per phase); strengthen NOT handling; add adaptive stopping; test on live, dynamic web; explore communication primitives among sub-agents; and study cost-quality frontiers.

Why remember this: WideSeek shifts the mindset from single-threaded depth to coordinated breadth—closer to how real analysts work—offering a practical path for AI that can gather complete, rule-following, multi-source tables at industrial scale.