acceptodds
Under review as a conference paper at ICLR 2027

Glasseek: A Transparent Recipe for Training and Trustworthy Evaluation of DeepSearch Agents

Abstract

Deep search enables language agents to solve complex information-seeking tasks through iterative web exploration. However, developing robust open-source agents remains challenging for three reasons. First, opaque trajectory-construction pipelines make training data difficult to audit and reproduce. Second, context compression can create a substantial mismatch between training and inference. Third, agents may retrieve benchmark content from the open web during evaluation, contaminating the results and overstating their performance. To overcome these bottlenecks, we introduce **Glasseek**, a fully transparent deep search framework spanning the complete development lifecycle, releasing all data, model weights, training recipes, and code. Specifically, for data construction, we establish a verifiable trajectory curation pipeline that systematically generates high-quality exploration paths. For training, we propose **C**ompaction-**M**anaged GSPO (CM-GSPO), which uses the same policy for search and summarization while optimizing only execution sub-trajectories, enabling end-to-end search-policy training across context-compaction boundaries. For evaluation, we conduct the first systematic audit of test-set leakage in open-web agents and release a modular anti-leakage plugin that seamlessly integrates into existing evaluation harnesses. Under this rigorous evaluation protocol, our 9B agent outperforms frontier proprietary agents across almost all deep research benchmarks spanning diverse task types, and achieves the best overall performance among recent open-weight agents, setting a new state of the art at the 9B scale. Our code is available at [https://anonymous.4open.science/r/Glasseeker-DC0B](https://anonymous.4open.science/r/Glasseeker-DC0B).

Primary area:
foundation or frontier models, including LLMs
Keywords:
Deep Search Agents, Reinforcement Learning, Context Management, Trustworthy Evaluation

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_sQvBOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Glasseek is an open recipe for training 4B and 9B deep-search agents. The data comes from a multi-agent pipeline that writes hard search questions. Training uses a GSPO variant built for rollouts where the context gets compressed. At evaluation time, a filter blocks the agent from looking up benchmark answers online. The authors also audit several existing agents and find that they do look up answers. The 9B model reports 61.6 on BrowseComp.

Critical strengths

I learned the most from the leakage study. In Appendix F, agents retrieve benchmark answers or previous solution traces from public web resources. Anyone who runs these benchmarks should see those examples. Appendix D's discussion of selective restarts is useful too, especially the distinction between single-episode capability and gains produced by giving resource-exhausted runs fresh attempts.

Critical weaknesses

The main problem is that the paper does not fully follow its own evaluation argument. Appendix D explains that selective restarts can increase the reported task-level score without improving single-episode reasoning ability, and recommends treating this as a protocol-level metric. Yet the headline BrowseComp number, 61.6, uses this restart protocol. The corresponding first-attempt accuracy is 54.5, which is below the 59.2 Gemini-3-Pro number used in the paper's comparison. Table 2 also states that many unmarked baseline scores are taken from their original reports and retain their original evaluation settings. This makes the broad headline comparison difficult to interpret. In particular, the abstract says the 9B model outperforms frontier proprietary agents across almost all deep-research benchmarks, which does not seem supported by Table 2 under a common protocol.

I also found the RL contribution hard to isolate. I could not find repeated training runs for the RL stage, the exact definition of the "+ Compaction" baseline is not sufficiently clear to me, and the two main ingredients of CM-GSPO are not separately ablated. The terminology also switches between turn-level and sub-trajectory importance ratios in different parts of the paper, and I think this distinction should be made more explicit.

One more result needs clarification. For BrowseComp, the CM-GSPO entry in Table 3 is exactly 61.6, the same as the full-result entry in Table 2. However, Section 5.3 says the BrowseComp ablation is evaluated on a 200-question subset and averaged over three independent runs. This could be coincidence, but the identical value makes me wonder whether one of the numbers comes from the full evaluation rather than the stated ablation protocol. The paper's own leakage rate is also left blank in Table 1.

Minor: the reproducibility statement says representative leakage trajectories are in Appendix E, while the paper itself places them in Appendix F.

Questions for authors
  1. Can you put the headline model comparison under one consistent protocol, ideally the same harness with first-attempt results, and revise the abstract accordingly? This would affect my score more than anything else.

  2. Do the Table 3 ablations use the restart protocol? Also, can you clarify why the BrowseComp CM-GSPO number is exactly the same as the full-set Table 2 result despite the stated 200-question, three-run ablation setup?

  3. How often does Glasseeker itself attempt to access benchmark artifacts when the anti-leakage filter is disabled? Also, did you test the synthetic training questions for overlap or near-duplication with the evaluation sets?

3 comments

Thank you for highlighting the leakage examples in Appendix F and the distinction in Appendix D between first-attempt accuracy and task completion with selective restarts. We agree that the headline comparison should make this distinction explicit.

Q1. Headline comparison and first-attempt evaluation

On the full BrowseComp test set, Glasseeker-9B achieves 54.5% accuracy on the first attempt and 61.6% with selective restarts. Under the protocol in Appendix D, an attempt has a budget of 500 interaction turns. A question receives a fresh attempt only if the agent exhausts its budget before producing a final answer, with at most five attempts in total. The first final answer ends the evaluation, regardless of correctness. The 7.1 percentage point increase measures the gain from this restart policy.

Gemini-3-Pro’s published BrowseComp score of 59.2% exceeds our first-attempt score of 54.5%. Table 2 identifies the baselines we evaluated in our harness with a dagger. The Gemini score comes from its original report. We agree that the original abstract overstated what comparisons across different evaluation protocols could establish. The revised abstract bases its comparison on Table 5, where all checkpoints used the same harness, answered the same questions, and received one attempt per question with identical turn and time limits. Under this protocol, Glasseeker-9B outperforms both open-source models with fewer than 9B parameters on all five benchmarks. The abstract also reports both results on the full BrowseComp test set: 54.5% accuracy on the first attempt and 61.6% with selective restarts.

Comparison under a common protocol. We added a first-attempt comparison in Section 5.2 and report the results in Table 5 of Appendix D. We evaluated all five checkpoints on the same questions using the same Hermes-agent harness, with identical turn and time limits and one attempt per question. Appendix D gives the remaining evaluation settings. The table reports first-attempt accuracy (%) with the number of questions in parentheses.

Model / checkpointBrowseComp (200)BrowseComp-ZH (289)Seal-0 (111)XDS-2510 (100)GAIA-Text (103)
DeepSeek-V4-Pro73.572.753.261.079.6
Claude-Opus-4.556.565.441.458.068.0
Apodex-1.0-4B-SFT9.533.921.625.042.7
MiroThinker-v1.0-8B30.540.439.635.065.0
Glasseeker-9B (CM-GSPO)54.552.640.551.072.8

We could not include Gemini-3-Pro in Table 5 because we did not have access to its API during this evaluation.

Apodex scored poorly in part because it requested tools in a format our harness could not reliably read. MiroThinker scored 30.5% on our 200 BrowseComp questions and 31.1% on the original full set, and neither evaluation use the restart protocal.

Glasseeker-9B also scores above Apodex-1.0-4B-SFT on all five benchmarks. Its accuracy is close to Claude-Opus-4.5 on BrowseComp-200 (54.5% versus 56.5%) and Seal-0 (40.5% versus 41.4%). On GAIA-Text, Glasseeker-9B scores 72.8%, compared with 68.0% for Claude-Opus-4.5 and 79.6% for DeepSeek-V4-Pro.

Q2. Restart policy for Table 3 and the earlier 61.6% entry

Yes. All BrowseComp ablations in Table 3 used selective restarts. Each attempt had a limit of 500 interaction turns and 3,600 seconds. If the agent reached either limit before producing a final answer, it could retry the question, up to five attempts including the first. Evaluation stopped as soon as the agent produced a final answer.

Correction to the submitted Section 5.3. We incorrectly stated that Table 3 reported ablation results averaged over three independent runs. We have corrected this reporting error in Section 5.3. Each BrowseComp score in Table 3 comes from one evaluation run per checkpoint on the same fixed subset of 200 questions. Selective restarts took place within that run.

Table 2 reports 61.6% accuracy on the full BrowseComp test set. The identical 61.6% entry for CM-GSPO in the submitted Table 3 was a typographical error. The corrected Table 3 entry is 60.5%. In the single subset run, CM-GSPO solved 121 of 200 questions, compared with 111 of 200 for the SFT baseline (55.5%), a gain of 5.0 percentage points.

Q3. Access to benchmark artifacts and overlap with the training data

Access to benchmark artifacts with the filter disabled (Table 1). We ran an additional evaluation with the anti-leakage filter disabled. Glasseeker-9B attempted to access benchmark-related artifacts in 13.8% of evaluation trajectories. The 61.6% accuracy reported on the full BrowseComp test set was obtained with the leakage filter enabled and selective restarts allowed.

Overlap with English BrowseComp (Appendix G). We checked the released training questions for near-duplicates of English BrowseComp questions. After removing fixed prompt templates and deduplicating within each training split, we compared 4,359 SFT questions and 1,308 RL questions against all 1,266 English BrowseComp questions. We embedded the question texts with Qwen3-Embedding-4B, retrieved the nearest BrowseComp question for each training question by cosine similarity, and inspected the highest-scoring pairs. The maximum similarity was 0.7915 for SFT and 0.7851 for RL.

Appendix G shows the three closest SFT pairs and the two closest RL pairs. In the closest SFT pair, both questions use a supervisor as a clue to identify a thesis. The training question asks for the second supervisor listed in the archive, while the BrowseComp question asks for the author’s surname. In the closest RL pair, both questions concern early-1990s PC games. One asks for the developer and the other for the game title. These examples illustrate why we examined the entities, constraints, and requested answers alongside each similarity score. The scope of this audit is question-text overlap with English BrowseComp. Other evaluation sets and possible exposure during pretraining remain outside its scope.

RL baselines and component ablations

The revised Table 3 identifies the importance-ratio unit and whether each variant uses context compaction and length-based reweighting. A session is the part of a rollout between compaction boundaries. The configurations differ as follows.

  • Vanilla GSPO computes one importance ratio per session and averages token losses within that session. With compaction disabled, a session spans the entire rollout.
  • + Compaction keeps the same rule while enabling context compaction. Each sub-trajectory now has its own ratio and independently averaged loss. Summing these losses gives greater aggregate weight to rollouts split into more sub-trajectories.
  • Our ReSum-GRPO implementation uses token-level ratios with compaction and broadcasts the rollout advantage to every segment. It applies no segment-length correction.
  • + Compaction & Turn IS keeps compaction and the same sub-trajectory loss normalization as + Compaction, but computes one ratio per turn. Comparing these rows isolates the choice of ratio unit.
  • CM-GSPO keeps the turn-level ratio and weights each sub-trajectory’s mean loss by its share of the rollout’s unmasked execution tokens, Li,k/LiL_{i,k}/L_i. These weights sum to one within each rollout, removing the extra weight introduced by splitting it into more segments. Comparing CM-GSPO with + Compaction & Turn IS isolates this reweighting.

Equations (3) and (4) use jj to index the turn that supplies the ratio. Equation (5) defines the sub-trajectory weight, and Equation (6) combines the losses within each rollout.

On BrowseComp-200, accuracy rose from 55.0% with + Compaction to 57.0% with + Compaction & Turn IS, a gain of 2.0 percentage points from switching to turn-level ratios. Adding rollout-level reweighting (CM-GSPO) raised accuracy to 60.5%, a further 3.5 percentage points and a total gain of 5.5 percentage points over + Compaction.

Reproducibility statement

We corrected the reference to Appendix F, which contains the representative leakage trajectories and their event indices. Appendix E reports the topic distribution of the SFT data.

Dear Reviewer sQvB,

Thank you again for your careful and constructive review. As the discussion period is coming to a close, we wanted to kindly check whether our response has addressed your concerns, in particular:

  • Q1 (common protocol): We added a first-attempt comparison in which all checkpoints use the same harness, questions and limits (Table 5), and revised the abstract to rest on this comparison and to report both first-attempt (54.5%) and restart (61.6%) BrowseComp results.
  • Q2 (Table 3 protocol): We clarified that the ablations use selective restarts on a single run over the fixed 200-question subset, and corrected the CM-GSPO entry to 60.5% (121/200).
  • Q3 (leakage and overlap): With the filter disabled, Glasseeker-9B attempts to access benchmark artifacts in 13.8% of trajectories; we also added a near-duplicate audit of the training questions against BrowseComp (Appendix G).

We would be happy to provide any further clarification. If our responses have resolved your concerns, we would be grateful if you would consider updating your evaluation.

Reviewer_LkyBOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces a deep search framework that include a training algorithm and analysis of test-set leakage in open-web agents. It first identifies three main challenges: (1) limited transparency, (2) train-inference discrepancy, and (3) test-set leakage. Glasseek overcomes these challenges with Compaction-Managed GSPO that optimizes only sub-trajectories and anti-leakage guardrail during evaluation. The training pipeline starts with a data construction and verification process. In CS-GRPO, the same terminal reward r_i is shared across sub-trajectories. The paper also includes analysis on benchmark leakages and note models like GPT-5.5 can already directly answer up to 28% of BrowseComp questions.

Critical strengths
  • The paper tackles a timely problem, deep search agents, and conducts thorough analysis on evaluation leakage, which is a well-known problem in the community. It’s important to use evaluation frameworks that reliably reflect the capabilities of the agent without allowing for cheating/leakage in the process. This paper’s breakdown on the leakage problem can help the community understand the extent to which it affects how results should be read.
  • The openness of the recipe can be of great value to the community as many other training recipes and data in the search agent space are closed.
Critical weaknesses
  • Comparisons and discussions with existing open-source DeepResearch frameworks like WebThinker and Tongyi DeepResearch are lacking. There are a number of other works that produce RL and other post-training techniques for compaction, such as ReSum. Similarly, there are works on data synthesis (e.g., WebShaper and WebSailor), and it’s unclear how this work compare against those approaches. The ablation section would benefit greatly from comparison with previous RL works.
  • The authors claim one of the key contributions is the CM-GSPO algorithm, but many of the key ideas already exist in literature, such as the length normalization, which was also used in DAPO that normalizes by the number of tokens in a group. This paper applies these ideas to the compaction setting with search agents but the novelty seems limited in this area.
Questions for authors
  • Table 1: what’s the breakdown for leakage rate for each model on each dataset?
  • In table 3, what’s the difference between + compaction and +CM-GSPO? is it the length normalization in the objective?
3 comments

W1: Comparison with Prior Work

We thank the reviewer for highlighting these related works. We clarify the distinctions in frameworks, RL optimization, and data synthesis below and will incorporate them into Related Work.

1. Framework-Level Comparison

WebThinker focuses on deep web exploration and report generation, combining a Deep Web Explorer with report-writing tools. Its repository provides model weights and inference/evaluation code.

Tongyi DeepResearch combines agentic mid-training, SFT, and RL, and supports context management through compressed report memory. It releases its model and inference/evaluation code, but its official FAQ states that there are no plans to release the training data.

Glasseek emphasizes an open development recipe spanning data-construction code, datasets, SFT/RL code, model weights, and runtime/evaluation harnesses. It also audits evaluation-time retrieval of benchmark answers or solution artifacts and provides corresponding safeguards. Such benchmark-leakage audits and safeguards are not explicitly reported in the cited WebThinker and Tongyi papers. These contributions complement their advances in agent capabilities.

2. RL Optimization Comparison

Tongyi DeepResearch uses GRPO with DAPO-style token-level ratios and an objective averaged over pooled response tokens. ReSum introduces summary-conditioned segmented training and broadcasts each rollout's terminal advantage to its segments. Since its paper does not fully specify token-level optimization details or provide public RL training code, we reimplement it based on our understanding of the paper, using token-level PPO ratios and token-mean loss aggregation.

CM-GSPO combines turn-level importance ratios/clipping with rollout-level loss aggregation. It weights the token-mean loss of segment kk in rollout ii by Li,k/LiL_{i,k}/L_i, its share of the rollout's unmasked execution tokens, before averaging across rollouts. This removes the additional aggregation weight introduced by independently averaging and summing segment losses. Q2 details our ReSum-style reimplementation and the controlled ablations.

3. Data-Synthesis Comparison

  • Structural construction and answer identifiability. WebShaper constructs questions through formalized Knowledge Projections and layer-wise expansion, while WebSailor combines graph sampling with information obfuscation. Glasseek uses selective evidence-tree expansion and explicitly distinguishes global target identifiability from local intermediate ambiguity: the combined constraints should identify the seed target, without requiring every intermediate entity to be uniquely recoverable from its immediate child clues (Appendix A.2). Root clues are assigned complementary roles: core clues jointly identify the target, while factually grounded distractors retain broader candidate sets. WebSailor’s analysis acknowledges that some generated questions may admit multiple valid answers; our pipeline explicitly searches for competing targets to detect and repair such ambiguity.

  • Verification-guided evidence-tree repair. WebShaper already incorporates validation feedback during expansion. Our distinction lies in the verification targets and the resulting repair operations. Glasseek combines alternative-answer search, evidence-grounded solution verification, and difficulty assessment using a web-enabled solver. When verification identifies a competing answer or insufficient evidence, the repair agent can restore omitted constraint chains. When a successful low-turn trajectory exposes a potential shortcut, it guides the agent to weaken, replace, or prune overly revealing clues. The question is regenerated and verified after these edits. Thus, feedback acts directly on the evidence structure underlying the complete question (§3.1 and Appendix A.3).

  • Empirical evidence and reproducibility. Our released SFT dataset contains 5,762 trajectories covering 4,448 unique questions. The 9B SFT baseline achieves 55.5% on the 200-question BrowseComp ablation subset. This demonstrates the usefulness of the resulting supervision under our experimental setting; isolating the relative contribution of different synthesis methods would require matched training and evaluation conditions. We also release the executable data-construction pipeline. Although WebShaper and WebSailor release generated data or examples, their official repositories do not currently provide the corresponding end-to-end construction implementations. Our release enables direct inspection and extension of the synthesis and verification procedures.

The additional baseline comparisons are described in Q2; the ratio granularity and loss aggregation must be distinguished when interpreting these ablations.

W2: Limited Algorithmic Novelty of CM-GSPO

We thank the reviewer for highlighting the connection to DAPO and welcome the opportunity to clarify the distinction. CM-GSPO addresses how to optimize compaction-separated execution sub-trajectories without treating fragments of the same rollout as independent rewarded samples. Building on GSPO, it computes and clips ratios at the interaction-turn level, using the same recorded rollout contexts for current- and behavior-policy likelihoods. Each fragment shares its original rollout’s terminal advantage, with a weight of Li,k/LiL_{i,k}/L_i applied to its token-mean objective. This preserves equal outer weighting of original rollouts and removes the extra aggregation weight introduced by independently averaging their fragments. DAPO instead uses token-level ratios and pools response tokens across sampled trajectories, giving longer rollouts greater aggregate weight. The distinction therefore concerns both the ratio/clipping unit and the aggregation of compaction-separated fragments: CM-GSPO retains the original rollout as the reward and outer aggregation unit while optimizing its execution sub-trajectories under their recorded contexts.

Q1: The breakdown for leakage rate for each model on each dataset

We added Table 6 in Appendix F and cite it in the discussion of Table 1 in Section 4. The new table reports the breakdown for the four checkpoints and three datasets in this additional audit. Each percentage is the share of evaluation trajectories in which the agent attempted to access benchmark-related artifacts. The numbers in parentheses are the dataset question counts.

Model / checkpointBrowseComp-ZH (289)Seal-0 (111)XDS-2510 (100)
DeepSeek-V4-Pro0.38%0.95%0.00%
Claude-Opus-4.50.00%1.87%0.00%
Apodex-1.0-4B-SFT3.93%1.85%1.11%
Glasseeker-9B (full CM-GSPO)3.77%1.98%1.16%

For Glasseeker-9B, the observed rate was highest on BrowseComp-ZH (3.77%). On XDS-2510, we observed attempts for Apodex-1.0-4B-SFT and Glasseeker-9B, while the observed rate was 0.00% for DeepSeek-V4-Pro and Claude-Opus-4.5.

Access to benchmark artifacts with the filter disabled (Table 1). We ran an additional evaluation with the anti-leakage filter disabled. Glasseeker-9B attempted to access benchmark-related artifacts in 13.8% of evaluation trajectories. The 61.6% accuracy reported on the full BrowseComp test set was obtained with the leakage filter enabled and selective restarts allowed.

Q2: The difference between + compaction and +CM-GSPO

We distinguish the unit used to compute the importance ratio from the unit used to normalize the policy loss. In Vanilla GSPO, both are defined per session. Without compaction, a rollout consists of a single session, so the ratio and the loss normalization both cover the full trajectory. + Compaction retains the same session-level rule, but each session now corresponds to a sub-trajectory between compaction events. Each sub-trajectory therefore has its own ratio and independently averaged loss. Summing these losses gives a rollout more weight simply because it was split into more pieces.

The two additional baselines in Table 3 clarify this distinction. Since ReSum does not fully specify token-level optimization details or provide public RL training code, we reimplement its segmented training and advantage broadcasting based on our understanding of the paper. Our ReSum-GRPO implementation uses token-level PPO ratios and token-mean loss aggregation without our rollout-level reweighting. + Compaction & Turn IS retains the compaction and session-level loss normalization of + Compaction, but computes one ratio per turn instead of one per sub-trajectory. With other settings held fixed, comparing these two GSPO variants isolates the change in ratio granularity.

CM-GSPO retains the turn-level ratio of + Compaction & Turn IS and changes how the sub-trajectory losses are combined. For rollout ii, it weights the mean loss of sub-trajectory kk by Li,k/LiL_{i,k}/L_i, its share of the rollout’s unmasked execution tokens. These weights sum to one within each rollout: splitting a rollout into more segments does not, by itself, increase its aggregate weight. With other settings held fixed, the comparison with + Compaction & Turn IS isolates rollout-level loss aggregation under compaction. On BrowseComp-200, switching to turn-level ratios raised accuracy from 55.0% to 57.0% (+2.0 percentage points), and adding rollout-level reweighting raised it to 60.5% (+3.5 percentage points). DAPO uses a different denominator: it computes token-level ratios and averages token losses across trajectories using the total number of response tokens in the batch. A longer rollout therefore contributes a larger share of the DAPO loss, whereas CM-GSPO normalizes within each rollout before averaging across rollouts.

Dear Reviewer LkyB,

Thank you again for your valuable feedback. As the discussion period is coming to a close, we wanted to kindly check whether our response has addressed your concerns. We would be happy to provide any further clarification. If our responses have resolved your concerns, we would be grateful if you would consider updating your evaluation.

Reviewer_CV69OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

Glasseek commits to releasing its data construction recipe, training data, model weights, training algorithm and contamination free evaluation for deep-search agents. Its proposed method, CM-GSPO, splits rollouts at context-compaction boundaries, trains execution segments under their recorded contexts, and adjusts segment weights to preserve normalization within each original rollout. It also audits benchmark-answer leakage and provides safeguards in the evaluation harness.

Overall, the strongest case for this paper is its emphasis on the reproducibility of its recipe including data generation and training algorithm, results for 4B and 9B size models, and attention to evaluation integrity. I have reservations about how the positioning of the proposed training algorithm and the lack of component level ablations.

Critical strengths
  • I appreciate the commitment given to data construction and open-sourcing the recepie not just the dataset. a great number of technical reports from Tongyi’s WebSailor: Navigating Super-human Reasoning for Web Agent and WebShaper: Agentically Data Synthesizing via Information-Seeking Formalization describes interesting ideas like graph sampling and information obfuscation, an and agentic search-expansion procedure to generate difficult training data. These reports provide useful ideas, but their public data releases are limited (WebSailor provides example SailorFog-QA samples, and WebShaper releases 500 QA pairs) and the code for replicating these recipe is not available: Glasseek’s commitment to releasing the complete construction pipeline and training data is therefore welcome.
  • The reported results are strong, Table 3 shows improvements over GSPO with compaction across difficult deep-search benchmarks: 55.0 to 61.6 on BrowseComp, 42.3 to 50.0 on Seal-0, and 65.0 to 75.7 on GAIA-Text.
  • The leakage audit is also a commendable effort towards examining actual trajectories and measuring performance before and after safeguards provides useful evidence about how evaluation can go wrong.
Critical weaknesses
  1. My main concern is that the experiments do not yet establish the benefit of CM-GSPO over prior existing training that have already explored training under context-compaction:

    So the new part in CM-GSPO is two things. It applies GSPO separately to each segment between context compressions. It also changes how much each segment adds to the training loss.

    The paper does not clearly show what CM-GSPO improves over these methods. Their objectives are different, but Table 3 does not compare CM-GSPO with any of them. A controlled comparison, mainly with ReSum-GRPO, would help to show the benefit of the training objective and its parts.

  2. Similarly, on the data front, the introduction says complete training recipes "remain largely proprietary". But prior works already open-source both the training recipe and datasets. Fathom-DeepResearch: Unlocking Long Horizon Information Retrieval and Synthesis for SLMs releases DuetQA, DeepResearch-SFT, model weights, and search infrastructure. Beyond Ten Turns: Unlocking Long-Horizon Agentic Search with Large-Scale Asynchronous RL releases ASearcher's training data, synthesis agent, and training code. The openess claim might be a bit overstated, though I understand we need more contributions here.

  3. I also would not be very comfortable with the "first systematic audit" claim. Han et al.'s Search-Time Data Contamination already examines contamination from benchmark-answer retrieval, measures the effect of blocking Hugging Face, and releases evaluation logs. It is also not well established in the paper whether GlassSeek's safeguards catch leaked answers on new websites or pages that paraphrase the benchmark questions which would be an actual contribution. Reporting how often they block legitimate evidence and how well the method generalizes would significantly help in qualifying this contribution.

Questions for authors
  • How does CM-GSPO compare with ReSum-GRPO and CompactionRL under a matched training setup? As in, the same starting checkpoint, training data, tools, rewards, and search budget. This would help to show what CM-GSPO improves over existing methods.
  • What happens if segment-level GSPO ratios and loss reweighting are tested separately? Training curves would also help to support the stability claim.
2 comments

Response to the reviewer

Thank you for recognizing our data-construction recipe and leakage audit. We have clarified the comparison with prior work and added two baselines to Table 3.

1. CM-GSPO versus prior training methods under compaction

ReSum-GRPO segments rollouts at summarization boundaries and broadcasts each rollout’s group-normalized advantage to its segments. Its published objective uses segment-level importance ratios. Our implementation follows its segmentation and advantage broadcasting but uses token-level PPO ratios. WebResearcher applies GSPO to research rounds under reconstructed states and groups rounds from trajectories for the same question. CM-GSPO clips one length-normalized ratio per interaction turn, gives each rollout equal outer weight, and weights each segment by its share of that rollout’s unmasked execution tokens.

We trained our ReSum-GRPO implementation and CM-GSPO from the same 9B SFT checkpoint with the same data, tools, reward function, and search budget per training rollout. Table 3 reports accuracy (%):

MethodBrowseComp-200BrowseComp-ZHSeal-0XDS-2510GAIA-Text
ReSum-GRPO (our implementation)50.053.639.643.068.0
GSPO + Compaction55.055.742.348.065.0
GSPO + Compaction & Turn IS57.059.941.447.067.0
CM-GSPO60.564.050.050.075.7

Each BrowseComp score comes from one evaluation on the same fixed 200 questions with selective restarts. The submitted Table 3 entry of 61.6% was a reporting error; the correct score is 60.5% (121/200). Table 2’s 61.6% is the full-set result.

CM-GSPO exceeds our ReSum-GRPO implementation on all five benchmarks, by 10.5 points on BrowseComp-200. CompactionRL addresses segment weighting by averaging optimized tokens across the batch, training on summary and execution tokens, and using cross-segment advantage estimation. Unlike CompactionRL, CM-GSPO requires no critic model. It normalizes within each rollout and masks summary-generation tokens. Without a matched CompactionRL run, its relative performance remains open.

2. Component ablations

With compaction and independently averaged segment losses, switching from segment-level to turn-level ratios improves three of five scores: BrowseComp-200 rises from 55.0% to 57.0%, while Seal-0 and XDS-2510 fall by 0.9 and 1.0 points. Holding turn-level ratios fixed, rollout-level reweighting improves all five scores, including BrowseComp-200 from 57.0% to 60.5%. The total 5.5-point gain thus comprises 2.0 points from changing the ratio unit and 3.5 from reweighting. The reweighting effect with segment-level ratios remains unmeasured. Table 3 reports final checkpoint accuracy; assessing optimization stability would require training curves.

3. Earlier open releases

We agree that “remain largely proprietary” understates prior open work and will credit Fathom-DeepResearch and ASearcher in the introduction. Fathom-DeepResearch uses multi-agent self-play to construct DuetQA and pairs search and report-generation models. It releases both models, DuetQA, DeepResearch-SFT, and its search server. ASearcher obscures clues, adds evidence, checks answer uniqueness, and releases its synthesis agent, training data, and asynchronous RL code.

Glasseek provides an open recipe for training and evaluating 4B and 9B agents on questions requiring sustained search across sources, including beyond the context window. We link clues and test questions with a web-enabled solver. Shortcuts prompt us to weaken revealing clues; competing answers prompt us to restore distinguishing evidence and retest. CM-GSPO trains continued search after compaction, and our evaluation audits retrieval of published answers or prior solution traces. We release the construction pipeline, SFT/RL data, checkpoints, evaluation harness, and training code.

4. Leakage audit

Han et al. documented retrieval of benchmark answers during search, measured the effect of blocking Hugging Face, and released evaluation logs. Our Appendix F shows encounters with reference-answer fields and earlier agents’ solution traces. We also provide an evaluation-time guard.

Before tool execution, the guard checks queries and URLs for benchmark identifiers and known leakage sources. Before returning results, it compares titles, snippets, or page text with the current question, including on unseen domains. It can detect copied questions or partial rewrites retaining distinctive phrases, with a lower overlap threshold for labels such as “reference answer.” Flagged results are removed so the agent can continue searching other sources.

Dear Reviewer CV69,

Thank you again for your detailed and constructive review. As the discussion period is coming to a close, we wanted to kindly check whether our response has addressed your concerns, in particular:

  • Comparison with prior compaction-aware training: we trained ReSum-GRPO from the same 9B SFT checkpoint with the same data, tools, reward and search budget. CM-GSPO outperforms it on all five benchmarks (e.g., +10.5 points on BrowseComp-200; updated Table 3).
  • Component ablations: of the 5.5-point gain over GSPO + Compaction on BrowseComp-200, 2.0 points come from turn-level ratios and 3.5 points from rollout-level reweighting.
  • Positioning: we have revised the openness and leakage-audit claims, crediting Fathom-DeepResearch, ASearcher and Han et al., and clarified what our evaluation-time guard adds.

We would be happy to provide any further clarification. If our responses have resolved your concerns, we would be grateful if you would consider updating your evaluation.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.