---
title: 'Go-Browse: Graph-Based Web Exploration'
url: https://www.emergentmind.com/topics/go-browse
type: topic
---

# Go-Browse: Graph-Based Web Exploration

Go-Browse is a method for training web agents capable of structured exploration across web environments, with an emphasis on scalable, diverse data collection. By reframing agent exploration as an explicit graph search, Go-Browse enables efficient and comprehensive coverage of previously unseen web sites, supporting the development and fine-tuning of web agents that demonstrate improved performance on complex, deeply nested navigation tasks. The methodology is instantiated on the WebArena benchmark, yielding state-of-the-art results for open-weights models in the sub-10B parameter regime [2506.03533].

## 1. Formal Environment and Problem Setting

The underlying environment is modeled as a deterministic or stochastic transition system. The state space $S$ is composed of the current goal or task description $g$, a flattened accessibility-tree (DOM snapshot) of the web page, the history of past actions and execution errors, and a list of available browser primitives (e.g., click, fill, scroll, goto). Actions $a \in A$ are atomic browser calls such as click(elemID), scroll(x,y), fill(elemID,text), goto(url), send_msg_to_user(msg), report_infeasible(reason), executed via a browser environment simulator. The transition function $T$ is defined as $s_{t+1} = T(s_t, a_t)$.

Each trajectory $\tau = (s_1, a_1, ..., s_T, a_T)$ is evaluated against the goal $g$ by a binary reward model $R(g, \tau) \in \{0,1\}$, marking success (1) or failure (0). A central research challenge addressed by Go-Browse is efficient exploration: agents often fail to discover semantically significant or deeply-nested web pages, instead repeating unproductive action sequences when unfamiliar with the environment.

## 2. Structured Exploration via Graph Construction

Go-Browse operationalizes structured exploration by representing the web environment as a graph $G = (V, E)$, where nodes $V$ correspond to unique URLs (or page states) and edges $E$ are navigation transitions between them. Data collection proceeds by iteratively expanding this graph:

- **Graph expansion:** At each discovered node $v$, NavExplorer and PageExplorer modules propose candidate navigation tasks $g_i$. Tasks that lead from $v$ to a previously unknown URL $v'$ (confirming feasibility via the FeasibilityChecker) yield new edges $e = (v \rightarrow v')$.
- **Frontier management:** A frontier $F \subseteq V$ contains nodes that have been discovered but not thoroughly explored. Exploration iteratively selects nodes from $F$ by cost heuristics such as minimum depth (breadth-first), i.e., $v \leftarrow \arg\min_{u \in F} \mathrm{depth}(u)$, or more generally by $v \leftarrow \arg\min_{u \in F} [\mathrm{depth}(u) + h(u)]$ for a learned heuristic $h$.

The comprehensive Go-Browse algorithm is outlined by the following pseudocode:

```pseudocode
procedure Go-Browse(Websites W)
  Initialize dataset D ← ∅; Graph G=(V,E) ← (∅,∅); Frontier F ← ∅
  for each site W_i in W do
    v_root ← root URL of W_i
    V ← V ∪ {v_root};  F ← F ∪ {v_root}
    while F ≠ ∅ do
      v ← SelectAndRemoveFromFrontier(F)
      s_v ← GetCurrentState(v)
      G_nav ← NavExplorer.propose_tasks(s_v)
      G_local ← PageExplorer.propose_tasks(s_v)
      G_prop ← G_nav ∪ G_local
      G_feas ← ∅
      for each task g in G_prop do
        (is_feas, τ_fc, v_new) ← FeasibilityChecker.check_and_collect(g,s_v,R,N_max)
        if is_feas then
          D ← D ∪ {(g, τ_fc)}; G_feas ← G_feas ∪ {g}
          if v_new ∉ V then
            V ← V ∪ {v_new};  E ← E ∪ {(v → v_new)}; F ← F ∪ {v_new}
          end if
        end if
      end for
      for each g in G_feas do
        T_pref  ← Solvers.sample(g, s_v, R, prefixed=True)
        T_unpref ← Solvers.sample(g, v_root, R, prefixed=False)
        D ← D ∪ { (g, τ) | τ ∈ T_pref ∪ T_unpref }
      end for
    end while
  end for
  return D
end procedure
```

This approach enables systematic graph expansion, facilitating the reuse of exploration knowledge and reducing redundant sampling.

## 3. Dataset Construction and Composition

Go-Browse was applied to the five self-hosted WebArena domains (Shopping Admin, Shopping, Reddit, Gitlab, Map), targeting 20 distinct URLs per domain (100 in total). The resulting Go-Browse-WA dataset comprises:

| Statistic                | Value     |
|--------------------------|----------:|
| Successful trajectories  | 9,504     |
| Unsuccessful trajectories| 17,245    |
| Total trajectories       | 26,749    |
| Successful steps         | 39,339    |
| Failed steps             | 157,123   |
| Total steps              | 196,462   |
| Unique task descriptions | 3,422     |

Of the successful trajectories, 36.6% were sampled by GPT-4o-mini, 33.9% by Claude-3.7-Sonnet, and 29.5% by Qwen-2.5-7B-Instruct.

Task collection included both "prefixed" (starting from a discovered node $v$) and "unprefixed" (starting from the root) sampling strategies, supporting downstream model robustness and the ability to bootstrap weaker models, particularly for deeper graph nodes.

## 4. Model Architecture and Training Regimen

Supervised fine-tuning was conducted on the 7B-parameter Qwen-2.5-7B-Instruct language model, using only successful (goal, trajectory) pairs. Each instance is prepended by the user goal, followed by a sequence of $(\text{state} \rightarrow \text{action})$ pairs, with the model trained to autoregressively generate action sequences by minimizing cross-entropy loss. No auxiliary losses were included.

Training configuration:

- Maximum sequence length: 24K tokens
- Batch size: 8 (1 per GPU), gradient accumulation: 4 (effective batch: 32)
- Learning rate: $2 \times 10^{-5}$, Adam optimizer
- 2 epochs over ~9,504 successful trajectories
- Hardware: 8 × H100 GPUs; total ≈ 40 hours

Additionally, a comparable model was trained on the NNetNav-WA dataset (45K steps), establishing a baseline for evaluation.

## 5. Empirical Evaluation and Comparative Analysis

Performance was assessed on 812 WebArena test tasks within BrowserGym, using binary task completion rates as the metric. Key results are as follows:

| Model                  | Overall | Admin | Shopping | Reddit | Gitlab | Map   |
|------------------------|--------:|------:|---------:|-------:|-------:|------:|
| GPT-4o-mini            | 19.3%   | 19.2% | 19.3%    | 21.1%  | 20.9%  | 15.6% |
| GPT-4o                 | 37.6%   | 35.7% | 32.3%    | 50.9%  | 36.7%  | 37.5% |
| Claude-3.7-Sonnet      | 45.4%   | 37.4% | 37.0%    | 58.8%  | 52.0%  | 47.7% |
| Qwen-2.5-7B-Instruct   | 8.3%    | 7.1%  | 9.4%     | 7.9%   | 8.7%   | 7.8%  |
| NNetNav-7B             | 18.8%   | 14.3% | 20.3%    | 23.7%  | 19.9%  | 17.2% |
| **Go-Browse-7B**       | 21.7%   | 25.3% | 22.4%    | 30.7%  | 15.3%  | 17.9% |

Go-Browse-7B achieves a 21.7% overall success rate, surpassing GPT-4o-mini by 2.4% and NNetNav-7B by 2.9%. Notable observations include:

- Tasks with deeper URL-paths (depth $\geq 5$) were solved more effectively by Go-Browse-7B.
- Prefixed trajectory sampling provided a 20–30% higher success rate on deep-page navigation for Qwen-2.5.
- Task diversity is enhanced, reducing the frequency of redundant, shallow navigation episodes relative to NNetNav.

## 6. Limitations and Prospective Extensions

The current Go-Browse experiments are constrained to the five WebArena domains. Broader generalization would require further data from diverse, real-world sites (e.g., e-commerce, banking, news). Fine-tuning presently leverages only successful traces; incorporating approximately 39K unsuccessful trajectories through auxiliary failure signals or RL-style objectives is suggested as a mechanism for improved robustness. Scaling beyond the 7B parameter threshold and investigating in-context or retrieval-augmented architectures represent logical extensions for bridging the performance gap relative to closed-weight supermodels.

A plausible implication is that the explicit graph-based exploration methodology is effective not only for data efficiency but also for supporting modular task generation and enabling sophisticated downstream agent behavior in complex, multi-hop web environments.

Source: https://www.emergentmind.com/topics/go-browse