WebWorld: A Large-Scale World Model for Web Agent Training

ArXiv: 2602.14721

🎯 Pitch

Training web agents on real websites is crippled by latency, rate limits, and the risk of irreversible actions, but this paper shows that a world model trained on over 1M open-web trajectories can simulate environments convincingly enough to replace live interaction—fine-tuning on its synthetic data alone boosts WebArena performance by over 10 points, matching GPT-4o. Remarkably, the same model beats GPT-5 when used for inference-time lookahead search and generalizes to code, GUI, and game tasks after lightweight fine-tuning, all following clean scaling laws with no saturation.

1. Executive Summary

This paper introduces WebWorld, a large-scale open-web simulator trained on over one million real-world interaction trajectories—roughly 100× more than prior trained world models—using a scalable hierarchical data pipeline that combines randomized crawling, autonomous LLM-guided exploration, and task-oriented execution. Intrinsic evaluation on the authors' new WebWorld-Bench (spanning nine dimensions with dual metrics of Factuality Score and Web Turing Score) shows WebWorld achieving simulation performance comparable to Claude-Opus-4.1 and Gemini-3-Pro, while extrinsic evaluation demonstrates that fine-tuning Qwen3-8B/14B on WebWorld-synthesized trajectories yields gains of +9.9% on MiniWob++ and +10.9% on WebArena, with the 14B model reaching performance on par with GPT-4o. When deployed as a world model for inference-time lookahead search, WebWorld outperforms GPT-5, and the model exhibits predictable scaling laws across sizes with no signs of saturation, establishing that web-scale world models can substitute for real-environment interaction in agent training while generalizing across code, GUI, and game domains through lightweight fine-tuning.

2. Context and Motivation

The Core Problem: Scaling Web Agent Training Is Fundamentally Bottlenecked by Real-World Interaction

The paper addresses a deceptively simple problem: how do you train autonomous web agents at scale when every real-world interaction is slow, expensive, and potentially dangerous? Web agents—LLM-based systems that navigate browsers, fill forms, click buttons, and complete multi-step tasks—require massive amounts of interaction experience to generalize robustly. But collecting that experience in live browser environments is bottlenecked by three irreducible constraints:

1. Network latency and throughput limits. Every action a web agent takes—clicking a button, loading a new page, waiting for a dropdown to render—incurs real-world latency. A single trajectory of 10–30 steps can take minutes to execute, and rate limits on websites (especially commercial ones with anti-scraping protections) cap how many interactions can be performed per unit time. Scaling to the millions of trajectories that modern LLM training demands is simply infeasible through live browsing alone.

2. Safety and irreversibility. Web interactions carry real-world consequences. An agent that mistakenly submits a form, initiates a financial transaction, or posts content to a public forum has performed an action that cannot be undone. The paper cites this explicitly: "interactions require careful safety considerations, as some actions (e.g., submitting sensitive forms or initiating transactions) may be irreversible." This makes exploration inherently risky—you cannot let an untrained agent freely experiment on production websites, which creates a circular dependency: the agent needs experience to become safe, but collecting experience requires safety.

3. Access restrictions and anti-crawling measures. Many websites actively block automated access through CAPTCHAs, IP rate limiting, bot detection, and terms-of-service restrictions. Even for legitimate research purposes, maintaining consistent access across the diversity of websites needed for generalist agent training is an operational challenge that grows with scale.

These three constraints create what the paper frames as a scaling wall: the experience required to train capable web agents far exceeds what can practically be collected from real browsers. This is the gap WebWorld aims to fill.

Why This Problem Matters: The Experience Era and the Pretraining-Inference Gap

The paper situates this problem within a broader shift in the field, invoking Silver and Sutton's (2025) framing of the "experience era"—the idea that continued progress in AI will come not from scaling pretraining data but from agents that learn through sustained interaction with environments. This is echoed by recent work showing that LLM-based agents improve substantially when given more interaction experience (Yang et al., 2025; Xi et al., 2025; Huang et al., 2025).

However, there is a critical asymmetry: while pretraining benefits from the effectively infinite supply of static text data on the internet, interaction data—sequences of states, actions, and outcomes—is fundamentally scarce. You cannot crawl interaction data the way you crawl text; every interaction requires live execution. This means the field has a data scaling problem specific to the agentic domain that pretraining scaling laws do not address.

The practical stakes are high. Web agents are being deployed for:

• Automated customer support and form-filling on enterprise platforms
• E-commerce tasks (comparison shopping, booking, order tracking)
• Data entry and workflow automation across SaaS tools
• Accessibility assistance for users navigating complex web interfaces
• Research and information synthesis across multiple web sources

For any of these applications, the difference between an agent that succeeds 50% of the time and one that succeeds 80% of the time is the difference between a research prototype and a deployable product. Getting to 80%+ reliability requires training on diverse, challenging trajectories—and that requires a scalable source of interaction experience.

The paper also highlights a theoretical motivation: world models have been a foundational concept in reinforcement learning since at least Ha and Schmidhuber (2018), enabling agents to learn in simulation rather than the real environment. Extending this paradigm to the open web—with its extreme diversity of page structures, interaction patterns, and dynamic behaviors—represents a significant technical challenge whose solution would validate that world models can scale beyond controlled domains (games, robotics simulations) to the uncontrolled, real-world digital environment that matters most for commercial applications.

Where Prior Approaches Fall Short

The paper identifies three categories of prior work, each with specific limitations that WebWorld addresses:

1. Prompting proprietary LLMs as world models (UI-Simulator, Simia). The most straightforward approach is to use a frontier model like GPT-4o or o4-mini as a zero-shot or few-shot world model: given an instruction and interaction history, prompt the LLM to predict the next browser state. Wang et al. (2025) demonstrated this with UI-Simulator, which uses retrieval-augmented simulation to synthesize trajectories targeting agent weaknesses. Li et al. (2025b) extended this with Simia, generating trajectories from tool specifications.

The limitations are structural rather than performance-related:

• Cost and latency: Every simulated step requires an API call to a proprietary model, making large-scale synthesis (millions of trajectories) economically prohibitive for most research groups and startups.
• Closed nature: The models are black boxes. Researchers cannot inspect, modify, or fine-tune them for specific domains. The world model's behavior is whatever the API provider ships.
• No clear scaling path: You cannot invest compute to improve the simulator's fidelity—you are locked into whatever quality the API provides at whatever price the provider sets.

2. Trained world models restricted to closed benchmark environments (DreamGym, WMA, WebSynthesis, WebEvolver). More recent work has shifted toward training dedicated world models, but the paper identifies a critical shared limitation: these models are trained on data collected from narrow, closed environments—primarily WebArena, WebShop, or similar research benchmarks.

The consequences of this restriction cascade through every aspect of model capability:

• Dataset scale is small: Ranging from ~4K trajectories (WebSynthesis) to ~70K (Word2World), compared to WebWorld's 1.06M. This is not just a numbers game—the diversity of web patterns is so vast that small datasets inevitably miss large swaths of the internet.
• Generalization is poor: A model trained on WebArena's four websites (e-commerce, GitLab, Reddit clone, content management) does not learn the interaction patterns of news sites, social media, travel booking, healthcare portals, educational platforms, or government services. The paper explicitly notes this: "existing models exhibit poor generalization because the data pipeline is not easily scalable."
• Task diversity is artificial: Benchmark environments provide pre-scripted tasks with known success criteria. Real web interaction involves open-ended exploration, ambiguous goals, and the need to recover from unexpected states—none of which are well-represented in benchmark training data.
• Long-horizon capabilities are absent: Several prior models (WebEvolver, WMA, WebSynthesis) are explicitly limited to single-step predictions, conditioning only on the most recent state rather than the full interaction history. This precludes learning long-range dependencies—e.g., "I filled out a form three steps ago, so this confirmation page should show my name"—that are essential for coherent multi-step simulation.

A specific technical consequence the paper highlights: several prior open-source baselines achieve near-zero scores on WebWorld-Bench not because the underlying approaches are fundamentally flawed, but because their training data distribution is so narrow that they cannot handle the diverse formatting, website structures, and interaction patterns present in open-web evaluation. The models overfit to the specifics of their training benchmarks.

3. Agent-driven synthesis methods that remain environment-bound (Word2World, WebSynthesis with MCTS). Some prior work attempts to address diversity by having agents autonomously generate their own training trajectories through exploration. Word2World uses MCTS to explore, while WebSynthesis integrates world models into the MCTS loop. The paper identifies two issues:

• The exploration is still confined to benchmark environments. An agent exploring WebArena will never encounter a travel booking workflow, a social media feed, or a healthcare portal—regardless of how sophisticated its exploration strategy is.
• The data representation is simplified or proprietary. Word2World uses a "simplified, flattened text stream representation" distinct from standard A11y Tree or HTML, making its outputs incompatible with downstream agent training pipelines that expect standard web formats.

4. The evaluation gap: no holistic benchmark for web world models. The paper also identifies a methodological gap in how prior work evaluates world models. Existing intrinsic metrics fall into two camps, both of which the paper argues are inadequate for open-web scenarios:

• Structural metrics (DOM tree similarity, element-level alignment) produce "uniformly low scores due to HTML's high variance"—two functionally identical web pages can have radically different DOM structures depending on ad insertions, personalization, A/B testing, or minor CSS differences. This makes pixel-perfect matching a poor proxy for functional correctness.
• Semantic metrics (ROUGE/BERTScore between predicted and actual state change descriptions) "fail to differentiate model capabilities when state changes are complex"—if a model predicts "the page changed" and the real outcome is "a popup appeared with a form," both receive low semantic scores even though the model's prediction is technically true.

This evaluation gap means that prior work cannot reliably compare world model quality across different approaches, training regimes, or model scales. The field lacks a shared yardstick.

How WebWorld Positions Itself

The paper's positioning can be understood along four axes that directly address the limitations above:

Axis 1: From closed-benchmark to open-web training. The fundamental design choice that differentiates WebWorld is training on the open web rather than on benchmark sandboxes. The data pipeline (Section 3.2) sources URLs from large-scale pretraining corpora (FineWeb, CCI 3.0), which provides two advantages: (a) coverage across hundreds of thousands of distinct websites spanning diverse domains (e-commerce, technology, education, lifestyle, etc., as shown in Figure 3a), and (b) alignment with the base model's pretraining priors, since the same URL sources were used for pretraining Qwen3. This is not just about more data—it is about a qualitatively different data distribution that captures the natural diversity of the web rather than the artificial regularity of research benchmarks.

Axis 2: From single-turn to long-horizon, reasoning-enabled simulation. Prior trained world models are restricted to single-step prediction or short contexts. WebWorld explicitly trains for 30+ step trajectories (Figure 3c shows the distribution reaching up to 30 turns), with a two-stage curriculum that first learns transition dynamics from 1.06M trajectories, then activates explicit reasoning via only 1K chain-of-thought samples (Section 3.5). The paper argues this is a "knowledge-then-reasoning-pattern injection recipe" that is essential: attempting to train reasoning from scratch on the base LLM without first learning web dynamics requires 10× more CoT data for worse performance (Table 7).

Axis 3: From proprietary API to open, scalable, inspectable models. By releasing trained weights at 8B, 14B, and 32B scales, WebWorld enables researchers to fine-tune the world model for specific domains, run it at zero marginal cost per step, and inspect its behavior. The paper explicitly positions this as enabling a "replicable recipe for world model construction."

Axis 4: From fragmented evaluation to a unified benchmark. WebWorld-Bench (Section 4) provides the first evaluation framework specifically designed for open-web world models, with nine dimensions (long-horizon consistency, base semantics, fine-grained sensitivity, multi-tab, multi-format robustness across four formats, and natural language Web2NAL) and two complementary metrics (Factuality Score for functional correctness, Web Turing Score for perceptual realism). The paper validates this benchmark by showing that it produces consistent model rankings across different LLM judges (Table 4) and that it can meaningfully differentiate models that appear superficially similar under prior metrics.

The paper does not claim to have invented world models for web agents—it acknowledges the lineage from WebDreamer, WMA, DreamGym, and others. Rather, its contribution is the scaling recipe: the specific combination of open-web data collection at scale, hierarchical pipeline design, format enrichment, two-stage reasoning activation, and multi-dimensional evaluation that together make world models practical for real-world agent training rather than just a research curiosity. The core bet is that web world models, like LLMs themselves, benefit from scale—and that the investment in building a large-scale open-web training pipeline pays off in generalization that small-scale benchmark-trained models cannot achieve.

3. Technical Approach

3.1 Reader Orientation

WebWorld is a family of autoregressive language models (at 8B, 14B, and 32B parameter scales) that have been fine-tuned to simulate browser behavior: given a natural language instruction and a history of web page states and agent actions, the model predicts what the next browser state will look like. The core problem it solves is that training capable web agents requires millions of interaction trajectories, but collecting these from real browsers is bottlenecked by network latency, website rate limits, and safety concerns—WebWorld provides a learned surrogate for the real browser environment, trained on 1.06 million real-world trajectories collected from the open web, so that agents can practice and learn in simulation at zero marginal cost per step.

3.2 Big-Picture Architecture (Diagram in Words)

The WebWorld system has five major components:

1. Hierarchical Data Collection Pipeline — a three-level strategy (randomized crawling, autonomous LLM-guided exploration, task-oriented execution) that harvests 1.06M real-world interaction trajectories from the open web, spanning hundreds of thousands of distinct websites. This is the foundation that makes the world model general.
2. Trajectory Formatting and Filtering — all collected trajectories are converted into a unified format: sequences of (state_t, action_t, state_{t+1}) tuples where states are represented as A11y Trees (accessibility trees extracted via Playwright). Rule-based and LLM-based filtering removes unsafe content, unreachable pages, and degenerate trajectories.
3. Data Enrichment and Augmentation — the base A11y Tree trajectories are expanded into multiple output formats (HTML, XML, Markdown, Playwright references) and auxiliary tasks (web generation, descriptive simulation, general world modeling, chat) to prevent format overfitting and catastrophic forgetting.
4. Two-Stage Training Curriculum — Stage 1 trains the model to predict state_{t+1} from (instruction, history, action_t) on the full 1.06M trajectories, learning raw web dynamics. Stage 2 continues training on only 1K chain-of-thought-augmented samples that interpose explicit reasoning between action and predicted state, activating the model's ability to explain state transitions.
5. Inference-Time Deployment — the trained world model can be used in two modes: (a) as a trajectory synthesizer, where an Abstract-and-Instantiate pipeline generates diverse training data for downstream agents, and (b) as a lookahead simulator for inference-time search, where candidate actions are evaluated by simulating their outcomes before execution.

Information flows as follows: candidate URLs are extracted from pretraining corpora → the hierarchical pipeline collects trajectories from those URLs → trajectories are filtered, formatted as A11y Trees, and enriched into multi-format data → Stage 1 trains the base model to predict next states → Stage 2 activates reasoning on 1K CoT samples → the trained WebWorld model synthesizes trajectories for agent training or serves as a lookahead simulator.

3.3 Roadmap for the Deep Dive

• First, the autoregressive formulation (Equations 1 and 2), which defines exactly what probability distribution WebWorld learns and why maximum likelihood on trajectories is the right objective.
• Second, the hierarchical data collection pipeline (Levels 1–3), since it is the core innovation that enables scale and diversity—without this, the model would be just another benchmark-trained simulator.
• Third, the filtering and quality control mechanisms, which determine what fraction of collected data survives to training and why rule-based filtering (rather than LLM-based) is used for trajectories specifically.
• Fourth, the data enrichment strategy (five auxiliary tasks across Web and General domains), since this is what prevents format overfitting and preserves the base model's conversational abilities.
• Fifth, the CoT synthesis and two-stage curriculum (Section 3.5), which is the critical "knowledge-then-reasoning" recipe that the paper ablates in Table 7.
• Sixth, the dataset statistics (Figure 3 and Table 11), which quantify the scale and diversity achieved by the pipeline.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and data engineering paper whose core idea is that web world models benefit from the same scaling principles as language models—more diverse data from a broader distribution yields better generalization—and that the key technical challenge is building a data pipeline that can harvest interaction trajectories from the open web at sufficient scale and quality.

Autoregressive World Model Formulation

The paper models the browser world as a conditional autoregressive generation problem. The world model is a probability distribution $P_\theta$ parameterized by a causal language model, which predicts the next browser state given the task instruction and the interaction history so far:

$s_{t+1} \sim P_\theta(\cdot \mid I, h_t)$

where $I$ is the natural language instruction describing the task (e.g., "Book a flight to London"), $h_t = (s_0, a_0, \ldots, s_t, a_t)$ is the interaction history consisting of alternating states and actions up to time $t$, and $s_{t+1}$ is the predicted next state. The state $s_t$ represents the browser page at time $t$, encoded as an A11y Tree—a structured, hierarchical representation of interactable page elements extracted via the browser's accessibility API. The action $a_t$ is a Python-style function call from a unified action space (e.g., click(bid='12'), fill(bid='7', text='London')).

What this formulation does: at each step of a simulated interaction, the model receives the complete history of what the user wants, what pages they have seen, and what actions they have taken so far, and it must produce a distribution over possible next page states. The actual next state is sampled from this distribution (or taken as the argmax for deterministic evaluation). This is a next-state prediction problem, not a next-action prediction problem—the model learns environment dynamics, not agent policy.

Why this formulation rather than alternatives: The paper could have formulated the problem as joint modeling of $(s_{t+1}, a_{t+1})$ (predicting both the next state and the next action), but this would conflate environment dynamics with agent behavior. By conditioning on the action as input and predicting only the state as output, the world model is agnostic to which agent is acting—it can simulate outcomes for any agent's actions, making it reusable across different agent architectures and training regimes. This also means the world model can be trained on trajectories from diverse agents (random crawlers, LLM-guided explorers, task-executing agents) without learning their specific behavioral biases.

The training objective is maximum likelihood estimation over a dataset $\mathcal{D}$ of trajectories:

$\mathcal{L}(\theta) = -\mathbb{E}_{\tau \sim \mathcal{D}} \sum_{t=0}^{T-1} \log P_\theta(s_{t+1} \mid I, h_t)$

where $\tau = (I, s_0, a_0, \ldots, s_T)$ is a complete trajectory sampled from the dataset $\mathcal{D}$, $T$ is the trajectory length (varying per example, up to 30 turns), and the sum runs over all state transitions in the trajectory.

What it computes: for each trajectory in the training set, at each time step $t$, the model is given the instruction and history and must assign high probability to the actual next state that occurred in the real browser. The loss is the negative log-likelihood of the true next state under the model's predicted distribution, summed over all steps and averaged over all trajectories. Minimizing this loss encourages the model to predict states that match real browser behavior.

Why this form: this is the standard autoregressive language modeling objective applied to state sequences. It has the crucial property that it trains the model to be consistent: the prediction at step $t+1$ must be compatible with the prediction at step $t$, because both are conditioned on the same growing history. Alternatives like independently predicting each $s_{t+1}$ from a fixed context window would not learn the causal structure of web interaction. The maximum likelihood framework also naturally handles the stochasticity of web environments—multiple valid next states can exist for the same action (e.g., due to A/B testing, ad randomization, or loading variations), and the model learns to represent this uncertainty in its output distribution.

The Hierarchical Data Collection Pipeline

This is the paper's central technical contribution: a three-level strategy for collecting interaction trajectories from the open web at scale. The key insight is that no single collection strategy can simultaneously provide breadth (coverage of many websites), realism (naturalistic agent behavior), and task alignment (goal-directed trajectories useful for downstream training). The hierarchical design assigns each objective to a different level.

Data format. Before the pipeline begins, all states are standardized to A11y Trees extracted via the Playwright API from the BrowserGym framework. The A11y Tree is chosen over raw HTML for three stated reasons: (1) universal applicability across web and GUI environments, (2) high information density (it strips rendering noise like CSS and scripts, keeping only interactable elements and their semantic roles), and (3) LLM-friendly structure (it is hierarchical, text-based, and compact). Each node in the A11y Tree encodes its role (e.g., button, textbox, link), its properties (e.g., focused, required, expanded), and a unique identifier (bid) that agents use for action grounding—when an agent issues click(bid='12'), the bid maps to a specific node in the A11y Tree. The paper notes that A11y Tree achieves "decent token compression compared to raw HTML while preserving all action-critical semantics."

URL sourcing. The pipeline starts by extracting target URLs from large-scale pretraining corpora: FineWeb (English, approximately 618K URLs) and a quality-filtered subset of CCI 3.0 (Chinese, approximately 64K URLs). This is a critical design choice motivated explicitly by the paper: "ensuring alignment between the world model's training distribution and the base LLM's pretraining priors." The intuition is that the base model (Qwen3) has already seen text from these URLs during pretraining, so it possesses latent knowledge about the structure and content of these websites that can be activated through world model fine-tuning. The paper also adds "curated lists of high-traffic English and Chinese websites (e.g., e-commerce, social media, news portals)" to supplement the corpus-derived URLs.

Level 1: Randomized Crawling (293K trajectories, 43.3% of total data).

This is the breadth-maximizing stage. Rule-based crawlers (not LLM-guided agents) are deployed on websites from the pretraining corpus URL list. At each page, the crawler randomly samples an executable action from the current page's A11y Tree—clicking a button, filling a form field, selecting a dropdown option, or following a link—and executes it. Each website receives 3–10 steps of random interaction before the crawler moves to the next URL.

What this produces: 293,511 trajectories spanning hundreds of thousands of distinct websites across diverse domains (the domain distribution in Figure 3a shows coverage of Lifestyle, Technology, Education, E-Commerce, News, Government, Health, and more). These trajectories are short (3–10 steps), lack task structure (actions are random, not goal-directed), and may include degenerate interactions (clicking non-interactive elements produces no state change). But their value is coverage: they teach the model the basic transition dynamics of the web—what happens when you click a link, fill a text field, or navigate between pages—across the widest possible variety of website structures.

Design rationale. The paper makes an explicit connection to pretraining: "This ensures the training distribution aligns with the model's linguistic priors from pre-training, maximizing the activation of its innate web understanding." The random crawling strategy is deliberately not trying to produce high-quality trajectories; it is trying to produce diverse trajectories that cover the support of the web's interaction distribution. Quality comes from later stages.

Level 2: Autonomous Exploration (38K trajectories, 20.4% of total data).

This level addresses the realism gap. Instead of random actions, LLM-based agents autonomously explore websites by generating their own exploratory objectives. The agents are guided by prompt design—the paper implements four complementary exploration strategies, each encoded in a specific prompt template (detailed in Appendix N.4, Figures 15–18):

1. Self-proposed Task: the prompt instructs the agent to infer a concrete user intent from the current page (e.g., "this appears to be a travel booking site, so I should try to search for flights") and execute it. This produces task-like behavior without requiring pre-specified tasks.

2. Long-horizon dependency: the prompt forces the agent to produce trajectories where later states causally depend on earlier actions—for example, filling a form on page 1 causes specific content to appear on page 3. This teaches the model about the temporal structure of web interaction that random crawling misses.

3. Composite Action interaction: the prompt requires multi-action sequences (type, select, click) rather than single-action navigation. This avoids the common failure mode where agents only click links without engaging with interactive elements like forms and dropdowns. The paper states this explicitly: "to avoid trivial navigation-only behavior."

4. Curiosity discovery: the prompt encourages systematic coverage of major sections and features of each website to maximize breadth, similar to curiosity-driven exploration in reinforcement learning.

Each trajectory can span up to 30 steps, and agents terminate naturally either by exhausting discoverable content or by hitting the step limit. This stage produces 38,356 trajectories that "reflect realistic agent behaviors"—the agents make mistakes, recover, explore dead ends, and exhibit the kind of non-optimal exploration patterns that are valuable for training robust downstream agents.

What makes this different from Level 3. The key distinction is that Level 2 agents have no external task specification. They generate their own goals based on what they see on the page. This means the trajectories capture exploratory behavior—what an agent does when it does not know exactly what it is looking for—which is a critical mode for training agents that need to operate on unfamiliar websites. Level 3, by contrast, captures task-execution behavior with known success criteria.

Level 3: Task-Oriented Execution (94K trajectories, 16.1% of total data).

This level ensures the model masters goal-directed dynamics. The paper implements a three-stage task generation pipeline:

Stage 1: Seed extraction. An LLM analyzes a website and proposes feasible user intents—specific, executable tasks that make sense for that website. For example, on a travel site, it might propose "book a flight from New York to Los Angeles on March 15th for one adult"; on an e-commerce site, "find and add to cart a pair of running shoes under $100." These seed tasks are grounded in the website's actual functionality.

Stage 2: Task diversification. For each seed task, the LLM generates multiple variants by perturbing parameters while maintaining executability on the same website. "Book a flight to London on March 15th" might become "Book a flight to Paris on April 3rd" or "Book a round-trip to Tokyo departing May 1st." The paper notes that the perturbation preserves executability—the LLM does not generate tasks requiring functionality the website does not have.

Stage 3: Paraphrasing. Each task variant is rewritten in semantically similar but linguistically diverse phrasings. "Book a flight to London" might become "I need to fly to London" or "Find me a ticket for London" or "Can you help me get to London?" This teaches the model to be robust to instruction phrasing variation.

Agents then execute these tasks on the corresponding websites. Critically, the paper states that "we retain only successful trajectories," meaning the 94,001 trajectories in this level are exclusively examples where the agent successfully completed the task. This provides clean, high-quality supervision for what correct task execution looks like—the model learns not just what happens when you click buttons, but what sequence of state transitions leads to task completion.

The final dataset combines all three levels with enriched data (described next), totaling 1,059,348 trajectories (Table 11 in Appendix D). The paper notes that the composition is deliberate: 43.3% randomized crawling for breadth, 20.4% autonomous exploration for realism, 16.1% task-oriented execution for goal alignment, with the remaining ~20% coming from open-source datasets (AgentTrek, etc.) and multi-format enrichment.

Filtering and Quality Control

The paper implements a "rigorous dual-stage filtering pipeline" applied at two points: URL filtering (before data collection) and trajectory filtering (after data collection).

URL filtering (two sub-stages).

Rule-based heuristics (Stage 1): The initial filter checks website reachability (can the browser actually load the page?) and screens for banned keywords covering sensitive categories (pornography, gambling, violence, etc.). The paper reports that only 15.7% of original URLs pass the reachability check—the vast majority of URLs from pretraining corpora are no longer accessible—and of those surviving URLs, 85.2% pass the keyword check. This is a massive filtration ratio that the paper reports matter-of-factly, implying that the 15.7% reachability rate is a known property of web-scale URL lists.

LLM-based scoring (Stage 2): Surviving URLs are evaluated by an LLM judge across four dimensions: (i) accessibility (page reachability and load success), (ii) content suitability (absence of unsafe or inappropriate content), (iii) interactivity (presence of buttons, forms, links, and other actionable elements), and (iv) engineering quality (HTML structural soundness, absence of broken markup). Each dimension receives a score from 0 to 1. Sites scoring below the average or triggering safety violations are discarded. As shown in Figure 6 (Appendix H), this retains only the top 32% of URLs that passed the initial rule-based filter.

Trajectory filtering (rule-based only). For collected trajectories, the paper applies keyword filtering to eliminate unsafe content. Additionally, it prunes transitions where "an action results in no observable state change (e.g., due to network latency or page loading failures)"—these are common in real web interaction but provide no learning signal for the world model. Trajectories exceeding 30,000 tokens or 30 turns are also discarded (the paper sets these as hard limits on sequence length and interaction depth).

A notable design choice: the paper explicitly states that trajectory filtering is "rule-based" only and does "not employ LLMs for judgment at this stage." The rationale given is: "To avoid introducing the inductive bias of a specific model." This is important because using an LLM to judge trajectory quality would bake that LLM's preferences into the training data—the world model would learn to produce states that a particular judge model considers plausible, rather than states that match real browser behavior. Rule-based filters avoid this bias by using objective criteria (keyword matching, state-change detection, length thresholds) that do not depend on any model's opinion.

Data Enrichment and Multi-Format Augmentation

The base trajectories provide rich interaction data but only in A11y Tree format. The paper identifies two risks with single-format training: (1) the model overfits to A11y Tree syntax, failing to generalize to other web representations (HTML, XML, Markdown) that agents might use, and (2) the model catastrophically forgets its base conversational abilities, since the training data consists entirely of state transition tuples with no natural language dialogue.

To address this, the paper constructs a "multi-dimensional instruction tuning dataset covering five paradigms" summarized in Table 2. These are not separate models or training stages—they are mixed into the same training data so the model learns all formats jointly.

Task 1: Multi-Format Simulator. The A11y Tree trajectories are transpiled into alternative output formats using a "two-stage parse-then-generate architecture" (Appendix G). The parsing stage converts the indentation-based A11y Tree text into a canonical nested dictionary structure by extracting node attributes (role, name, ID, properties) via regular expressions and reconstructing the hierarchy via a stack-based algorithm. The generation stage applies format-specific generators—XMLGenerator, HTMLGenerator, PlaywrightGenerator, MarkdownGenerator—that traverse the parsed tree and apply domain-specific mapping rules (e.g., ARIA-to-HTML semantic mapping, XML name sanitization, Markdown heading conversion). The result is that for each A11y Tree trajectory, the model also sees the same transition in HTML, XML, Markdown, and Playwright reference format. This teaches the model that the semantics of the state transition matter, not the specific formatting syntax.

Task 2: Web Generation. Instead of predicting the next state from (state_t, action_t), this task maps a user intent description directly to a full webpage structure: given a natural language query like "a flight booking form with departure city, arrival city, and date fields," the model generates the corresponding A11y Tree or HTML. This teaches the model about the compositional structure of web pages—how user requirements translate into UI layouts—which is a different skill from transition prediction.

Task 3: Descriptive Simulator. Given (state_t, action_t), the model outputs a natural language description of the state change rather than the next state itself: e.g., "clicking the 'Search' button causes a loading spinner to appear, followed by a list of flight results sorted by price." This is the task that several prior world models (WMA, WebEvolver) use as their primary objective, and the paper includes it as an auxiliary task to ensure the model can verbalize what it is simulating.

Task 4: General World Model. This extends the transition prediction objective beyond web pages to arbitrary natural language domains. The input is (text_state_t, action_t) and the output is text_state_{t+1}, where the state is described in free text rather than structured web formats. This teaches the model that world modeling is a general skill not tied to HTML syntax.

Task 5: General Chat. Standard conversational data is mixed in to preserve the base model's dialogue capabilities. The paper uses Ultrachat and general QA data, reformatted into the world model's training template so the model sees both "predict next state" and "respond to user" tasks during training.

The paper notes (Table 11) that the "Interaction" category—which includes Ultrachat, QA, and Web2NAL data—accounts for 547,758 samples, or roughly 52% of the total dataset. While these are not web interaction trajectories, they are critical for preventing catastrophic forgetting: without them, a model fine-tuned exclusively on state transitions would lose its ability to engage in natural conversation, making it useless for downstream agent training where instruction following is essential.

CoT Synthesis and Two-Stage Training Curriculum

The paper identifies a knowledge-reasoning gap: the 1.06M trajectories teach the model what state transitions occur, but not why they occur. An action causes a state change, but the model has no signal about the causal mechanism—why clicking this button produces that popup, why filling this form enables that submission.

To activate explicit reasoning, the paper implements a two-stage curriculum:

Stage 1: Transition Modeling. The base Qwen3 model is fine-tuned on the full 1.06M trajectory dataset using the objective in Equation 2. The training configuration (Table 9, Appendix A) specifies:

• Full parameter fine-tuning (not LoRA) with DeepSpeed ZeRO-2 (for 8B and 14B) or ZeRO-3 (for 32B)
• BF16 precision
• Base learning rate of $2.0 \times 10^{-5}$ with cosine schedule and 0.1 warmup ratio
• Per-device batch size of 2, gradient accumulation of 2 steps, effective batch size of 64 (across 2 devices for ZeRO-2)
• Maximum sequence length of 20,000 tokens with sequence packing enabled
• 1 epoch of training (approximately 7,215 steps for the 8B model on 16×A100 GPUs, taking 4 days and 1 hour)

This stage teaches the model raw web dynamics—the mapping from (instruction, history, action) to next_state.

Stage 2: Reasoning Activation. The paper randomly samples transitions from the 1.06M corpus and synthesizes chain-of-thought rationales. Given (I, s_t, a_t), the model is trained to generate intermediate reasoning steps—"analyzing page structure, interpreting user intent, predicting changes"—followed by the next state $s_{t+1}$. The training template becomes:

Given: instruction, history, action_t
Generate: thought_1, thought_2, ..., thought_k, state_{t+1}

The training configuration differs from Stage 1 in several ways (Table 9):

• Initialization from the Stage 1 checkpoint (not the base Qwen3 model)
• Lower learning rate ($8.0 \times 10^{-6}$, a 2.5× reduction) to avoid overwriting the dynamics knowledge
• 5 epochs (vs. 1 in Stage 1) on the much smaller CoT dataset
• Per-device batch size of 2, gradient accumulation of 2, effective batch size of 32 (1 device)
• History masking enabled: the loss is computed only on the CoT tokens and predicted state tokens, not on the input history tokens. This is a critical detail—without history masking, the model would be penalized for not predicting the input, which would distort the training signal.
• Training time: approximately 110 steps for the 8B model, taking 2 hours on 8×A100 GPUs

The critical finding: knowledge-then-reasoning is more effective than reasoning from scratch. Table 7 ablates the amount of CoT data (500, 1K, 2K, 10K samples) and compares two starting points:

• Starting from Qwen3-8B (direct reasoning tuning): Training on 1K CoT samples reaches a Total Score of 0.403 (Factuality 0.511, Turing 0.296). Scaling to 10K samples reaches 0.510.
• Starting from the Stage 1 model (1.06M transition modeling first): Training on only 1K CoT samples reaches a Total Score of 0.561 (Factuality 0.701, Turing 0.422)—significantly better than the direct approach even with 10K samples (0.510).

The paper's interpretation: "our robust pre-trained dynamics enable effective reasoning activation with only 1,000 samples, achieving performance that surpasses the base model trained on 10× more CoT data." This validates the two-stage design: the model first learns what happens (via exposure to 1M+ trajectories), which creates a rich internal representation of web dynamics, and then a small amount of CoT data teaches it to externalize that knowledge as explicit reasoning. Attempting to teach reasoning from scratch fails because the model does not yet have the dynamics knowledge to reason about.

The paper also observes that excessive CoT data can degrade performance: the 2K-sample model scores 0.537 (lower than 1K at 0.561), and the 10K model scores 0.552 (still below 1K). The recommendation is to use "a small, carefully curated amount of CoT data" for optimal results—a finding consistent with the broader literature on catastrophic forgetting during fine-tuning.

Dataset Statistics and Scale

The paper provides detailed statistics in Figure 3 and Table 11 (Appendix D).

Domain distribution (Figure 3a). The dataset spans categories including Lifestyle, Technology, Education, E-Commerce, News, Government, Health, Travel, Entertainment, Sports, and Finance. The distribution shows "balanced coverage across diverse categories," with no single domain dominating.

Token length distribution (Figure 3b). Context lengths range up to 30,000 tokens. The distribution is right-skewed, with most trajectories in the 2,000–10,000 token range but a long tail extending to the maximum. This ensures the model can handle both short interactions (a single form submission) and extended multi-page workflows.

Trajectory turns distribution (Figure 3c). The number of interaction turns ranges from 1 to 30+, with the distribution peaking in the 3–10 turn range and tapering toward 30. The paper emphasizes that this confirms "the inclusion of long-horizon tasks (up to 30+ steps)," which is a key differentiator from prior work that is limited to single-step prediction or short contexts.

Data composition (Table 11). The 1,059,348 total trajectories break down as:

• Randomized Crawling: 293,511 trajectories (22.0 GB), sourced from CCI 3.0 (Chinese, 57,837 trajectories) and FineWeb subset (English, 235,674 trajectories). Labeled with attributes: Real-World=Yes, Long-Seq=No, Multi-Fmt=No.
• Autonomous Exploration: 38,356 trajectories (10.4 GB), from FineWeb LLM-driven exploration (36,474) and high-frequency sites (1,882). Real-World=Yes, Long-Seq=Yes, Multi-Fmt=No.
• Task-Oriented Execution: 94,001 trajectories (8.2 GB), from benchmark-derived synthetic tasks. Real-World=No, Long-Seq=Yes, Multi-Fmt=Yes.
• Open Source: 37,568 trajectories (0.7 GB), from AgentTrek and other public datasets. Real-World=Yes, Long-Seq=Yes, Multi-Fmt=No.
• Multi-format: 47,855 trajectories (4.0 GB), HTML/XML/Playwright conversions. Real-World=Yes, Long-Seq=No, Multi-Fmt=Yes.
• Interaction (chat/QA/Web2NAL): 547,758 trajectories (5.6 GB). Real-World=No, Long-Seq=No, Multi-Fmt=No.

A critical observation: the Interaction category, which is not web interaction data at all, constitutes over half the training set by count but only 11% by size (5.6 GB out of 50.9 GB). This is because chat and QA exchanges are much shorter than web trajectories. The web trajectory data dominates the total training compute, even though it is outnumbered by auxiliary samples.

4. Key Insights and Innovations

Innovation 1: The "Open-Web Scaling Hypothesis" for World Models — Diversity Beats Fidelity

The paper's most fundamental conceptual contribution is not any specific architectural choice or training trick but rather a thesis about what matters most when building world models for web agents: exposure to the raw diversity of the real internet matters more than carefully curated trajectories from controlled benchmark environments. This is a direct analog of the pretraining scaling hypothesis that revolutionized NLP — the idea that a language model trained on a broad, noisy internet corpus outperforms one trained on a smaller, cleaner, more carefully constructed dataset — but applied to the fundamentally different domain of interaction data, where every example requires live browser execution rather than static text crawling.

Before WebWorld, the dominant assumption in the web world model literature was that quality and task relevance were the binding constraints. Prior trained world models (DreamGym, WMA, WebSynthesis, Word2World, WebEvolver) all share a common design philosophy: collect trajectories from benchmark environments (WebArena, WebShop, Mind2Web) where the task structure is known, the websites are controlled, and the evaluation criteria are clear. These datasets range from ~4K to ~70K trajectories — two to three orders of magnitude smaller than WebWorld's 1.06M — but they are curated, clean, and task-aligned. The implicit assumption was that this curation was necessary: that the signal-to-noise ratio in open-web data would be too low for effective world model training, that random crawling would produce degenerate trajectories with no learning value, and that task-oriented execution on known benchmarks provided the richest supervision.

WebWorld falsifies all three assumptions simultaneously. The 293K trajectories from randomized crawling (Level 1) — which are explicitly not task-aligned, not curated for quality, and not restricted to any particular domain — are not just harmless filler; they are the largest single component of the training data (43.3%) and arguably the most important for generalization, because they teach the model the basic transition dynamics of the web across the widest possible variety of website structures. The finding that models trained on this noisy, broad data match or exceed proprietary frontier models (Claude-Opus-4.1, Gemini-3-Pro) on WebWorld-Bench (Table 3) while prior benchmark-trained models achieve near-zero scores on the same evaluation is the clearest empirical validation of the open-web scaling hypothesis.

This is a fundamental shift rather than an incremental refinement. It changes the problem formulation from "how do we collect high-quality trajectories from benchmark environments?" to "how do we harvest interaction data from the open web at sufficient scale and diversity?" The entire hierarchical pipeline — randomized crawling for breadth, autonomous exploration for realism, task-oriented execution for goal alignment — is downstream of this conceptual reorientation. It also explains why the paper treats the 15.7% URL reachability rate and 85.2% keyword pass rate not as failures but as acceptable filtration costs: in a scaling regime, you accept that most candidate URLs are dead or unsuitable because the ones that survive still number in the hundreds of thousands. This is the same logic that makes CommonCrawl viable for pretraining despite its noise.

The practical implication is that future web world model research should invest in broader data coverage rather than better data curation. The paper provides the first recipe for how to do this at scale, but the conceptual insight — that diversity, not cleanliness, is the primary driver of world model generalization — is the lasting contribution that will shape how the field approaches data collection for agent training.

Innovation 2: The "Knowledge-Then-Reasoning" Two-Stage Curriculum — Decoupling Dynamics Learning from Reasoning Activation

The paper identifies and solves a subtle but critical problem in training world models that can both predict state transitions and explain them: attempting to learn web dynamics and reasoning patterns simultaneously from scratch fails, but learning dynamics first on massive data and then activating reasoning on a tiny CoT dataset succeeds dramatically. This is not merely a hyperparameter tuning observation — it is a finding about the structure of knowledge acquisition in world models that challenges the default assumption that reasoning should be trained jointly with the task it reasons about.

The dominant approach in the LLM fine-tuning literature is to train on the final target format directly. If you want a model that produces chain-of-thought reasoning followed by a prediction, you train it on (input → thought → output) sequences from the start. This is how most instruction-tuned reasoning models are built. The paper shows that this approach fails for web world modeling: training Qwen3-8B directly on CoT-augmented state prediction data requires 10K samples to reach a Total Score of 0.510 (Table 7, "From Qwen3-8B" row). In contrast, first training on 1.06M non-reasoning transition trajectories (Stage 1), then adding only 1K CoT samples (Stage 2), achieves a Total Score of 0.561 — significantly better with 10× less reasoning data.

What makes this finding intellectually distinctive is the mechanism it implies: the model already has knowledge about web dynamics after Stage 1 — it knows what happens when you click a button, what pages look like after form submission, how navigation works. But this knowledge is implicit in the model's weights, not explicit in its outputs. The CoT fine-tuning does not teach new dynamics; it teaches the model to externalize knowledge it already possesses as explicit reasoning steps. This is fundamentally different from the standard view of CoT training as teaching the model how to reason; here, it is teaching the model to surface reasoning it has already internalized through exposure to raw dynamics data.

The evidence for this interpretation is the non-monotonic relationship between CoT data quantity and performance. More CoT data does not monotonically improve the model: 1K samples (0.561) > 2K samples (0.537) > 10K samples (0.552). If CoT training were teaching new reasoning capabilities, more data should help. Instead, the pattern suggests that a small amount of CoT data activates existing knowledge, while larger amounts begin to overwrite the dynamics knowledge through catastrophic forgetting — even with the reduced learning rate used in Stage 2. The sweet spot is the minimum amount needed to teach the externalization pattern.

This is a fundamental finding with broad implications beyond web world models. It suggests a general recipe for building models that both perform a task and explain their performance: first train on massive task data without explanations (letting the model build rich internal representations), then activate explanations on a tiny annotated dataset. This is the opposite of the standard "train on expert demonstrations with explanations" pipeline and could apply to any domain where raw task data is abundant (from web crawling, simulation, or logs) but annotated reasoning data is expensive. The paper does not make this generalization explicitly, but the structure of the finding strongly suggests it.

A practical corollary: the paper finds that the CoT data can be synthesized rather than human-annotated. The 1K CoT samples are generated by prompting an LLM to produce reasoning steps for randomly sampled transitions from the Stage 1 training data. This means the entire two-stage pipeline requires zero human annotation for reasoning — only raw interaction trajectories (which are collected automatically) and a modest amount of LLM-synthesized CoT data. This is what makes the recipe "replicable" as the paper claims.

Innovation 3: WebWorld-Bench as a Diagnostic Framework — Separating Factuality from Realism with Dual Metrics

The paper identifies a previously unrecognized problem in world model evaluation: existing metrics conflate two distinct dimensions of simulation quality, and neither dimension alone captures what makes a world model useful for agent training. The solution — WebWorld-Bench with its dual Factuality Score and Web Turing Score — is not just a new benchmark but a diagnostic framework that reveals how different world models fail, enabling targeted improvement rather than black-box score optimization.

Before WebWorld-Bench, the field used two families of metrics. Structural metrics (DOM tree similarity, element-level alignment, used by WebEvolver) measure whether the predicted HTML or A11y Tree matches the ground truth at the syntactic level. Semantic metrics (ROUGE, BERTScore between predicted and actual state change descriptions, used by WMA) measure whether the predicted state description covers the same information as the actual state change. The paper argues persuasively that both families break down on the open web: structural metrics produce "uniformly low scores due to HTML's high variance" (two functionally identical pages can have entirely different DOM structures due to ads, personalization, or A/B testing), while semantic metrics "fail to differentiate model capabilities when state changes are complex" (a vague but true prediction and a specific but wrong prediction can receive similar ROUGE scores if both share keywords with the reference).

The conceptual move WebWorld-Bench makes is to recognize that what we want from a world model depends on how we use it. For trajectory synthesis (generating training data for agents), we care primarily about factuality: does the predicted state correctly reflect the causal effect of the action? If the agent clicks "Submit," did the model predict the correct confirmation page, even if the page layout differs slightly from reality? For inference-time lookahead search (evaluating candidate actions by simulating their outcomes), we also care about realism: can the value model distinguish simulated states from real ones, or does the world model produce states that "look wrong" in ways that bias action selection? These two criteria can diverge — a model might produce factually correct states that are stylistically unrealistic, or realistic-looking states that are factually wrong — and neither existing metric family captures both.

The Factuality Score addresses this with pointwise evaluation: an LLM judge scores whether the predicted state correctly reflects the functional effect of the action on a continuous scale, focusing on "semantic consistency rather than pixel-perfect matching." The Web Turing Score uses pairwise adversarial discrimination: the judge is shown two anonymized states (one real, one predicted) and must identify which is real. A model that achieves a high Turing Score is producing states indistinguishable from reality — even if those states are factually wrong in specific details. The two scores together provide a richer diagnostic: a model with high Factuality but low Turing is functionally correct but stylistically "off" (perhaps producing overly simplified pages), while a model with high Turing but low Factuality is a convincing hallucinator.

The empirical validation of this framework is Table 3, where the diagnostic power becomes clear. The baselines (WebSynthesis-8B, WMA-8B, Word2World-8B) score near zero on both metrics — not because their underlying approaches are worthless, but because their format misalignment with open-web evaluation makes them produce outputs that are neither factually correct nor Turing-plausible. The Qwen3 base models (without any world model training) achieve moderate Factuality scores (26.9–40.1) but poor Turing scores (17.4–23.0), indicating that the base LLM has some latent knowledge of web dynamics (it can roughly predict what should happen) but cannot produce states that "look right" — a diagnosis that would be invisible under a single aggregate metric. Proprietary frontier models (GPT-4o, Claude, Gemini) achieve strong Factuality (59.5–71.3) and moderate Turing (35.4–47.4), while WebWorld-32B matches the best proprietary models on Factuality (71.0) and approaches them on Turing (45.6).

This is a fundamental methodological contribution rather than an incremental benchmark. It does not just measure "is model A better than model B?"; it reveals why and in what way, enabling targeted improvement. The consistent ranking across different LLM judges (Table 4 — GPT-4o and Claude-Opus-4.1 produce the same relative ordering despite different absolute strictness) validates that the metrics are measuring stable properties of the models rather than judge-specific preferences. The paper's observation that "bounded gains from inference-time search suggest that world models are more valuable for synthesizing training data" (Section 5.2) is an example of the kind of insight the dual-metric framework enables: inference-time search depends more on Turing realism (the value model must not be fooled by unrealistic states), while trajectory synthesis depends more on Factuality (the downstream agent must learn correct dynamics), and WebWorld's strength in Factuality over Turing explains why synthesis is the higher-value application.

Innovation 4: Web Interaction as a Foundation for Cross-Domain World Modeling — The Web as a "Base Environment" for Transfer

The paper's finding that WebWorld transfers effectively to code, GUI, and game environments through lightweight fine-tuning (Table 8, Section 6.3) is more than a demonstration of transfer learning — it is evidence for a structural claim about the relationship between web interaction and other digital domains: that the open web, with its extreme diversity of interface patterns, interaction modalities, and dynamic behaviors, serves as a kind of "base environment" for world modeling that captures transferable skills absent from narrower training distributions.

This claim is not obvious a priori. One could reasonably argue that a world model trained on web pages — with their specific DOM structures, form-based interactions, and navigation patterns — would be specialized to web tasks and would not transfer to fundamentally different environments like terminal commands (code), pixel-based game interfaces (games), or desktop GUI widgets (GUI). The dominant assumption in the world model literature has been that world models are environment-specific: you train a web world model for web tasks, a robotics world model for manipulation tasks, a game world model for game playing. Cross-domain transfer, if it occurs at all, is a bonus, not a design goal.

Table 8 challenges this assumption quantitatively. When fine-tuned on as few as 1,500 samples from code, game, and GUI environments (converted into (state_t, action_t, state_{t+1}) tuples), WebWorld achieves Total Scores of 0.396 (code), 0.473 (game), and 0.705 (GUI) — representing gains of +0.249, +0.220, and +0.383 over the Qwen3 baseline fine-tuned on the same data. At 3,000 samples, the gains persist: +0.275, +0.148, and +0.208 respectively. The average gain across all four domains (including API services) is +0.224 at 1,500 samples and +0.165 at 3,000.

What makes this a conceptual contribution rather than just an empirical observation is the mechanism it implies. The fact that WebWorld initialization provides a large advantage over the base Qwen3 model for non-web domains suggests that the skills acquired during web-scale world model training — predicting how interfaces respond to actions, reasoning about state transitions, maintaining consistency across multi-step interactions — are not web-specific but are general world modeling competencies. The open web, by virtue of containing every conceivable type of digital interface (forms, search, navigation, media playback, real-time updates, multi-page workflows, modal dialogs, drag-and-drop, etc.), provides a training distribution that covers the support of many narrower domains. A model that can simulate what happens when you click a button on an arbitrary website has already learned most of what it needs to simulate what happens when you click a button in a desktop application or select a menu item in a game.

This is a fundamental reframing of the role of web data in agent training. Rather than treating the web as one domain among many, the paper's results suggest it may be the foundational domain — the digital environment whose diversity makes it the best starting point for any world model that will subsequently specialize to narrower environments. This parallels the role of ImageNet pretraining in computer vision (where a broad, diverse dataset provides features that transfer across tasks) and language model pretraining on internet text (where broad linguistic exposure enables downstream task adaptation). The paper does not make this analogy explicitly, but the structure of the finding strongly supports it.

A limitation the paper does not address: the transfer results are shown with fine-tuning on target domain data, not zero-shot transfer. The gains represent faster adaptation and better sample efficiency, not a claim that WebWorld can simulate code execution or game physics without any domain-specific training. This is analogous to the difference between "ImageNet pretraining improves downstream task performance after fine-tuning" (well-established) and "ImageNet pretraining enables zero-shot medical image diagnosis" (not true). The practical value is in reducing the amount of target-domain data needed to build a competent world model — a significant benefit given that collecting interaction data in specialized environments (enterprise software, industrial control systems, proprietary games) is often even more constrained than web data collection.

The cross-domain result also retroactively validates the data enrichment strategy (Section 3.4). By training on multiple formats (A11y Tree, HTML, XML, Markdown) and auxiliary tasks (General World Model, General Chat), Stage 1 teaches the model that world modeling is about state transition semantics, not web-specific syntax. This is precisely what enables transfer: the model has learned to represent the abstract structure of cause and effect in digital environments, not merely to pattern-match on A11y Tree formats. The fact that the base Qwen3 model (which has the same auxiliary data but no web-scale world model training) shows much lower transfer performance confirms that the transferability comes specifically from the web interaction training, not from general language understanding or multi-format exposure alone.

5. Experimental Analysis

Evaluation Methodology

Dataset. The primary intrinsic evaluation uses WebWorld-Bench, a custom benchmark constructed by the authors specifically for open-web world model evaluation. The benchmark is generated using the same hierarchical data curation pipeline as the training set (Section 3.2) to ensure domain alignment, but is strictly held out to prevent data contamination. It spans nine dimensions: Long-Horizon Consistency (trajectories exceeding 10 steps), Base Semantics (macroscopic page transitions), Fine-Grained Sensitivity (actions triggering minimal localized changes, filtered by an LLM), Multi-tab/Multi-page interactions, Multi-Format Robustness across four representations (XML, HTML, Markdown, Playwright references), and Web2NAL (natural language state change descriptions). The exact number of evaluation examples per dimension is not specified in the main text. For extrinsic evaluation of downstream agent performance, the paper uses MiniWob++ and WebArena (the standard benchmark from Zhou et al., 2023, consisting of four sub-domains: E-Commerce, GitLab, Reddit, and content management/Others). Success rates and average steps are reported on these benchmarks' standard test splits.

Base model(s). The WebWorld family is built on Qwen3 (Yang et al., 2025) at three scales: 8B, 14B, and 32B parameters. The paper trains each size from scratch using the identical data pipeline, enabling scaling law analysis. The Qwen3 base models (without any world model training) also serve as baselines in Table 3. For downstream agent training (Section 5.1), the base agents are Qwen3-8B and Qwen3-14B. The choice of Qwen3 is justified implicitly by its availability at multiple scales and the alignment between its pretraining data and the URL sources (FineWeb, CCI 3.0) used for WebWorld's data collection.

Metrics. The paper uses two complementary intrinsic metrics:

• Factuality Score: A pointwise LLM-judge evaluation (using GPT-4o as judge) that scores whether the predicted state correctly reflects the functional effect of the action on a continuous scale. The judge prompt (Appendix N.3, Figure 13) assesses "semantic consistency rather than pixel-perfect matching." Scores are normalized to [0, 1] and reported as percentages (0–100) in Table 3.
• Web Turing Score: A pairwise adversarial evaluation where the judge is presented with two anonymized observations—one from WebWorld and one from the real browser—and must identify which is more realistic (Appendix N.3, Figure 14). A score of 50% indicates indistinguishability from real data; higher scores indicate the model's outputs are deemed more plausible than ground truth. Like Factuality, scores are normalized to [0, 1] and reported as percentages. Both metrics are computed across all nine evaluation dimensions, with averages reported in the final columns of Table 3.

For extrinsic evaluation (Section 5.1), the primary metric is Success Rate (SR %) with Standard Error and Average Steps per task. For inference-time search (Section 5.2), the metric is task success rate on MiniWob++, with the reward delta (Δ) relative to the greedy decoding baseline.

Baselines. The paper evaluates against four categories:

• Proprietary frontier LLMs prompted zero-shot as world models: GPT-4o (gpt-4o-2024-11-20), Claude-Sonnet-4.5 (claude-sonnet-4-5-20250929), Claude-Opus-4.1 (claude-opus-4-1-20250805), Gemini-3-Pro (Gemini-3-Pro-preview). These serve as upper bounds for intrinsic evaluation since they are not specialized for web simulation.
• Prior trained world models, reproduced using Qwen3-8B as the base to control for architecture: WebSynthesis-8B (Gao et al., 2025, trained on the official 27K dataset), WMA-8B (Chae et al., 2025, trained on the official WMA dataset), Word2World-8B (Li et al., 2025a, evaluated zero-shot from the released Llama-3.1-8B checkpoint since format misalignment prevents fine-tuning).
• Base Qwen3 models at 8B, 14B, and 32B without any world model fine-tuning. These measure how much latent web dynamics knowledge exists in the pretrained LLM.
• GPT-4o as a downstream agent for extrinsic evaluation (Table 5, achieving 64.3% on MiniWob++ and 26.6% on WebArena). For inference-time search (Table 6), the paper also evaluates GPT-5 (gpt-5-2025-08-07) as a world model for lookahead simulation.

Generation budget / compute accounting. For intrinsic evaluation on WebWorld-Bench, there is no explicit generation budget—the world model receives the full interaction history and produces a single predicted next state. The "compute" is the model's inference FLOPs per prediction, which scale with model size but are not explicitly quantified. For extrinsic trajectory synthesis (Section 5.1), the paper generates 8,000 trajectories using the Abstract-and-Instantiate pipeline; the compute cost of this synthesis is not reported. For inference-time search (Section 5.2), the budget is parameterized by the number of candidate actions evaluated per step (k in Best-of-N, MCTS branching factor). The default Best-of-N uses k=3, with experiments varying k=2, 3, and 5. MCTS and Hybrid search use k=3. The paper notes that the output format constrains the effective budget: natural language output enables deeper search (k=5) while full HTML is restricted to shallow search (k=2) by context length limits.

Cross-validation / statistical protocol. For WebWorld-Bench evaluation, the paper does not report cross-validation—the benchmark is a fixed test set, and models are evaluated once. Judge consistency is validated by comparing rankings produced by two different LLM judges (GPT-4o and Claude-Opus-4.1) in Table 4, showing that relative model ordering remains stable despite different absolute score calibrations. For downstream agent evaluation on MiniWob++ and WebArena, standard errors are reported (± in Table 5), suggesting multiple evaluation runs, though the exact number is not specified. For the CoT ablation (Table 7), each data scale (500, 1K, 2K, 10K samples) is trained once and evaluated on the full benchmark, without reported variance.

Main Quantitative Results

Intrinsic Evaluation: WebWorld-Bench Performance (Tables 3 and 4)

The headline result is that WebWorld-32B achieves an average Factuality Score of 71.0% and a Web Turing Score of 45.6%, matching or approaching the best proprietary models. Specifically (Table 3):

• WebWorld-32B Factuality (71.0%) is within 0.3 percentage points of Claude-Opus-4.1 (71.3%) and slightly ahead of Gemini-3-Pro (70.3%). The gap to GPT-4o (59.5%) and Claude-Sonnet-4.5 (59.7%) is substantial (~11 points).
• WebWorld-32B Turing (45.6%) trails Claude-Opus-4.1 (47.4%) and Gemini-3-Pro (43.2%) but leads GPT-4o (35.4%) and Claude-Sonnet-4.5 (36.2%). A Turing score above 50% would indicate super-human realism (the judge prefers simulated states to real ones); WebWorld's score in the mid-40s indicates it is approaching but not exceeding human-level plausibility.
• Scaling trends: WebWorld-8B achieves 70.1% Factuality / 42.2% Turing; WebWorld-14B: 70.7% / 44.7%; WebWorld-32B: 71.0% / 45.6%. The modest gains from 8B to 32B (+0.9 Factuality, +3.4 Turing) suggest that model scale provides diminishing returns on intrinsic metrics once the data pipeline is fixed—most of the benefit comes from the 1.06M trajectories, with model capacity providing incremental refinement.

The dimension-level breakdown reveals specific strengths and weaknesses:

• Long-Horizon Consistency: WebWorld-32B achieves 77.0% Factuality and 37.0% Turing. This Factuality score is competitive with proprietary models (Claude-Opus-4.1: 82.9%, Gemini-3-Pro: 78.7%) and dramatically higher than untrained Qwen3-32B (52.9%). The Turing score (37.0%) is in the mid-range of proprietary models (25.0–39.4%), suggesting long-horizon realism remains challenging even with 1M+ training trajectories.
• Fine-Grained Sensitivity: WebWorld-32B scores 87.0% Factuality—the highest Factuality score across all dimensions and all models, including proprietary ones (GPT-4o: 81.0%, Claude-Opus-4.1: 79.4%). This is a specific strength: WebWorld excels at predicting localized, subtle state changes (dropdown expansion, checkbox toggling), likely because the training data includes extensive form interactions from Levels 2 and 3.
• Multi-Format Robustness: Across XML (73.0%), HTML (63.0%), Markdown (73.0%), and Playwright (74.0%), WebWorld-32B maintains consistent Factuality scores. The HTML score is notably lower than other formats, consistent with the paper's observation that HTML has higher variance and is harder to predict exactly. The Turing scores for these formats (40.5–50.0%) show that the model produces format-appropriate outputs that are difficult to distinguish from real data.
• Web2NAL (Natural Language): This is WebWorld's weakest dimension across all scales: 37.6% (8B), 38.1% (14B), 38.5% (32B) Factuality, and 41.0–54.0% Turing. The relatively high Turing score with low Factuality suggests the model produces plausible-sounding natural language descriptions that are often factually wrong—a classic hallucination pattern. Proprietary models show the same pattern (GPT-4o: 34.2% Factuality, 62.0% Turing), suggesting natural language state description is fundamentally harder than structured format prediction.

Prior trained world models collapse on WebWorld-Bench. WebSynthesis-8B achieves only 16.7% average Factuality and 8.8% Turing; WMA-8B: 11.1% / 8.7%; Word2World-8B: 7.0% / 0.6%. The paper attributes this primarily to "output format misalignment rather than model deficiency" (Appendix C), since these models were trained on benchmark-specific formats. However, the near-zero Turing scores for Word2World (0.6%) suggest deeper issues than just format mismatch—the model produces outputs that even the simplest adversarial test can distinguish from reality.

Untrained Qwen3 models show non-trivial latent knowledge. Qwen3-8B achieves 26.9% Factuality and 17.4% Turing; Qwen3-32B: 40.1% / 23.0%. These are far below WebWorld but substantially above the prior trained world models, confirming the paper's premise that pretraining on web text provides latent web dynamics knowledge that can be activated through fine-tuning. The gap between Qwen3-32B (40.1% Factuality) and WebWorld-32B (71.0% Factuality) represents the value added by the 1.06M trajectory fine-tuning.

Judge consistency (Table 4). GPT-4o and Claude-Opus-4.1 produce the same relative model ordering despite different absolute strictness. For example, on Factuality, GPT-4o scores: WebWorld-8B 70.1, Qwen3-8B 26.9, proprietary average ~63. Claude-Opus-4.1 scores: WebWorld-8B 67.6, Qwen3-8B 27.3, proprietary average ~57. The absolute scores differ by 2–6 points, but the ranking (WebWorld ≈ best proprietary > Qwen3 base) is preserved. This validates that the metrics are measuring stable model properties rather than judge idiosyncrasies.

Extrinsic Evaluation: Downstream Agent Performance (Table 5)

The headline result: fine-tuning on WebWorld-synthesized trajectories improves Qwen3-8B by +9.9% on MiniWob++ (49.4% → 59.3%) and +10.9% on WebArena (9.8% → 20.7%), with the 14B model reaching 24.3% on WebArena—comparable to GPT-4o's 26.6%.

MiniWob++ results. The base Qwen3-8B achieves 49.4% success rate with average steps of 4.88. After fine-tuning on 8,000 WebWorld-synthesized trajectories, performance rises to 59.3% (+9.9%), with average steps decreasing to 4.39—the agent becomes both more accurate and more efficient. Qwen3-14B shows a similar pattern: 54.9% → 63.2% (+8.3%), with steps dropping from 4.55 to 4.28. The 8B fine-tuned model (59.3%) is within 5 percentage points of GPT-4o (64.3%), and the 14B fine-tuned model (63.2%) is within 1.1 percentage points—essentially matching GPT-4o's performance.

WebArena results. The base Qwen3-8B achieves only 9.8% overall success rate, with particularly poor performance on Reddit (5.0%) and GitLab (9.4%). After WebWorld fine-tuning, overall success rises to 20.7% (+10.9%), with dramatic gains on Reddit (+18.3%, from 5.0% to 23.3%) and GitLab (+12.0%, from 9.4% to 21.4%). The E-Commerce sub-domain shows more modest gains (+3.6%, from 17.1% to 20.7%), while the Others category slightly declines (-0.7%). Qwen3-14B shows similar patterns: overall 15.1% → 24.3% (+9.2%), with GitLab showing the largest gain (+17.3%, from 15.4% to 32.7%).

Key observation: domain-specific gains. The WebArena sub-domain breakdown reveals that WebWorld training helps most on domains that involve structured, form-based interactions (GitLab: issue tracking, merge requests; Reddit: posting, commenting) and least on domains requiring open-ended content understanding (Others: content management system, where the fine-tuned model actually regresses slightly). This pattern is consistent with WebWorld's training data composition—the task-oriented execution trajectories (Level 3) emphasize goal-directed form interactions, while free-form content exploration is less represented.

GPT-4o comparison. The fine-tuned Qwen3-14B achieves 24.3% on WebArena, compared to GPT-4o's 26.6%—a gap of only 2.3 percentage points. This is notable because Qwen3-14B is a much smaller model than GPT-4o (14B vs. an estimated hundreds of billions of parameters), suggesting that domain-specific training on simulated trajectories can substantially close the gap with generalist frontier models. However, GPT-4o achieves its performance with zero web-specific fine-tuning, so the comparison is not entirely fair—a GPT-4o fine-tuned on the same WebWorld data might improve further, though such fine-tuning is not possible with the proprietary API.

Extrinsic Evaluation: Inference-Time Lookahead Search (Table 6)

The headline result: WebWorld as a world model for lookahead search outperforms GPT-5 on MiniWob++, with Best-of-N (k=3) using pairwise scoring achieving 67.5% success rate (+3.2% over greedy) compared to GPT-5's best configuration at 64.5% (+0.2%).

Baseline performance. The GPT-4o agent with greedy decoding achieves 64.3% on MiniWob++. Using GPT-4o's own internal knowledge as a world model for Best-of-N lookahead (k=3) with pointwise scoring actually degrades performance to 63.8% (-0.5%), suggesting that the agent's internal simulation is noisy enough to mislead action selection. This negative result validates the need for dedicated world models rather than relying on the agent's implicit environment understanding.

Impact of scoring method. Shifting from pointwise to pairwise value evaluation provides substantial gains. With WebWorld as the world model and GPT-4o as the value model:

• Pointwise Best-of-N (k=3): 64.8% (+0.5%)
• Pairwise Best-of-N (k=3): 65.5% (+1.2%)

The pairwise scoring provides richer comparative signals than absolute pointwise scores, consistent with findings in the RLHF literature that humans (and LLM judges) are better at relative comparisons than absolute judgments.

Impact of value model quality. Upgrading the value model from GPT-4o to GPT-5 while keeping WebWorld as the world model yields the best result: 67.5% (+3.2%). This suggests that the bottleneck in lookahead search is partially in the value model's ability to assess simulated states, not just in the world model's simulation fidelity. However, even with GPT-5 as the world model and a pairwise GPT-4o value model, performance only reaches 64.5% (+0.2%), confirming that WebWorld's learned simulation outperforms GPT-5's implicit world knowledge for this task.

Format and depth trade-offs. Natural language output from WebWorld enables deeper search (k=5, 65.9% at +1.6%) compared to structured A11y Tree (k=2, 65.7% at +1.4%; k=3, 65.5% at +1.2%). The paper explains this as a context length constraint: full A11y Tree states consume more tokens, limiting how many branches can be explored within the model's context window. Natural language summaries are more compact, enabling the value model to compare more candidates.

Advanced search strategies. Monte Carlo Tree Search (MCTS, k=3) achieves 65.4% (+1.1%), and Hybrid search (which only triggers lookahead when actions are uncertain) achieves 65.5% (+1.2%)—both marginally below the simpler Best-of-N with pairwise scoring (65.5%). The paper interprets this as evidence that "bounded gains from inference-time search suggest that world models are more valuable for synthesizing training data" (Section 5.2). The overhead of sophisticated search does not pay off compared to simply generating more training trajectories offline.

Ablation Studies and Robustness Checks

Reasoning activation data scale (Table 7): A minimal dataset of 1,000 CoT samples is optimal for activating reasoning in the Stage 1-pretrained model, achieving a Total Score of 0.561. This surpasses both smaller (500 samples: 0.535) and larger (2K: 0.537, 10K: 0.552) CoT datasets, producing a non-monotonic relationship. Starting from the base Qwen3-8B without Stage 1 pretraining requires 10K CoT samples to reach only 0.510—significantly worse than WebWorld's 1K-sample result at 0.561. This is the paper's strongest evidence for the "knowledge-then-reasoning" claim: Stage 1 dynamics learning is a necessary prerequisite for efficient reasoning activation.

Model scale (Table 3, Figure 4): WebWorld's performance scales predictably with model size. Factuality increases from 70.1% (8B) to 70.7% (14B) to 71.0% (32B); Turing from 42.2% to 44.7% to 45.6%. Figure 4 shows evaluation loss following a power-law relationship with compute (FLOPs), with extrapolated predictions for a hypothetical 72B model suggesting continued improvement without saturation. The paper does not report whether the scaling law was fit to the 8B/14B/32B points or also includes the smaller ablation models mentioned in Section 6.1 ("6 model sizes").

Judge consistency across evaluators (Table 4): The relative ranking of models (WebWorld ≈ best proprietary > base Qwen3) is preserved when switching the judge from GPT-4o to Claude-Opus-4.1, despite systematic differences in absolute scores. Claude-Opus-4.1 tends to be stricter on Turing scores (e.g., Gemini-3-Pro drops from 43.2 to 36.5) but preserves the ordering. This validates that the benchmark measures inherent model properties, not evaluator-specific biases.

Cross-environment generalization (Table 8): WebWorld initialization provides consistent and substantial gains over Qwen3 when fine-tuned on non-web domains. At 1,500 training samples per domain, the average Total Score gain is +0.224 (0.176 → 0.400). Gains are largest for GUI (+0.383) and Code (+0.249), and smallest for API Services at 3,000 samples (+0.034, suggesting saturation). The baseline Qwen3 also improves with more data (0.176 → 0.298 average at 1,500 → 3,000 samples), but WebWorld's advantage persists (+0.165 average gain at 3,000 samples).

Output token length analysis (Appendix K, Figure 7): Stage 2 reasoning activation causes a ~49.4% reduction in average output token length compared to Stage 1 alone. The paper interprets this as a shift "from verbose state reconstruction to concise state prediction," where the CoT training teaches the model to filter redundant information. The effect stabilizes after approximately 1,000 CoT samples—further CoT data does not significantly change output length, consistent with the performance plateau in Table 7.

ReST^EM revision model ablation (Appendix K—mentioned in the reference example but not present in WebWorld): This ablation is not applicable to the WebWorld paper, which does not train a revision model. The paper's only negative result on training methodology is the CoT data scale finding (Table 7), where 2K samples underperform 1K.

Critical Assessment

Does WebWorld actually achieve "performance comparable to Gemini-3-Pro and Claude-Opus-4.1," as claimed in the executive summary?

The evidence partially supports this claim. On Factuality Score, WebWorld-32B (71.0%) is indeed comparable to Claude-Opus-4.1 (71.3%) and Gemini-3-Pro (70.3%). On Turing Score, WebWorld-32B (45.6%) is comparable to Claude-Opus-4.1 (47.4%) and exceeds Gemini-3-Pro (43.2%). However, there are important caveats:

• The comparison is on the authors' own benchmark (WebWorld-Bench), which was constructed using the same data pipeline as the training data (though held out). This introduces a potential distributional advantage: even with strict held-out splits, the evaluation data is drawn from the same URL sources (FineWeb, CCI 3.0) and the same collection pipeline as the training data. Proprietary models trained on entirely different data distributions might underperform on WebWorld-Bench not because they are worse world models in general, but because the benchmark reflects WebWorld's specific data distribution. The paper would need to evaluate on a truly independent benchmark (e.g., human-curated web interaction traces from entirely different URL sources) to fully validate the claim of general parity with frontier models.

• The claim of "performance comparable to Gemini-3-Pro" elides significant dimension-level variation. WebWorld-32B substantially outperforms Gemini-3-Pro on Fine-Grained Sensitivity (87.0% vs. 80.3% Factuality) and Multi-Format Robustness, but notably underperforms on Long-Horizon Consistency (77.0% vs. 78.7% Factuality) and Web2NAL (38.5% vs. 35.4% Factuality, though with much lower Turing: 54.0% vs. 49.5%—WebWorld's Turing is actually higher). The average masks these opposing strengths.

• The proprietary model comparison uses zero-shot prompting—no fine-tuning, no few-shot examples, no domain adaptation. This is the weakest possible configuration for these models. If Claude or Gemini were fine-tuned on even a small fraction of WebWorld's training data, their performance might substantially exceed WebWorld's. The paper does not and cannot run this experiment, but it means the claim of "comparable performance" should be qualified as "comparable to zero-shot proprietary models," not "comparable to the best achievable performance of these models."

Does fine-tuning on WebWorld-synthesized trajectories genuinely improve downstream agent performance by the claimed margins?

The evidence in Table 5 supports the claim of significant improvement, but with important nuance:

• The +9.9% gain on MiniWob++ and +10.9% on WebArena are large, robust improvements on standard benchmarks. The WebArena gains are particularly impressive because they include dramatic improvements on previously near-zero sub-domains (Reddit: 5.0% → 23.3%). This strongly validates the utility of WebWorld for trajectory synthesis.

• However, the experiments do not isolate how much of the gain comes from WebWorld specifically versus the Abstract-and-Instantiate data synthesis pipeline. The pipeline itself—abstracting seed tasks, having an agent execute abstract goals, instantiating back to concrete tasks, and applying rejection sampling—might produce useful training data even with a weaker world model. An ablation replacing WebWorld with (say) the base Qwen3-8B as the simulator would reveal how much of the 10.9% gain is uniquely attributable to WebWorld's simulation quality versus the data synthesis methodology.

• The comparison to GPT-4o is useful but incomplete. The fine-tuned Qwen3-14B reaches 24.3% on WebArena versus GPT-4o's 26.6%. This is close, but the claim in the executive summary that this is "performance comparable to GPT-4o" is borderline—a 2.3 percentage point gap on a 26.6% baseline is a relative difference of ~8.6%, which may or may not be considered "comparable" depending on the use case. More importantly, GPT-4o achieves its score with zero task-specific training, while the Qwen3 model required 8,000 synthesized trajectories. A fairer comparison would be GPT-4o with some form of test-time adaptation or few-shot prompting on WebArena.

Does WebWorld genuinely outperform GPT-5 as a world model for inference-time search?

The evidence in Table 6 supports this claim for the specific setting tested (MiniWob++, Best-of-N lookahead with LLM-based value models). WebWorld + GPT-5 value model achieves 67.5% versus GPT-5 as world model + GPT-4o value model at 64.5%. However:

• The comparison is asymmetric in value models. WebWorld gets to use GPT-5 as its value model in the best configuration, while GPT-5 as world model is evaluated with GPT-4o as the value model. The paper does not report GPT-5 as world model + GPT-5 as value model, which would be the fairest comparison. This configuration might not be feasible (using GPT-5 for both roles could exceed API limits or be cost-prohibitive), but its absence means we cannot be certain the advantage comes from WebWorld's simulation quality rather than the superior value model.

• The absolute gains from lookahead search are modest across all configurations: the best improvement over greedy is +3.2% (67.5% vs. 64.3%). While statistically meaningful, this represents only about 1 additional task solved correctly out of every 30 attempts—a real but small practical benefit for the additional inference cost. The paper's own conclusion that "world models are more valuable for synthesizing training data" (Section 5.2) seems well-supported by the data: batch trajectory synthesis yields +10.9% gains, while online lookahead yields +3.2%.

Does WebWorld truly demonstrate that web-scale world models follow predictable scaling laws?

Figure 4 shows evaluation loss decreasing with model size, with extrapolated predictions for 72B. The paper claims "no signs of saturation." However:

• The scaling law is shown for evaluation loss, not for downstream task performance. Lower loss on next-state prediction does not necessarily translate to better agent training outcomes. An ablation showing that agents trained on trajectories from larger WebWorld models achieve higher downstream success rates would substantiate the scaling claim in practical terms.

• The paper mentions training "6 model sizes" but only reports results for 8B, 14B, and 32B in detail. The smaller model sizes (presumably <8B) are not shown with specific performance numbers; they appear only as data points on the scaling curve in Figure 4. This makes it impossible to assess whether the power-law fit is robust across the full range or is dominated by the three largest models.

• The extrapolation to 72B is presented as a prediction, not a validation. Without actually training and evaluating a 72B model, the claim that "substantial performance improvements are achievable through further scaling" remains speculative.

Missing experiments that would strengthen the paper

1. Ablation of data pipeline levels. The paper does not report what happens if you train on only Level 1 (random crawling), only Levels 1+2, or only Level 3 data. Given that Level 1 is 43.3% of the training data and the paper's central claim is that breadth matters, an ablation showing degradation when removing the random crawling component would directly validate the "open-web scaling hypothesis." Similarly, an ablation showing that Level 3 (task-oriented execution) is necessary for downstream agent training gains (even if not for intrinsic metrics) would clarify the distinct roles of each pipeline level.

2. Comparison to API-based world models at matched generation cost. The paper compares WebWorld to proprietary models in zero-shot mode, but a more policy-relevant comparison would match the total inference cost. How many trajectories can GPT-4o simulate for the cost of training WebWorld-8B (4 days on 16×A100)? If GPT-4o could simulate 100K trajectories for less than the training cost of WebWorld, the economic case for training a dedicated world model weakens even if WebWorld achieves higher per-prediction quality.

3. Direct evaluation of world model utility for agent training at different scales. The paper shows that WebWorld's evaluation loss scales with model size (Figure 4), but does not show that downstream agent performance scales with the world model size used for synthesis. If WebWorld-8B-synthesized trajectories yield the same agent improvement as WebWorld-32B-synthesized trajectories, the scaling law has limited practical relevance.

4. Zero-shot cross-domain transfer. Section 6.3 shows transfer with fine-tuning on target domain data, but does not report zero-shot performance of WebWorld on code, GUI, or game state prediction. This would reveal whether web-scale training provides any immediate simulative capability in new domains or whether the benefit is purely in faster fine-tuning adaptation.

5. Human evaluation. Both Factuality and Turing metrics rely on GPT-4o as judge. While Table 4 shows consistency across two LLM judges, neither is validated against human judgments of state prediction quality. A small-scale human study correlating LLM-judge scores with human ratings would calibrate the benchmark's relationship to actual perceived simulation quality.

6. Limitations and Trade-offs

The Cost of Difficulty Estimation Is Not Accounted for in the Headline Efficiency Claims

The assumption or constraint. The paper's entire compute-optimal scaling framework (both for PRM search and for revisions) depends on knowing which of five difficulty bins a given prompt falls into before deciding how to allocate the inference budget. The method for estimating difficulty—whether oracle-based or predicted—requires generating 2,048 samples per question from the base model and computing either ground-truth pass@1 or averaging PRM final-answer scores across those samples (Section 3.2). The authors explicitly acknowledge this gap:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity" (Section 3.2).

This is not a minor accounting detail. Generating 2,048 samples per question to determine which strategy to use consumes more compute than the largest test-time budgets studied (256–512 generations). In the PRM search experiments, the compute-optimal strategy is claimed to achieve 4× better efficiency than best-of-N (Figure 4: 16 generations matching 64). But the difficulty estimation step alone costs 2,048 generations—roughly 128× the claimed 16-generation budget and 32× the 64-generation baseline. Even if difficulty estimation is amortized across many queries to the same question (unlikely in most deployment settings), the one-time cost per question remains enormous.

The consequence. The 4× efficiency gains over best-of-N are computed after difficulty is known, without amortizing the cost of learning it. In any realistic deployment where questions are encountered once (the standard scenario for math problem-solving, tutoring, or evaluation), the total cost is difficulty estimation (2,048 samples) + strategy execution (16–256 samples). The total is dominated by difficulty estimation, making the 4× figure an upper bound on achievable efficiency that is likely unattainable in practice. The claimed gains only materialize in a regime where the difficulty of every question is already known in advance—for example, if a teacher repeatedly asks the same question to different students, or if a benchmark's difficulty labels have been pre-computed.

The paper also does not explore whether fewer samples could achieve similar difficulty estimation accuracy, nor whether difficulty estimation quality degrades gracefully as the number of pre-samples is reduced. It is entirely possible that 2,048 samples are overkill for binning into five quintiles, and that 64 or 128 samples would achieve similar coarse accuracy at much lower cost—but this is not tested.

What evidence exists in the paper. The difficulty estimation cost is stated explicitly (2,048 samples per question, Section 3.2) but appears only in prose, not in any cost comparison table or amortization analysis. The "cost" column in the paper's budget accounting (generations per question) never includes difficulty estimation overhead. Figure 4 (compute-optimal search) and Figure 8 (compute-optimal revisions) plot accuracy against generation budget, where the x-axis represents only the strategy execution budget, not the total cost including difficulty estimation. The fact that predicted difficulty bins nearly match oracle difficulty bins (the curves "largely overlap" per the authors) shows that PRM-based difficulty estimation works in principle, but does not address whether it works at a lower sample count.

Mitigation status. The paper partially acknowledges this limitation in Section 3.2 and explicitly flags it as an area for future work:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity"

The authors suggest that future work could explore "pretraining or finetuning models to directly predict difficulty of a question" (Section 8) or use the difficulty estimation cost itself as part of an exploration-exploitation tradeoff. However, no experiments are run with reduced sample counts, no difficulty prediction models are trained, and no amortization analysis is provided. The limitation remains unaddressed in the current work, and the 4× efficiency figure should be interpreted accordingly.

The 14× Larger Model Baseline Is Not Compute-Optimally Trained

The assumption or constraint. The FLOPs-matched comparison in Section 7 pits PaLM 2-S* with compute-optimal test-time scaling against a model with approximately 14× more parameters, where the larger model is trained with the same data but more parameters—following what the authors call the LLaMA paradigm (Touvron et al., 2023). The paper explicitly acknowledges that this departs from compute-optimal pretraining as established by Hoffmann et al. (2022):

"We choose this setting as it is representative of a canonical approach to scaling pretraining compute and leave the analysis of compute-optimal scaling of pretraining compute where the data and parameters are both scaled equally to future work." (Section 7)

This matters because Hoffmann et al. (2022) demonstrated that for a given compute budget, the optimal allocation scales model parameters and training tokens equally (a ~1:1 ratio in log space). A model trained with 14× more parameters but the same data as the smaller model is almost certainly undertrained—its parameters exceed what the available data can effectively utilize. A Chinchilla-optimal model trained with 14× more total FLOPs would allocate roughly 14× more compute roughly equally between additional parameters and additional data, producing a model that is both larger and trained on more tokens. This model would almost certainly outperform the parameter-only-scaled baseline used in the paper.

The consequence. The reported advantages of test-time compute over pretraining—for example, +27.8% relative improvement on easy questions at R ≪ 1 using revisions (Section 7, Figure 1 bar chart), or +19.1% using PRM search—are almost certainly overstated relative to a properly compute-optimal larger model. A Chinchilla-optimal baseline trained with matched total FLOPs would be stronger, potentially reversing some of the comparisons where test-time compute appears preferable. The paper's headline finding that "test-time compute can substitute for pretraining" is therefore qualified: it can substitute for a specific, suboptimal pretraining allocation, not for the best possible use of that pretraining budget.

Additionally, the 14× larger model uses only greedy decoding in the FLOPs-matched comparison—no majority voting, no best-of-N, no search of any kind. This is a deliberate design choice to isolate the effect of test-time compute versus pretraining scale, but it means the larger model is evaluated in its weakest configuration while the smaller model gets the full benefit of the compute-optimal strategy. A fairer comparison would give the larger model some test-time compute budget as well (e.g., best-of-8 or best-of-16), since in practice, any deployed model can benefit from at least modest test-time compute augmentation.

What evidence exists in the paper. The FLOPs accounting in Section 7 explicitly describes the larger model as parameter-only-scaled, and the caveat about compute-optimal pretraining appears in the same section. Figure 9 and the Figure 1 bar charts report all comparisons against this specific baseline. There is no ablation using a Chinchilla-optimal model, no sensitivity analysis exploring how results would change if the baseline were stronger, and no experiment giving the larger model even modest test-time compute. The paper is transparent about the limitation in text but does not attempt to bound how much it affects the results.

Mitigation status. The paper acknowledges the limitation explicitly and defers to future work. No experiments address it. A practitioner reading these results should understand that the comparison is between test-time compute on the frontier of inference methodology and a suboptimal pretraining baseline—not between two equally optimized uses of total compute. The true exchange rate between pretraining and inference FLOPs is likely less favorable to inference-time compute than the paper's numbers suggest.

The Approach Provides No Benefit on the Hardest Problems

The assumption or constraint. The paper's entire framework—search, revisions, compute-optimal allocation, and FLOPs-matched substitution—rests on an implicit assumption: the base model already produces correct solutions at some non-trivial rate, and test-time compute amplifies that capability. When the base model's pass@1 is near zero, no amount of search or revision can find a correct solution because none exist in the proposal distribution. The paper is explicit about this boundary:

"test-time compute provides essentially zero benefit regardless of budget, meaning that some capabilities can only be acquired through pretraining, not recovered at inference time" (Section 7 takeaway, paraphrased from the results discussion).

This is not a minor edge case. On MATH difficulty bin 5 (the hardest quintile), accuracy across all methods—best-of-N, beam search, revisions, and their compute-optimal combinations—remains at 1–3% regardless of compute budget (Figure 3, right panel, bin 5; Figure 7, right panel, bin 5). The FLOPs-matched comparison shows the same: bin 5 is essentially flat near 0–5% for all values of R, with the larger pretrained model showing clear superiority (Figure 9, bottommost lines). The paper's test-time compute strategies offer no path forward for these problems.

The consequence. The practical value of the compute-optimal framework depends critically on the difficulty distribution of the target deployment. If the user-facing problem distribution skews toward easy-to-medium difficulty (where the base model already has some success rate), the framework delivers substantial gains. But if a significant fraction of real-world queries fall into the "hard" bin—problems where the model fundamentally lacks the knowledge or reasoning capability to produce correct solutions—test-time compute is wasted effort. The framework provides no mechanism for detecting when a problem is beyond the model's capabilities (other than the difficulty estimator itself, which would correctly place it in bin 5 but provide no useful strategy), and no graceful degradation path other than "spend the budget on best-of-N and hope for the best."

This also limits the framework's applicability to self-improvement pipelines (a use case the paper explicitly discusses in Section 8). If a model is used to generate training data for itself, the hardest problems—precisely those where improved performance would be most valuable—will not benefit from test-time compute augmentation. The model will generate correct solutions for easy and medium problems (which it could already solve) and continue to fail on hard problems, potentially creating a self-reinforcing cycle where the training distribution never expands to cover genuinely challenging cases.

What evidence exists in the paper. The bin 5 results are consistently near-zero across all experiments: Figure 3 (right, bin 5), Figure 7 (right, bin 5), Figure 9 (bin 5 scaling lines), and the FLOPs-matched bar charts showing negative relative gains for hard problems at high R. The paper acknowledges this limitation in the Section 7 discussion:

"On the hardest questions... test-time compute provides essentially zero benefit regardless of budget."

Mitigation status. The paper is transparent about the limitation but offers no solution. It does not explore whether combining revisions with PRM search (a natural next step acknowledged in Section 8) could break through the bin 5 ceiling, nor whether iterative self-play (where the model generates solutions, is fine-tuned on correct ones, and then re-attempts the same problems) could gradually expand the set of solvable problems. The finding that hard problems remain hard is presented as a fact about the current approach rather than a problem to be solved, which is appropriate for an analysis paper but leaves a clear capability gap for practitioners.

The Study Is Restricted to a Single Benchmark and Model Family

The assumption or constraint. All experiments in the paper use the MATH benchmark (Hendrycks et al., 2021, specifically the Lightman et al. 2022 split with 12,000 training and 500 test questions) and a single model family, PaLM 2-S* (Codey). The paper justifies this:

"We believe this model is representative of the capabilities of many contemporary LLMs" (Section 4).

However, this single-benchmark, single-model design means that essentially all findings—the difficulty-dependent behavior of search and revisions, the 4× efficiency gains, the FLOPs-matched comparison, the verifier over-optimization thresholds—are conditional on the specific interaction between PaLM 2-S*'s capabilities and the MATH dataset's characteristics.

Several aspects of the results could be model-specific or benchmark-specific in ways the paper cannot assess:

• PRM quality and over-optimization behavior depend on PaLM 2-S*'s output distribution, its calibration, and the types of errors it makes. A model with different failure modes (e.g., one that makes more arithmetic errors vs. conceptual errors) might exhibit different optimal search strategies at each difficulty level.
• Revision model effectiveness depends on the base model's in-context learning capabilities and its ability to benefit from seeing previous incorrect attempts. Different model families show substantially different in-context learning behavior.
• MATH consists exclusively of competition-level math problems requiring symbolic reasoning. It is unclear whether the central finding—that beam search helps on medium problems but hurts on easy ones, and that revisions help on easy problems but need balanced parallel sampling on hard ones—generalizes to other reasoning domains. Code generation (where correctness is binary and feedback comes from execution), logical reasoning (where errors propagate differently), or factual QA (where errors are often retrieval failures rather than reasoning failures) might show entirely different difficulty-dependent patterns.
• The test set is 500 questions, split into five difficulty quintiles of ~100 each, then further split by two-fold cross-validation for strategy selection. The compute-optimal policy is thus selected based on ~50 questions per fold per bin—a very small sample. The paper does not report confidence intervals on the compute-optimal scaling curves, making it impossible to assess whether the observed strategy differences across bins are statistically robust.

The consequence. A practitioner considering adopting the compute-optimal framework for a different model (GPT-4, Claude, Llama) or a different domain (code, legal reasoning, scientific QA) cannot assume that the difficulty-dependent strategies, the specific beam width settings, or the optimal sequential-to-parallel ratios transfer. The paper provides a methodology for discovering these relationships (estimate difficulty per prompt, sweep strategies per bin, select compute-optimal allocation), but does not validate that the methodology produces consistent results across models or tasks. In the worst case, the "compute-optimal" strategies discovered on PaLM 2-S* + MATH could be actively harmful if deployed on a different setup without re-running the full strategy sweep.

Additionally, the small test set means that the observed differences between strategies within a bin (which drive the compute-optimal policy selection) may be noisy. A strategy that appears 2–3% better than alternatives on 50 questions might be statistically indistinguishable given the variance. Without error bars, a practitioner cannot tell which strategy differences are reliable and which are sampling noise.

What evidence exists in the paper. The paper's entire empirical section (Figures 3–9, Tables 2–5 in the reference) reports results on MATH with PaLM 2-S*. There is no cross-benchmark evaluation (e.g., on GSM8K, MMLU-Math, or an independent math dataset), no cross-model evaluation (e.g., applying the same methodology to a different base LLM), and no confidence intervals on the scaling curves. The 500-question test set size is mentioned in Section 4 but the implications for statistical power are not discussed.

Mitigation status. The paper does not attempt to address this limitation beyond acknowledging it:

"We believe this model is representative of the capabilities of many contemporary LLMs."

This is a claim, not evidence. The paper does not argue that MATH covers a representative sample of reasoning tasks, nor that PaLM 2-S*'s error patterns are typical. Future work on replication across models and benchmarks would be needed to establish the generality claimed implicitly by the paper's presentation of "compute-optimal test-time scaling" as a general framework rather than a case study.

Sequential Revision Strategies Introduce Latency That Is Not Accounted For

The assumption or constraint. The paper measures test-time compute in generations—the number of complete solutions sampled from the model—which is a reasonable proxy for total FLOPs but ignores wall-clock latency. This matters because the compute-optimal strategies discovered by the paper often allocate a significant fraction of the budget to sequential revisions, which are inherently serial: each revision depends on the output of the previous revision and cannot be parallelized.

Consider the compute-optimal revision strategy for easy problems (Figure 7, right, bins 1–2): purely sequential revision with 64 generations means generating one chain of 64 sequential revisions. Each revision requires the full context of all previous steps, making the process entirely serial. In contrast, the baseline parallel best-of-N with 64 generations can run all 64 samples simultaneously on sufficient hardware. In terms of wall-clock time, the sequential strategy takes approximately 64× longer than the parallel strategy for the same FLOPs budget.

The paper briefly discusses this for the revision model:

"At test time, the revision model generates a chain of revisions: it produces an initial answer, then conditions on that answer to produce a revision, then conditions on the revision to produce another revision, and so on." (Section 6.1, inference description)

But it never quantifies the latency implications. For the PRM search methods, beam search is also inherently sequential (each step depends on the previous step's beam scores), though the serial depth is the number of solution steps (typically 5–20 for math problems) rather than the number of generations.

The consequence. In latency-sensitive applications—interactive tutoring, real-time problem-solving assistants, API services with SLA requirements—the sequential-heavy strategies favored by the compute-optimal policy on easy-to-medium problems may be practically unusable regardless of their FLOPs efficiency. A user waiting for an answer will not care that the system used 4× fewer FLOPs if the answer takes 64× longer to arrive. The paper's efficiency claims (4× fewer generations) come with a hidden latency cost that is not discussed and that could render the optimal policy unacceptable in deployment.

The latency issue also creates a tension between the two axes the paper studies. PRM beam search adds serial depth proportional to solution length (manageable at 5–20 steps), while sequential revisions add serial depth proportional to the generation budget (up to 64 or 128 steps, which is much worse). The compute-optimal policy for some difficulty/budget combinations might select revisions over search for their accuracy advantage, but in practice the latency penalty might make search preferable despite lower accuracy. The paper provides no framework for trading off latency against accuracy.

What evidence exists in the paper. The paper never reports wall-clock time, latency, or throughput numbers. The generation budget is the sole cost metric. Sequential revision chains of up to 64 steps are mentioned in Section 6.1 and shown in Figure 6 (left, pass@1 trajectory out to step 64), but the serial nature of these chains and their latency implications are not analyzed. The paper's discussion of practical deployment (Section 8) focuses on self-improvement loops and distillation, not on latency constraints.

Mitigation status. The paper does not address this limitation at all—it is entirely absent from the discussion. A practitioner deploying these strategies would need to independently assess the latency-accuracy tradeoff and potentially override the compute-optimal policy in latency-sensitive contexts (e.g., by capping the maximum sequential chain length, or by switching to parallel strategies when user-facing latency matters). This is a significant practical gap that limits the deployability of the paper's recommendations without additional engineering.

The Revision Model Has a ~38% Correct-to-Incorrect Reversion Rate

The assumption or constraint. The revision model is trained exclusively on sequences where all in-context answers are incorrect, followed by a correct answer (Section 6.1, training data construction). This means the model has never seen a correct answer in its context during training. The consequence is predictable: at test time, when a revision chain produces a correct answer at some intermediate step, the model has no training signal for what to do next. The paper reports:

"approximately 38% of correct answers get converted back to incorrect ones" (Section 6.1, discussing the correct-to-incorrect reversion problem).

This is a direct consequence of the training data design, not an unforeseen bug. The edit-distance-based pairing strategy ensures that the incorrect answers in the training context are "close" to the correct target, which teaches the model to make targeted corrections. But it provides no signal about the case where the current answer is already correct—the model is never trained to output "no revision needed" or to preserve a correct answer unchanged.

The consequence. The revision model is fundamentally unreliable as a monotonic improver. You cannot simply run a long revision chain and take the final output; the model will often "fix" things that are not broken, degrading correct answers. The paper mitigates this with a selection mechanism across the entire chain (majority voting or verifier-based selection, Section 6.1), which picks the best answer from any point in the chain rather than trusting the final revision. But this is a patch, not a solution. The selection mechanism adds overhead (you must evaluate every step in the chain, not just the final output) and is itself imperfect—the verifier or majority vote can select an incorrect answer from earlier in the chain, missing a correct answer that appears later (before being reverted).

The 38% reversion rate also implies that ~38% of the chain's resources are wasted on generating revisions that are worse than what the model had already produced. In a budget-constrained setting, these wasted generations could have been spent on parallel exploration instead. The compute-optimal policy (Figure 7) partially accounts for this by selecting the best sequential-to-parallel ratio per difficulty bin, but the reversion problem means that the effective "good generations per chain" is significantly lower than the total chain length.

What evidence exists in the paper. The 38% figure is quoted directly in Section 6.1. Figure 6 (left) shows the pass@1 rate across revision steps—while the overall trend is upward, there are clear fluctuations where pass@1 drops from one step to the next, consistent with correct answers being reverted. The paper mentions majority voting and verifier-based selection as mitigations but does not report the reversion rate with these mitigations in place. It is unclear whether majority voting reduces the effective reversion rate to (say) 10% or 25%—the 38% is reported as a raw statistic without the selection mechanism applied.

The ReST^EM experiment (Appendix K, Figure 16) provides additional evidence that the revision training procedure is fragile: attempting to optimize the revision model with RL-style training caused performance to substantially degrade with sequential revisions, suggesting that the training data construction methodology is not robust to distribution shift.

Mitigation status. The paper acknowledges the problem and applies a mitigation (selection across the chain), but does not fundamentally solve it. A more principled fix—such as training the model on trajectories that include correct answers in context with a "stop" or "no change needed" target, or training a separate classifier to detect when revision is unnecessary—is not explored. The limitation is a fundamental consequence of the training data design that the paper does not fully resolve, leaving the revision model suitable for offline batch processing (where you can afford to generate a chain and select the best answer) but less suitable for interactive use cases where you want a reliable monotonic improvement guarantee.

7. Implications and Future Directions

How This Work Changes the Landscape

WebWorld changes the landscape by demonstrating that web-scale world models are not only feasible but follow the same scaling logic as language models themselves — specifically, that exposure to the raw diversity of the open web produces a qualitatively different kind of world model than careful curation on benchmark environments ever could. This is not an incremental improvement over prior trained world models (which achieve near-zero scores on WebWorld-Bench); it is a categorical jump that puts open-weight simulators into the same performance tier as proprietary frontier models for the first time.

The shift is primarily methodological rather than architectural. WebWorld does not introduce a novel model architecture, training objective, or inference algorithm. Its contribution is a data-centric scaling recipe: a three-level hierarchical collection pipeline that harvests 1.06M real-world trajectories from the open web, combined with format enrichment, a knowledge-then-reasoning two-stage curriculum, and a dual-metric evaluation framework. This recipe is replicable — the paper explicitly frames it as "a replicable recipe for world model construction" — and it fundamentally changes what "building a web world model" means. Before WebWorld, the dominant approach was to collect trajectories from benchmark sandboxes (WebArena, WebShop) using task-directed execution, producing small (4K–70K), narrowly-distributed datasets. The implicit assumption was that quality and task relevance were the binding constraints. WebWorld falsifies this by showing that breadth and volume matter more: the 293K trajectories from randomized crawling — which are explicitly not task-aligned, not curated for quality, and not restricted to any domain — are the largest single component of the training data (43.3%) and appear to be the primary driver of generalization, since they teach the model the basic transition dynamics of the web across hundreds of thousands of distinct websites.

This reorients the field's research priorities. The question shifts from "how do we design better simulation architectures?" to "how do we harvest more diverse interaction data from the open web?" It makes data pipeline engineering the central challenge for world model construction, much as pretraining data curation became the central challenge for LLMs after the Chinchilla scaling laws. Simultaneously, it makes certain previously-attractive research directions less compelling: investing in sophisticated search or planning algorithms for world model training (as in MCTS-based approaches like WebSynthesis and Word2World) now appears less urgent than simply collecting more diverse data, since WebWorld's simple autoregressive training on broad data outperforms those approaches by large margins.

The paper also resolves a contradiction in prior work that was not even recognized as a contradiction. Prior trained world models claimed varying degrees of success on their respective benchmarks, but when evaluated on WebWorld-Bench — which tests open-web generalization rather than benchmark-specific patterns — they collapse to near-zero scores (Table 3: WebSynthesis-8B 16.7% Factuality, WMA-8B 11.1%, Word2World-8B 7.0%). These were not fundamentally different approaches with different capabilities; they were all suffering from the same failure mode of distributional overfitting to narrow training environments. The paper's unified evaluation framework reveals this, reconciling the field's fragmented prior results into a coherent picture: trained world models can work well, but only if their training distribution matches the diversity of the target deployment. The web, by virtue of containing essentially every type of digital interface, provides that diversity.

The knowledge-then-reasoning curriculum finding (Table 7) has implications beyond web world models. The demonstration that learning dynamics on massive data first, then activating reasoning on a tiny CoT dataset (1K samples), dramatically outperforms training reasoning from scratch on 10× more data (10K samples) suggests a general principle: explicit reasoning is more efficiently taught as externalization of already-internalized knowledge than as a de novo skill. This challenges the standard fine-tuning paradigm where reasoning is trained jointly with the task, and it opens the possibility that many domains where raw task data is abundant but annotated reasoning data is scarce could benefit from this two-stage approach.

Finally, the cross-domain generalization results (Table 8) plant a flag for a new research direction: the web as a foundational training environment for general digital world modeling. The finding that web-scale training transfers to code, GUI, and game domains with only lightweight fine-tuning suggests that the web's extreme interface diversity makes it a uniquely valuable pretraining distribution — a kind of ImageNet for digital interaction. This reframes how researchers should think about data collection for specialized world models: rather than starting from scratch in each domain, start with web-scale pretraining and fine-tune. The days of training world models on single-digit-thousands of benchmark trajectories may be numbered, not because the methods are wrong, but because the data scale is insufficient.

Follow-Up Research This Work Enables

Ablation of the hierarchical pipeline levels to quantify the contribution of breadth versus task alignment. The paper's central claim is that open-web diversity drives generalization, but the training data mixes three qualitatively different collection strategies: randomized crawling (breadth, 43.3%), autonomous exploration (realism, 20.4%), and task-oriented execution (goal alignment, 16.1%), plus auxiliary data. A researcher could train separate WebWorld models on: (1) only Level 1 data (293K random crawling trajectories), (2) only Level 3 data (94K task-oriented trajectories), (3) Levels 1+2 without task data, and (4) Levels 2+3 without random crawling. Evaluating all four on WebWorld-Bench would reveal which pipeline level drives which capabilities — for example, whether fine-grained sensitivity comes from task-oriented form interactions (Level 3) or whether long-horizon consistency requires autonomous exploration (Level 2). This would also test whether the 293K random trajectories alone can match the full pipeline's performance, which would validate the "breadth beats curation" thesis in its strongest form.

Cheap difficulty estimation via learned difficulty predictors for compute-optimal allocation. The paper's own compute-optimal scaling framework (from the prior sections) requires 2,048 samples per question for difficulty estimation, making it impractical. WebWorld's data pipeline provides a natural solution: train a lightweight difficulty classifier on the 1.06M trajectories, where "difficulty" could be operationalized as the PRM's average score or the base model's pass@1 on that website/task. Since WebWorld has already collected massive interaction data with known outcomes, it could serve as a training environment for meta-models that predict how hard a given task-website pair will be for a given agent architecture. A strong follow-up would train a small classifier (perhaps a few hundred million parameters) that takes only the task instruction and initial page state as input and predicts which difficulty quintile it belongs to, then evaluate whether compute-optimal allocation using this cheap predictor recovers the 4× efficiency gains without the 2,048-sample overhead.

Combining WebWorld with PRM-guided search for agent action selection. The paper briefly explores inference-time lookahead search (Table 6) but finds bounded gains (+3.2% over greedy). This is likely because the search depth is limited by context length (k=2 for A11y Tree, k=5 for natural language). A natural extension is to train a dedicated process reward model — analogous to the PRM in the prior sections — that scores partial trajectories in WebWorld's simulated states, enabling deeper tree search without needing to retain full states in context. The PRM could be trained on WebWorld's own trajectory data by using Monte Carlo rollouts: for each step in a collected trajectory, complete the trajectory multiple times in simulation and compute the fraction that achieve the task goal. This would enable MCTS-style search over WebWorld-simulated states, potentially unlocking larger gains from inference-time planning than the current shallow lookahead approach. A concrete experiment: train a PRM on 10K WebWorld trajectories, then evaluate MCTS with k=10 or k=20 on MiniWob++ and WebArena, comparing against the k=3 Best-of-N approach in Table 6.

Testing whether WebWorld-synthesized trajectories enable self-improvement loops without degradation. The prior sections' paper found that ReST^EM-style self-improvement degraded the revision model's performance (Appendix K), likely due to distribution shift in on-policy data. WebWorld provides a way to test this hypothesis in the web domain without the risks of real-world interaction. A researcher could implement an iterative self-improvement loop: (1) use WebWorld to generate 10K trajectories with the current agent, (2) fine-tune the agent on successful trajectories, (3) use the improved agent to generate another 10K trajectories, and (4) repeat for N iterations. The key measurement is whether agent performance on real WebArena continues to improve across iterations or plateaus/degrades due to simulation-reality mismatch accumulating over successive fine-tuning rounds. The paper's observation that WebWorld exhibits sycophancy — "generating overly optimistic outcomes that cater to the agent's action" — predicts that this loop will eventually degrade as the agent learns to exploit the simulator's biases. A strong follow-up would quantify how many iterations are useful before degradation sets in, and whether techniques like adversarial filtering or mixing real trajectories can extend the useful iteration count.

Cross-model replication of the difficulty-dependent strategy findings. All experimental results in the prior sections were obtained with PaLM 2-S* on MATH. The paper establishes a methodology (estimate difficulty, sweep strategies per bin, select compute-optimal allocation) but does not validate that the specific strategies discovered — beam search on medium problems, sequential revisions on easy ones, balanced parallel-sequential on hard ones — transfer across model families. A researcher could replicate the full experimental protocol using a different base model (e.g., Llama-3, Qwen, DeepSeek) on MATH, and also replicate on a different reasoning benchmark (e.g., GSM8K, MMLU-Math, or a code generation benchmark like HumanEval). The key question is whether the qualitative pattern of difficulty-dependent strategy effectiveness is universal (beam search helps on medium, hurts on easy) or model-specific. If the pattern is universal, it becomes a reliable design principle for inference systems. If it varies by model, then the methodology (not the specific strategies) is the portable contribution, and every deployment requires its own strategy sweep.

Stress-testing WebWorld's generalization to adversarial or out-of-distribution websites. WebWorld is trained on URLs from FineWeb and CCI 3.0, which represent the surface web — primarily mainstream commercial, educational, and informational sites. A stress-test would evaluate WebWorld on deliberately out-of-distribution web environments: government portals with complex multi-page form workflows, single-page applications with heavy JavaScript state management (where the A11y Tree may not capture all relevant dynamics), non-English websites not represented in CCI 3.0 (e.g., Arabic, Hindi), or adversarial websites designed to confuse automated agents (honeypots, CAPTCHA-like interaction patterns). A concrete experiment: curate a small test set of 100 trajectories from each of these out-of-distribution categories, evaluate WebWorld's Factuality and Turing scores, and identify which categories cause the largest performance drops. This would define the operational envelope of the current model and identify where additional data collection is most needed. It would also test the claim that WebWorld is a "generalist world model" — if performance collapses on government forms or SPAs, the generalization is shallower than the paper's domain diversity chart (Figure 3a) suggests.

Practical Applications and Downstream Use Cases

Cost-efficient batch trajectory synthesis for web agent training in enterprise settings. An organization building a web agent for internal workflow automation (e.g., processing invoices across multiple vendor portals, filling standardized compliance forms, or automating CRM data entry) faces the same bottleneck that motivates WebWorld: real-world interaction is slow, risky, and rate-limited. WebWorld provides an offline alternative: the organization can fine-tune WebWorld on a small set of their specific target websites (perhaps 50–100 trajectories per site, following the cross-domain fine-tuning protocol from Section 6.3), then use the fine-tuned world model to synthesize thousands of training trajectories for their agent. The paper's results suggest this would dramatically reduce the need for live interaction during agent development: the 10.9% WebArena improvement (Table 5) was achieved with only 8,000 synthesized trajectories, and the cross-domain results (Table 8) show that WebWorld initialization provides +0.224 Total Score advantage even with as few as 1,500 domain-specific samples. For an enterprise with 10–20 target websites, the total data collection burden could be a few hundred real trajectories (for fine-tuning the world model) plus automated synthesis of thousands more — a practical, cost-effective pipeline that avoids the safety and rate-limiting issues of large-scale live browsing.

Bootstrapping web agents for low-resource languages and regional websites. The paper's data pipeline sources URLs from FineWeb (English, ~618K URLs) and CCI 3.0 (Chinese, ~64K URLs). The hierarchical collection strategy — randomized crawling, autonomous exploration, task-oriented execution — is language-agnostic and requires only that the base LLM can process the website's text. A practitioner could extend WebWorld to a new language by: (1) sourcing URLs from a pretraining corpus in that language, (2) running the same three-level pipeline with an LLM that supports the language, and (3) fine-tuning WebWorld on the resulting trajectories. The paper's scaling results (1.06M trajectories taking ~4 days on 16×A100 for the 8B model) provide a concrete resource estimate: a researcher with access to a similar compute budget could build a regional-language web world model from scratch. The downstream benefit is that agents for low-resource web environments could be trained primarily in simulation, avoiding the even-more-severe real-world interaction constraints in these settings (fewer accessible websites, stricter rate limiting, less tooling support). This is a direct path to democratizing web agent capabilities beyond English and Chinese.

Integration with inference-time tool use in coding agents. The cross-domain generalization results (Table 8) show that WebWorld transfers to code environments with +0.249 Total Score gain at 1,500 samples and +0.275 at 3,000 samples. A coding agent that uses web APIs or scrapes documentation pages could incorporate WebWorld as a simulated environment for planning: before making a real API call or navigating to a documentation page, the agent simulates the outcome in WebWorld to verify that the action will produce the expected result. This is the same lookahead paradigm evaluated in Table 6, but applied to code-web interaction rather than pure web navigation. The concrete benefit is reducing failed API calls, authentication errors, and incorrect page navigation during automated coding workflows — each of which costs real time and may trigger rate limits. Since WebWorld is open-weight and can run locally, this simulation adds zero API cost per step, unlike using GPT-4o or GPT-5 as the world model. The experiment would be: integrate WebWorld into a coding agent's tool-use loop, measure the reduction in failed web interactions compared to an agent that executes actions without simulation, and quantify the wall-clock time savings from avoiding rate-limit backoffs and retries.

When to Prefer This Method

The paper explicitly positions WebWorld against two alternatives — prompting proprietary LLMs as world models (UI-Simulator, Simia) and training world models on closed benchmark environments (DreamGym, WMA, WebSynthesis) — and the experimental results in Tables 3, 5, and 6 provide clear decision boundaries.

Prefer WebWorld-style open-web training when:

• The target deployment spans diverse, uncontrolled websites (not a fixed set of known benchmarks). Table 3 shows that benchmark-trained models achieve 7–17% Factuality on open-web evaluation, while WebWorld achieves 70–71%.
• You need to synthesize large volumes of training trajectories (>1K) for downstream agent fine-tuning. The 8,000 trajectories used in Table 5 would cost hundreds of dollars in API calls if generated via GPT-4o but are essentially free with a locally-deployed WebWorld model after the one-time training cost (~4 days on 16×A100 for the 8B model, Table 9).
• You require multi-format simulation (A11y Tree, HTML, XML, Markdown) or natural language state descriptions. Table 3 shows WebWorld maintaining 63–75% Factuality across formats, while proprietary models vary widely (GPT-4o achieves 47.3% on HTML vs. 64.1% on Markdown).
• The base agent model shares pretraining data sources with WebWorld's URL corpus (FineWeb, CCI 3.0), since the paper argues explicitly that this alignment "maximizes the activation of its innate web understanding."

Prefer prompting proprietary LLMs when:

• The number of trajectories needed is small (<100) and per-trajectory quality matters more than volume. GPT-4o and Claude-Opus-4.1 match or exceed WebWorld-32B on several WebWorld-Bench dimensions (Table 3), so for small-scale high-stakes synthesis, API-based simulation may be worth the cost.
• Deployment requires zero infrastructure beyond API access. Training WebWorld requires GPU clusters and data pipeline engineering; if those are unavailable, prompting GPT-4o or Gemini as a world model is the only feasible option.
• The target websites are not well-represented in FineWeb/CCI 3.0. WebWorld's performance on genuinely novel website structures is untested, and proprietary models' broader pretraining may provide better zero-shot generalization to unseen web patterns.

Prefer benchmark-trained world models when:

• The deployment is strictly limited to a specific benchmark environment (e.g., you are building an agent exclusively for WebArena and have no need for open-web generalization). In this narrow setting, a model like DreamGym or WMA trained specifically on WebArena trajectories may outperform WebWorld on that specific distribution — though Table 3 suggests this requires format-matching during evaluation, and the paper provides no direct WebArena-only comparison.
• Training data from the target environment is already abundant (e.g., you have 50K+ real trajectories from your specific web application). In this case, training from scratch on in-domain data may be simpler than the hierarchical pipeline, though WebWorld's cross-domain results (Table 8) suggest that even here, WebWorld initialization provides faster adaptation.