One-sentence Summary

AllSpark Team presents Iris-mini and Iris-pro, $35\text{B-A}3\text{B}$35B-A3B and $397\text{B-A}17\text{B}$397B-A17B search agents trained via reverse-constructed multi-hop tasks and a novel SFT–RL climbing procedure, achieving $82.2/84.8/86.9/52.3$82.2/84.8/86.9/52.3 and $88.6/85.1/92.9/56.4$88.6/85.1/92.9/56.4 on BrowseComp, BrowseComp-ZH, DeepSearchQA, and Humanity's Last Exam with context management, the strongest open-source results in their respective parameter ranges.

Key Contributions

• Introduces Iris-mini and Iris-pro, search agents trained at 35B-A3B and 397B-A17B scales, with a data pipeline that reverse-constructs multi-hop tasks from web hyperlink structure, rewrites entities to block string-matching shortcuts, and retains only questions a reference model fails closed-book but solves with evidence.
• Combines trajectory-level and turn-level filtering (the latter using a judge rubric induced from data), followed by reinforcement learning against live search with in-cluster judging and observation summarization, plus an iterative SFT–RL climbing procedure that feeds the hardest solved and most efficient rollouts back into supervised passes.
• With inference-time context management enabled and all other components fixed, achieves 82.2/84.8/86.9/52.3 and 88.6/85.1/92.9/56.4 on BrowseComp, BrowseComp-ZH, DeepSearchQA, and Humanity’s Last Exam, respectively, the strongest overall results among open-source search agents in their parameter ranges.

Introduction

Search agents extend language models beyond closed-form reasoning by enabling interaction with external tools and dynamic information retrieval, requiring decisions about what to search, how to interpret evidence, and when to stop. Unlike conventional language-model evaluation, where task, context, and computation budget are fixed, search demands long-horizon strategies and robust training data, yet prior work often yields performance differences driven more by inference-time harness choices than by the underlying policy. A key challenge is context management (CM), where long trajectories can exhaust the context window, shrinking the effective search budget; existing mitigations like summarization or history removal obscure how much performance stems from the policy versus the harness, limiting fair evaluation.

The authors present an end-to-end recipe for building search agents, covering data construction, training, and evaluation. They construct multi-hop tasks from web-graph structure, remove easily searchable anchors via entity rewriting, and retain only questions that are difficult and verifiable. They collect teacher trajectories with multi-stage filtering, then optimize the policy via reinforcement learning against live search, alternating SFT and RL iteratively to reinforce successful behaviors. Their systems, Iris-mini and Iris-pro, achieve top performance among open-source agents on four benchmarks (BrowseComp, BrowseComp-ZH, DeepSearchQA, and Humanity’s Last Exam), with CM effects isolated by holding other components fixed. The work also finds that search data and models transfer positively to general tool use and cowork scenarios, suggesting search is an atomic capability rather than a vertical specialization, with implications for broader agentic training.

Dataset

The authors build a fully LLM-driven data pipeline that reverse-constructs questions from the hyperlink structure of a web corpus. The pipeline has three stages: web-graph construction, task synthesis, and dual-criteria verification.

Dataset Composition and Sources

• The corpus is modeled as a directed graph where nodes are web pages and edges are hyperlinks.
• Each synthesis instance starts from a seed page, sampled using an answer-anchored mode that fixes a target answer entity and retrieves pages describing it.
• The seed is expanded along its out-links into a local subgraph, retaining the full text of each page truncated to a fixed budget.
• The true out-link set is recovered from a structured semantic mirror (RDF triples) merged with rendered page markup to maximize link recall.

Task Synthesis

• Raw pages are distilled into a compact, connected entity graph with at most n entities and typed semantic relations, preserving the cross-page link structure.
• The extractor keeps only entities and relations on a multi-hop path toward the seed theme, creating a dense relational skeleton.
• A question is generated together with a reasoning path, with a hard constraint that the path has at least N coupled relations, forcing multi-hop dependency.
• An anchor abstraction operator rewrites every non-answer entity into a descriptive reference, removing surface strings that could be directly searched. The rewritten question preserves reasoning structure and the answer, demanding disambiguation by reasoning rather than string matching.

Dual-Criteria Verification

• A reference model judges each question-answer pair under two settings:
  • Difficulty: the model, without tools, fails to answer correctly.
  • Solvability: the model, given the entity graph as context, answers correctly.
• Only pairs passing both criteria are kept, discarding simple questions answerable from memory and questions with wrong or non-unique answers.
• Answer equality is decided by a semantic-matching judge.

Data Usage

• The accepted set of abstracted multi-hop questions, each paired with a verified unique answer, is used for trajectory generation.
• The authors also include some in-house and open-source question sets alongside the generated data, though the specific mixture ratios are not detailed in this section.

Method

2 Data Pipeline

The authors aim to train a capable search agent on questions that cannot be answered from parametric memory alone and require composing evidence dispersed across several sources. Naturally occurring web questions rarely satisfy both conditions, and hand-written questions are expensive and hard to scale. The authors therefore build a fully LLM-driven data pipeline that reverse-constructs questions from the hyperlink structure of a web corpus. The pipeline is organized into three stages: web-graph construction, task synthesis, and dual-criteria verification.

2.1 Web-Graph Construction

The authors model the corpus as a directed graph whose nodes are pages and whose edges are hyperlinks:

$$G = (V, E), \quad \operatorname{Out} (v) = \big \{u \in V \mid (v, u) \in E \big \}.$$G=(V,E),Out(v)={u∈V∣(v,u)∈E}.

Each synthesis instance begins from a seed page drawn by a sampling policy:

$$v _ {0} \sim P _ {\mathrm{seed}} (V),$$v0​∼Pseed​(V),

for which the authors use the answer-anchored mode that fixes a target answer entity and retrieves pages describing it. The seed is then expanded along its out-links into a local subgraph:

$$G _ {\mathrm{sub}} = \big (\{v _ {0} \} \cup N, E _ {\mathrm{sub}} \big), \qquad N = \{v _ {i} \} _ {i = 1} ^ {k} \subseteq \operatorname{Out} (v _ {0}),$$Gsub​=({v0​}∪N,Esub​),N={vi​}i=1k​⊆Out(v0​),

retaining the full text of each page truncated to a fixed budget. Because the reader services that render pages strip inline anchors, the authors recover the true out-link set of $v$v from a structured semantic mirror of the corpus (RDF triples) together with rendered page markup, and merge the two sources to maximize link recall.

2.2 Task Synthesis

Given a subgraph $G _ {\mathrm{sub}}$Gsub​, this stage produces a single obscured multi-hop question through three steps: distilling the pages into an entity graph, authoring a question over that graph, and abstracting away every directly searchable anchor.

Entity-graph extraction. Raw pages carry substantial noise that distracts question generation. The authors distill $G _ {\mathrm{sub}}$Gsub​ into a compact, connected entity graph:

$$G _ {e} = (V _ {e}, R _ {e}) = f _ {\mathrm{ext}} (G _ {\mathrm{sub}}), \qquad | V _ {e} | \leq n,$$Ge​=(Ve​,Re​)=fext​(Gsub​),∣Ve​∣≤n,

where $V _ {e}$Ve​ are salient entities and $R _ {e}$Re​ are typed semantic relations that preserve the cross-page link structure of $G _ {\mathrm{sub}}$Gsub​. The extractor keeps only entities and relations that lie on a multi-hop path toward the seed theme, yielding a dense relational skeleton over which questions can be authored precisely.

Multi-hop question generation. Let $y = \mathrm{theme} (v _ {0})$y=theme(v0​) denote the seed theme, which the authors take as the target answer. They generate an initial question together with its reasoning path over the entity graph:

$$(q _ {0}, P) = f _ {\text {gen}} (G _ {e}, y) \quad \text{s.t.} \quad | P | \geq N \land y \notin q _ {0},$$(q0​,P)=fgen​(Ge​,y)s.t.∣P∣≥N∧y∈/q0​,

where $P = ( e _ { 1 } \stackrel { r _ { 1 } } { \longrightarrow } e _ { 2 } \stackrel { r _ { 2 } } { \longrightarrow } \cdots y )$P=(e1​⟶r1​​e2​⟶r2​​⋯y) is a path in $G _ { e }$Ge​ whose traversal uniquely yields $y$y. The hard constraint $| P | \geq N$∣P∣≥N forces the question to depend on at least $N$N coupled relations.

Anchor abstraction. Concrete anchors let an agent bypass the intended reasoning by directly searching a surface string. The authors remove this shortcut with an abstraction operator $\mathcal{A}$A that rewrites every non-answer entity into a descriptive reference:

$$\mathcal {A} (e): \quad \text {name} (e), \text {alias} (e) \notin \mathcal {A} (e) \land \mathcal {A} (e) \text { uniquely identifies } e, \quad \forall e \in V _ {e} \setminus \{y \}.$$A(e):name(e),alias(e)∈/A(e)∧A(e) uniquely identifies e,∀e∈Ve​∖{y}.

The initial question is then rewritten into its abstracted form:

$$\tilde {q} = f _ {\mathrm{abs}} (q _ {0}, \mathcal {A}),$$q~​=fabs​(q0​,A),

substituting each mentioned entity $e$e by $\mathcal{A}(e)$A(e) while preserving the reasoning structure and the answer $y$y. The resulting $\tilde{q}$q~​ demands disambiguation-by-reasoning rather than string matching.

2.3 Dual-Criteria Verification

The authors admit a pair $(\tilde{q}, y)$(q~​,y) only if it is simultaneously hard and solvable, judged by a reference model $M_{\mathrm{ref}}$Mref​ under two settings:

$$c _ {\mathrm{diff}} (\tilde {q}) = \mathbb {I} \big [ M _ {\mathrm{ref}} (\tilde {q}) \neq y \big ], \qquad c _ {\mathrm{solv}} (\tilde {q}) = \mathbb {I} \big [ M _ {\mathrm{ref}} (\tilde {q} \mid G _ {e}) = y \big ],$$cdiff​(q~​)=I[Mref​(q~​)=y],csolv​(q~​)=I[Mref​(q~​∣Ge​)=y],

and they keep only the intersection:

$$\mathcal {D} = \big \{(\tilde {q}, y) \mid c _ {\mathrm{diff}} (\tilde {q}) \cdot c _ {\mathrm{solv}} (\tilde {q}) = 1 \big \}.$$D={(q~​,y)∣cdiff​(q~​)⋅csolv​(q~​)=1}.

The difficulty criterion (closed-book, no tools) discards simple questions the model already answers from memory; the solvability criterion (with $G_e$Ge​ supplied as context) discards questions whose answer is wrong or non-unique. Answer equality is decided by a semantic-matching judge. The accepted set $\mathcal{D}$D of abstracted multi-hop questions, each paired with a verified, unique answer, is then used for trajectory generation.

3 Training Recipe

The authors train the search agent through iterative cycles of supervised fine-tuning (SFT) and reinforcement learning (RL).

3.1 Supervised Fine-Tuning

Trajectory generation. The authors prompt a strong teacher $M_T$MT​ to solve each question $q \in \mathcal{D}$q∈D under the ReAct paradigm, interleaving reasoning, tool calls, and observations against live search tools. A trajectory is the resulting sequence of reasoning steps, tool calls, and observations, terminated by a final answer:

$$\tau = \left(r _ {1}, a _ {1}, o _ {1}, \dots, r _ {T}, a _ {T}, o _ {T}, r _ {T + 1}, \hat {y}\right) \sim \pi_ {M _ {T}} (\cdot \mid q, \mathcal {T}),$$τ=(r1​,a1​,o1​,…,rT​,aT​,oT​,rT+1​,y^​)∼πMT​​(⋅∣q,T),

where $r_t$rt​ is the reasoning at step $t$t, $a_t \in \mathcal{T}$at​∈T is a tool call from the tool set $\mathcal{T} = \{ \mathrm{SEARCH}, \mathrm{SCRAPE} \}$T={SEARCH,SCRAPE}, $o_t$ot​ is the returned observation, and $\hat{y}$y^​ is the final answer. Each observation is a document-level summary produced on the fly rather than a raw page, which keeps trajectories within a bounded context budget.

Coarse filtering. Let $\mathcal{D}_{\mathrm{raw}} = \{ (q, \tau) \}$Draw​={(q,τ)} be the pool of collected trajectories. Every sample must clear a trajectory-level stage that admits $\tau$τ only if it is correct, non-degenerate, and non-trivial. Correctness is a two-part gate: the rollout must terminate successfully, and its answer must be judged correct by an LLM judge $J$J against the reference $y^*$y∗:

$$c _ {\mathrm{corr}} (q, \tau) = \mathbb {I} [ \text {success} (\tau) ] \cdot \mathbb {I} [ J (q, \hat {y} _ {\tau}, y ^ {*}) = \text {CORRECT} ].$$ccorr​(q,τ)=I[success(τ)]⋅I[J(q,y^​τ​,y∗)=CORRECT].

The authors then remove degenerate trajectories: repetition loops, runaway tool calling, unterminated thinking blocks, and other pathologies. Their primary detector is a sliding-window compression ratio, computed in $O(n)$O(n) over the decoded text:

$$\rho_ {\mathrm{cr}} (w) = \frac {| w |}{\left| \operatorname{zlib} (w) \right|}, \quad c _ {\text {degen}} (\tau) = \mathbb {I} \left[ \max _ {w} \rho_ {\mathrm{cr}} (w) \geq \tau_ {\mathrm{cr}} \right].$$ρcr​(w)=∣zlib(w)∣∣w∣​,cdegen​(τ)=I[wmax​ρcr​(w)≥τcr​].

Repetitive text compresses far more than fluent text, so any window whose ratio reaches $\tau_{\mathrm{cr}}$τcr​ signals a loop, whatever its period and wherever it begins. Auxiliary detectors cover what compression alone can miss: periodically repeating lines, long single-character runs, and consecutive tool calls with byte-identical arguments. Finally, the authors keep only trajectories with at least $K$K tool-call turns, discarding shallow cases a direct lookup could resolve:

$$c _ {\mathrm{depth}} (\tau) = \mathbb {I} [ T _ {\mathrm{tool}} (\tau) \geq K ].$$cdepth​(τ)=I[Ttool​(τ)≥K].

An exact-duplicate pass over full message sequences then drops byte-identical trajectories while keeping distinct rollouts of the same question, giving the coarse set:

$$\mathcal {D} _ {\mathrm{sft}} = \operatorname{dedup} \bigl \{(q, \tau) \in \mathcal {D} _ {\text {raw}} \mid c _ {\text {corr}} \cdot (1 - c _ {\text {degen}}) \cdot c _ {\text {depth}} = 1 \bigr \}.$$Dsft​=dedup{(q,τ)∈Draw​∣ccorr​⋅(1−cdegen​)⋅cdepth​=1}.

Fine filtering. Coarse filtering keeps or drops whole trajectories. When a question sits near the capability boundary of the teacher, however, a correct trajectory may still contain a locally poor turn: a redundant search, a hallucinated tool name, or reasoning inconsistent with the action actually taken. As a turn-level refinement, the authors label individual turns with an LLM judge. The difficulty is that a turn which looks wasteful in isolation is often a legitimate exploratory step, and because no human is in the loop, the judge has to draw that line on its own. The authors therefore induce the criteria from the data rather than hand-crafting them. Specifically, they sample some trajectories and ask the judge to critique them in free form, then consolidate the recurring failure modes (e.g., misinterpreting the question) into an explicit rubric used in the final judging prompt. For each assistant turn, the judge receives the question, reference answer, and a fixed local window of surrounding turns, and outputs either KEEP or MASK, represented as $m_t \in \{0, 1\}$mt​∈{0,1}. To prevent overly aggressive filtering, the authors mask at most 10% of the assistant turns in any trajectory. Masked turns remain in the context but are excluded from the training loss, providing cleaner learning signals without discarding useful interaction history.

Training objective. For each assistant turn, let $C_{<t}$C<t​ denote its visible history, reconstructed by the harness's replay operator from the append-only conversation so as to stay byte-identical to what the agent conditioned on at inference. Over $\hat{\mathcal{D}}_{\mathrm{sft}}$D^sft​ the authors maximize the likelihood of the teacher's output:

$$\mathcal {L} _ {\mathrm{SFT}} (\theta) = - \mathbb {E} _ {(q, \tau) \sim \mathcal {D} _ {\mathrm{sft}}} \sum_ {t = 1} ^ {T + 1} m _ {t} \log \pi_ {\theta} \big (u _ {t} \mid C _ {< t} \big),$$LSFT​(θ)=−E(q,τ)∼Dsft​​t=1∑T+1​mt​logπθ​(ut​∣C<t​),

where $u_t$ut​ is the assistant output at turn $t$t, namely the reasoning and tool call $(r_t, a_t)$(rt​,at​) for $t \leq T$t≤T and the final reasoning and answer $(r_{T+1}, \hat{y})$(rT+1​,y^​) at $t = T+1$t=T+1. The per-turn mask $m_t \in \{0, 1\}$mt​∈{0,1} is supplied by fine filtering; observation, user, and system tokens carry zero loss by construction.

3.2 Reinforcement Learning

The authors then optimize the agent against live search with a group-relative policy gradient. To keep long-horizon rollouts affordable without going fully asynchronous, they place the rollout regime between on- and off-policy through request-level partial rollout. To avoid depending on external APIs at training time, they co-locate an in-house model that serves as both reward judge and observation summarizer.

Partial rollout and prefix reuse. Long-horizon rollouts have a heavy tail: a few sessions run far longer than the rest and stall a synchronous step. Rather than discard unfinished work, as task-level streaming does, the authors interrupt at the request level. Once a step has committed enough completed trajectories, in-flight over-sampled sessions are aborted and resumed at the next step from their committed prefix. Rollouts are organized as a forest whose nodes are message states, each caching its token, loss-mask, log-probability, and weight-version deltas, so a resumed trajectory is a path that splices prefixes generated under different policy weights, a mismatch the authors correct with truncated importance sampling. Completed turns are therefore reused rather than thrown away, which keeps rollout GPUs busy under a synchronous, co-located schedule at the cost of roughly $2\times$2× over-sampling as headroom.

In-house reward and summarization. Rather than call an external API, the authors run several FP8 engines of an in-house Qwen3.5-397B-A17B model inside the training cluster, alongside the actor and rollout engines. Acting as a generative reward model (GenRM), the model scores a rollout with a binary verdict on the extracted answer $\hat{y}_\tau$y^​τ​ against the reference $y^*$y∗:

$$R (q, \tau) = \mathbb {I} \left[ \mathrm{GenRM} \big (q, \hat {y} _ {\tau}, y ^ {*} \big) = \mathrm{A} \right],$$R(q,τ)=I[GenRM(q,y^​τ​,y∗)=A],

with no additive format term, since an empty or mid-thought-truncated answer extracts to $\emptyset$∅ and already scores 0 without invoking the judge. As a summarizer, the same engines compress each retrieved page into a short, query-relevant digest that supplies the observation $o_t$ot​ of Eq. (10). This is the only context-reduction mechanism in the rollout, with no message-history pruning or sliding window, so the context the policy conditions on is exactly what is trained on. Serving both roles in-cluster removes the external API dependency from the training loop, and one allocation covers training, rollout, and reward.

3.3 Iterative Climbing

The authors alternate SFT and RL in iterative cycles. Each round of RL explores the current policy, after which a small set of high-quality rollouts is distilled back into the policy through supervised fine-tuning; RL then resumes from the updated model. The authors call each such cycle a climb. This alternation complements the strengths of the two objectives: RL improves behaviors sampled by the current policy through relative rewards, while supervised fine-tuning directly reinforces rare but successful trajectories instead of relying on their contribution to a group-relative gradient.

For each query $q$q, the authors retain at most one rollout from the existing RL samples. Let $\bar{R}(q)$Rˉ(q) denote the pass rate within its rollout group. They select queries with $0 < \bar{R}(q) \leq 1/2$0<Rˉ(q)≤1/2, targeting cases that are solvable but not yet reliable. Among successful rollouts, they require at least $K_{\mathrm{rft}}$Krft​ tool-call turns and then select the shortest valid trajectory:

$$\mathcal {S} _ {q} = \big \{\tau_ {i} \mid R (q, \tau_ {i}) = 1, T _ {\mathrm{tool}} (\tau_ {i}) \geq K _ {\mathrm{rft}} \big \}, \quad \tau_ {q} ^ {\star} = \underset {\tau \in \mathcal {S} _ {q}} {\arg \min} T _ {\mathrm{tool}} (\tau).$$Sq​={τi​∣R(q,τi​)=1,Ttool​(τi​)≥Krft​},τq⋆​=τ∈Sq​argmin​Ttool​(τ).

The depth constraint filters out lucky or trivial solutions, while the shortest-trajectory criterion discourages unnecessary search. The resulting set is deduplicated and used for SFT before the next RL round. Since the difficulty band is defined by the current policy's pass rate, it automatically shifts toward harder examples as the policy improves, providing a simple self-paced curriculum and a natural stopping signal as the candidate pool diminishes.

Experiment

The evaluation covers four benchmarks (BrowseComp, BrowseComp-ZH, DeepSearchQA, and HLE) with two model scales, Iris-mini and Iris-pro, tested under both no context management and discard-all settings. Iris-mini leads its parameter range on three benchmarks, while Iris-pro tops or ties all four, with both models showing competitive performance against larger systems. Context management consistently improves results, with gains tied to how often a model exhausts its context, and the retry strategy pushes scores higher but at substantial inference cost, so discard-all is treated as the default reporting configuration.

In the 30–35B parameter range, Iris-mini achieves the best results on three of four benchmarks, outperforming same-scale competitors on BrowseComp and BrowseComp-ZH while trailing on DeepSearchQA. In the ~400B range, Iris-pro leads or ties on all benchmarks, including a notable gain over XYZ-Aquila-pro on BrowseComp and HLE. The models also show strong intrinsic search ability without context management, and context management consistently improves performance, with larger gains for the smaller model. Iris-mini outperforms XYZ-Aquila-mini by 3.4 points on BrowseComp but trails on DeepSearchQA. Iris-pro leads or ties on all four benchmarks in its size range, with the largest gap on BrowseComp. Without context management, Iris-mini beats FORT-Searcher, OpenSeeker-v2, and RED-Searcher on BrowseComp and BrowseComp-ZH. Context management improves performance more for Iris-mini than for Iris-pro, as the smaller model exhausts context more often. On BrowseComp-ZH, three configurations converge to the same score, suggesting a benchmark-specific ceiling.

Context management (CM) consistently improves search agent performance over no-CM baselines, with larger gains for the smaller Iris-mini model than for Iris-pro. The benefit of CM is most pronounced on benchmarks requiring long-horizon information seeking, where context exhaustion is the limiting factor, and combining discard-all with retry yields the highest scores but at substantial inference cost. CM improves performance over no-CM baselines across all evaluated settings, with gains for Iris-mini reaching up to 21.2 points on BrowseComp. Iris-mini benefits more from CM than Iris-pro, as the smaller model exhausts context more often and has more to recover. The largest CM gains occur on BrowseComp, which requires long-horizon search, while HLE gains less because its bottleneck is knowledge and reasoning rather than context. Combining discard-all with retry achieves the strongest results in most settings, but the added inference cost makes it an upper-bound exploration rather than the primary configuration. Without CM, Iris-mini and Iris-pro outperform several existing search agents on BrowseComp and BrowseComp-ZH, indicating strong intrinsic search capability.

In the 30–35B parameter range, Iris-mini leads on three of four benchmarks, outperforming same-scale competitors on BrowseComp and BrowseComp-ZH but trailing on DeepSearchQA. In the ~400B range, Iris-pro leads or ties on all benchmarks, with its largest advantage on BrowseComp. Both models show strong intrinsic search ability without context management, and adding context management consistently improves performance, with larger gains for the smaller model, which exhausts context more often. The benefit is most pronounced on long-horizon tasks like BrowseComp, while HLE gains less due to its knowledge and reasoning bottleneck; combining discard-all with retry yields the highest scores but at substantial inference cost, and on BrowseComp-ZH, three configurations converge to the same score, suggesting a benchmark-specific ceiling.