Iris-mini and Iris-pro: Two Search Agents Trained at 35B-A3B and 397B-A17B Scales

Iris-mini and Iris-pro are search agents trained via iterative SFT-RL climbing on synthetic multi-hop web tasks.

How can we build effective search agents by reverse-constructing training data and using iterative SFT/RL cycles?

Search agents often struggle to resolve complex, multi-hop queries because naturally occurring web data is too simple and inference-time context management masks the agent's true policy capability. The authors introduce an end-to-end pipeline that reverse-constructs difficult, verifiable search tasks from web-graph structure and optimizes agents through iterative cycles of supervised fine-tuning and reinforcement learning against live search. Iris-mini and Iris-pro achieve state-of-the-art performance among open-source search agents in their respective parameter classes across four challenging benchmarks.

Paper Primer

The core mechanism is SFT-RL climbing: an iterative loop where the agent explores via reinforcement learning (RL) against live search, and the most efficient, successful trajectories are distilled back into the policy via supervised fine-tuning (SFT). This process is like a mountain climber using a safety rope — each successful ascent is anchored as a new base camp, allowing the agent to explore increasingly difficult terrain without losing its footing.

Iris-pro (397B) achieves the strongest performance among open-source search agents on BrowseComp, DeepSearchQA, and Humanity’s Last Exam.

The model reached 88.6 on BrowseComp, 92.9 on DeepSearchQA, and 56.4 on HLE, outperforming the previous best open-source agent, XYZ-Aquila-pro. Iris-pro outperformed XYZ-Aquila-pro by 3.8 points on BrowseComp and 3.1 points on HLE.

Context management (CM) provides significant performance gains, but the underlying policy quality remains the primary driver of search capability.

Performance improvements from CM are benchmark-dependent and correlate with how frequently a model exhausts its context window during long-horizon tasks. CM gains reached up to 21.2 points on BrowseComp for Iris-mini, while the model maintained a clear lead over baselines even in no-CM regimes.

Why is it necessary to reverse-construct search tasks from web graphs instead of using existing datasets?

Naturally occurring web questions are often too simple to require multi-hop reasoning or tool use. By distilling entity graphs and abstracting searchable anchors, the authors force the agent to disambiguate through reasoning rather than simple string matching.

How does the authors' approach to context management differ from standard practice?

Rather than designing benchmark-specific heuristics, the authors report results both with and without CM to disentangle the agent's intrinsic search intelligence from the performance gains provided by the inference-time harness.

Search should be treated as an atomic agentic capability rather than a vertical specialization; the authors' results suggest that search-derived behaviors transfer positively to general tool use and collaborative tasks.

Introduction to Iris Search Agents

We outline the motivation, pipeline, and evaluation of strong search agents and the gap they address.

Search agents extend language models by interacting with tools and retrieving information, turning static reasoning into dynamic search.

Existing pipelines construct harder tasks by traversing web graphs and masking entities, yet they still lack a systematic way to generate multi‑source evidence composition challenges.

A search agent must learn to combine evidence from many sources and reason non‑parametrically, which requires training data that forces such behavior.

We build Iris‑mini and Iris‑pro agents at 35B‑A3B and 397B‑A17B scales using a reverse‑construction pipeline that creates multi‑hop tasks from a web‑graph, rewrites non‑answer entities, and filters questions to those a reference model cannot answer without evidence.

Trajectories are filtered twice before supervised fine‑tuning: first at the trajectory level for correctness, degeneracy, and depth, then at the turn level by a judge whose rubric is induced from the data rather than hand‑written.

The policy is then optimized by reinforcement learning against live search, with the reward judge and observation summarizer inside the training cluster; over‑long rollouts are interrupted and resumed from their committed prefix.

We alternate SFT and RL in a procedure we call SFT‑RL climbing, feeding the hardest solved and most efficient rollouts back into the next supervised pass.

Because inference‑time context management (CM) can dominate performance, we evaluate each benchmark with and without it while keeping the tool set, context limit, and judge fixed.

With CM enabled, Iris‑mini and Iris‑pro achieve 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 open‑source results in their parameter ranges.

We will release the model weights and the complete data‑construction, training, and evaluation recipe to enable reproducibility.

The gap between web‑scale data and agent‑specific training needs drives the entire pipeline.

Reverse-Constructing Search Tasks

We build a fully LLM‑driven pipeline that reverse‑constructs multi‑hop questions from web links.

Natural web queries rarely force a model to combine evidence from multiple sources, and hand‑crafted questions are costly to scale. To supply the needed training signal we construct a fully LLM‑driven pipeline that reverse‑constructs questions from the hyperlink structure of a web corpus.

The pipeline starts from a seed web page, expands a local link subgraph, distills it into a compact entity graph, then generates an abstracted multi‑hop question that cannot be answered by memorized facts alone.

Entity extraction yields three entities: $e_{\text{Mars}}$, $e_{\text{Olympus}}$, $e_{\text{Rover}}$, and two relations: $e_{\text{Mars}} \xrightarrow{\text{hasFeature}} e_{\text{Olympus}}$, $e_{\text{Mars}} \xrightarrow{\text{exploredBy}} e_{\text{Rover}}$.

We ask the generator to produce a question whose answer is $e_{\text{Mars}}$ and whose path uses at least $N=2$ relations, yielding $q_0$: “Which planet hosts the tallest volcano and the rover that discovered it?”.

Applying abstraction $A$, we replace “Olympus Mons” and “Mars Rover” with descriptive placeholders “the tallest volcano” and “the rover that discovered it”, giving $\tilde{q}$: “Which planet hosts the tallest volcano and the rover that discovered it?” (anchors removed).

Reference model $M_{\text{ref}}$ fails to answer $\tilde{q}$ without context (returns “unknown”), but succeeds when provided $G_e$ (outputs “Mars”). The pair $(\tilde{q}, \text{Mars})$ is kept.

The example shows how abstracting surface strings forces the model to follow the relational path in $G_e$ rather than relying on memorized entity names.

Iterative SFT and RL Training

Iterative cycles of supervised fine‑tuning and reinforcement learning shape the search agent.

The agent needs training data that forces it to combine evidence from multiple tools and to reason beyond simple lookup. Naïve fine‑tuning on raw teacher rollouts yields many degenerate trajectories—repetitive loops, empty tool calls, or shallow searches—that provide little learning signal.

Instead of a single monologue, the model alternates between reasoning, issuing a tool call, and observing the tool’s output—forming a tight loop that lets each step build on the previous observation.

How does ReAct differ from a standard chain‑of‑thought prompt?

Chain‑of‑thought produces a single reasoning trace and then answers, while ReAct injects external tool calls between reasoning fragments, allowing the model to retrieve fresh information at each step rather than relying solely on its internal knowledge.

We alternate between supervised fine‑tuning on high‑quality rollouts and reinforcement learning that explores new behaviors, letting each phase compensate for the other’s weaknesses.

Filter out rollouts with fewer than 2 tool calls → all three remain.

Select only those with the highest reward (assume A and C succeed, B fails) → keep A and C.

Among the successful ones, pick the shortest trajectory → Rollout A (length 5) is chosen as $\tau_q^\ast$.

Choosing the shortest successful rollout discourages unnecessary searches while still guaranteeing that the essential evidence has been retrieved.

Why not rely solely on RL to improve the policy?

RL explores new behaviors but provides a noisy gradient that can be dominated by rare high‑reward events; without SFT, the policy may never see the concrete sequence of reasoning and tool calls that lead to those rewards, making learning unstable.

Reconstruct the visible history $C_{<t}$ for each turn $t$ using the append‑only replay operator.

Apply the turn‑level mask $m_t$ (from fine filtering) to decide whether the turn contributes to the loss.

Compute the log‑probability $\log \pi_\theta(u_t\mid C_{<t})$ of the teacher’s output $u_t$.

Accumulate the masked negative log‑likelihood across all turns and all trajectories in $D_{\text{sft}}$.

Back‑propagate the summed loss to update parameters $\theta$.

Generate a batch of rollouts synchronously until a request‑level budget is reached.

Abort any over‑sampled sessions and cache their completed prefixes (token, loss‑mask, log‑probability).

At the next training step, resume each aborted rollout from its cached prefix, stitching together trajectories generated under different policy weights.

Apply truncated importance sampling to correct for the weight mismatch between prefixes and the current policy.

Reuse the completed prefixes for the next RL gradient estimate, reducing idle GPU time.

By repeatedly climbing—alternating SFT on distilled high‑quality rollouts and RL on the current policy—we obtain a self‑paced curriculum that automatically shifts toward harder queries as the pass rate improves, eventually converging when the pool of eligible rollouts vanishes.

Benchmark Performance

Iris‑pro outperforms all baselines, delivering the top scores across four search benchmarks.

Iris‑pro leads on all four benchmarks, beating the strongest comparable model by up to 3.8 points.

Table 1 shows Iris‑pro scoring 88.6 on BrowseComp, 92.9 on DeepSearchQA, and 56.4 on HLE, each surpassing XYZ‑Aquila‑pro (84.8, 92.5, 53.3) and the HLE baseline (64.5, 54.7, 64.5) where applicable.

**Figure 1.** Performance comparison across four agentic search benchmarks.

**Table 1.** Main results on the four search benchmarks with CM enabled for each system. For our models we report the discard-all setting throughout; the remaining strategies are analyzed in Table 2. HLE uses the text-only setting by default; results evaluated on the full set are marked with $^f$. $^r$ indicates that the corresponding result was reproduced by the XYZ-Aquila Team.

Context Management Strategies

Ablation study quantifies how Context Management strategies impact search agents across benchmarks.

We evaluate how different Context Management (CM) strategies affect each search agent’s scores on four benchmarks.

CM decides which parts of the interaction history are retained when the agent continues searching.

How does CM differ from simply truncating the context window?

Truncation only removes the oldest tokens, preserving a partial history. Discard‑all removes the entire history, and retry re‑uses the previous attempt’s output, fundamentally altering what information the model sees.

Qualitative Analysis and Failure Modes

We analyze how Context Management strategies affect search agents across benchmarks and model scales.

Table 2 quantifies how Context Management (CM) strategies influence our search agents. We compare a simple discard‑all policy, which wipes the interaction history once a context threshold is hit, against the retry strategy that appends a compact summary of a failed attempt before retrying.

**Figure 2.** An illustrative case from BrowseComp-ZH (Question 85), where our search agent returns the answer “Bolton”, while the official ground truth is “Lannister”.

Without any CM, Iris‑mini scores 64.7 on BrowseComp and 72.3 on BrowseComp‑ZH, surpassing prior systems such as FORT‑Searcher and OpenSeeker‑v2. Iris‑pro adds 7.9 and 4.5 points respectively, and both models retain their advantage after CM is applied, showing that the gains are not merely due to inference‑time tricks.

CM consistently lifts performance over the no‑CM baselines, but the boost is larger for Iris‑mini because the smaller model reaches the context limit more often. Consequently, CM is most valuable when a model has learned effective search behavior yet runs out of context before it can exploit it.

Benchmark‑specific effects reveal the ordering: CM adds up to 21.2 points on BrowseComp, yet only 9.2 on HLE, reflecting how frequently each task exhausts the context window. Notably, three configurations converge on a BrowseComp‑ZH score of 85.1, indicating that beyond this point performance is constrained by factors other than model capacity.

Combining discard‑all with retry yields the highest scores—pushing Iris‑pro above 90 on BrowseComp—but each retry incurs a full additional search pass, raising inference cost. We therefore report discard‑all results as the primary metric, treating aggressive retry as an upper‑bound exploration rather than the standard configuration.

Summary and Future Directions

We wrap up the recipe, highlight transfer potential, and note authorship and reference details.

We presented an end‑to‑end recipe for building search agents, instantiated at Iris‑mini and Iris‑pro, and demonstrated strong performance on standard benchmarks.

Training questions are reverse‑constructed from web hyperlinks, filtered by a strong teacher, and optimized through alternating SFT and RL stages.

Beyond search, the models transferred positively to General Tool Use and Cowork domains, suggesting search is an atomic capability reusable across tasks.

The authors list reflects contribution order, with equal contributors and project leads identified.

A concrete inconsistency is highlighted in BrowseComp‑ZH Question 85, where the benchmark’s ground truth mismatches the series‑based answer, motivating higher‑quality benchmark creation.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers