# GPT-OSS Browser Tool for Math Reasoning

The GPT-OSS
browser
tool doesn't have to point at the web — it can point at the model's own parallel attempts.
TL;DR
Stage 1:
generate N solutions independently with the
python
tool.
Stage 2:
index them as web pages and let a new solver query them via
browser
.
Result on Hard-50:
maj@8 66.0% → 73.7% (pass@8 drops 92.0% → 84.0%).
Motivation
Last year, during AIMO 2, I was lucky to join the NVIDIA NeMo-Skills team and spent most of my work time on the competition. I focused on reward models and on how to decrease the gap between maj@k and pass@k. Eventually, we developed the
[GenSelect](https://arxiv.org/pdf/2507.17797)
method, which picks the best solution from multiple attempts. However, we didn't use this method in the final submission because of time constraints.
This year, I worked on Deep Research
[project](https://huggingface.co/blog/nvidia/how-nvidia-won-deepresearch-bench)
. We built a multi-agent system capable of performing multi-step web search with hundreds of queries, synthesizing the search results, and producing a final report for a single "research" question. During this project, I noticed how powerful the GPT-OSS model with the
browser
tool can be. Eventually, we distilled this knowledge into a fine-tuned NVIDIA Nemotron 3 Super model.
Still, at the end of this competition, I decided to combine these two ideas — to use the
browser
tool for correct math solution search.
Method
The GPT-OSS model has two built-in tools:
python
and
browser
. The
browser
tool has three methods:
search
,
open
, and
find
. The LLM starts with a search query, then uses the
open
method to open a link from the search results, and can also find information on the page using the
find
method when the page content is too long.
The obvious way to use the
browser
tool is to combine it with Retrieval-Augmented Generation (RAG). But it seems that RAG is not very effective for math reasoning. Instead, I decided to use the
browser
tool for multi-stage solution search.
My pipeline consists of two distinct stages: (1) parallel solution generation, and (2) generating new solutions based on the previous ones. In the first stage, I generate solutions independently and in parallel, using the
python
tool only. In the second stage, I index the solutions generated in the first stage, add the
browser
tool and prompt the LLM to search correct solution. Here is the developer prompt for the second stage:
You are a world-class mathematical olympiad solver. Your task is to solve the given competition problem. You can use the browser tools (browser.search, browser.open) to explore solutions from AoPS forum. Search for solutions first, then critically compare different approaches against each other — check whether they agree, identify contradictions, and verify the most promising solution step-by-step with the python tool before producing your final answer. Use only https://artofproblemsolving.com/community/ URL, do NOT open external URLs (Wikipedia, WolframAlpha, GitHub, OEIS, mathjs.org, etc.). Remember, browser results show solutions from other people — some may be wrong, so always verify claims independently using the python tool before trusting them. Put your final answer within \boxed{}. The final answer must be a non-negative integer between 0 and 99999.
You can see that I present the generated solutions as if they retrieved from the AoPS forum.
As an alternative solution, I also tried concatenating the summaries directly into the prompt instead of exposing them through the
browser
tool:
You are a world-class mathematical olympiad solver. Your task is to solve the given competition problem.
Below are several solution approaches proposed by other solvers. Each approach explains a method and its reasoning. Critically compare the approaches against each other — identify where they agree or contradict, note which ideas look promising and which ones may be flawed, and verify the most promising approach step-by-step with the python tool before committing to an answer. Some approaches may be wrong, so always double-check claims with python before trusting them.
## Candidate approaches
{approaches}
Put your final answer within \boxed{}. The final answer must be a non-negative integer between 0 and 99999.
This variant uses no
browser
tool at all — the solver just sees all candidate approaches up-front in its context.
Results
I tested this idea on 50 problems from
[Hard Math Problems for AIMO 3](https://www.kaggle.com/datasets/zfturbo/hard-math-problems-for-aimo-3)
dataset.
Metric
stage 1 (1 run)
stage 2 concatenate (avg of 4 runs)
stage 2 browser (avg of 6 runs)
pass@1
48.5%
73.1%
67.1%
pass@2
69.2%
78.8%
76.5%
pass@4
85.1%
81.7%
81.6%
pass@8
92.0%
83.5%
84.0%
maj@4
52.0%
75.0%
71.0%
maj@8
66.0%
78.0%
73.7%
You can see that the second stage improves the maj@k scores but decreases the pass@8 score. The concatenate version actually matches or beats the browser-based approach — just showing all candidate approaches up-front in the prompt is enough to get most of the gain. However, the
browser
approach should scale better to many more parallel attempts. It could also extend naturally to RAG-style settings, or used in the scenario where the pool of summaries keeps growing over time.
Unfortunately, I didn't manage to make it work within the competition constraints. My final submission
[gpt-oss-math-search](https://www.kaggle.com/code/sorokin/gpt-oss-math-search)
only scored 36, where I applied the second stage only to tied cases.
Takeaways
Sharing context between parallel attempts beats independent sampling on maj@k.
A
browser
-style tool can be considered as one alternative interface for that sharing.