Language agents increasingly require persistent worlds in which they can act, remember, and learn. Existing approaches sit at two extremes: conventional web frameworks provide reliable but fixed contexts backed by databases, while fully generative world models aim for unlimited environments, but the world is constructed primarily through generation, making it harder to maintain a fixed, deterministic global framework and reducing controllability. In this work, we introduce the Web World Model (WWM), a middle ground where world state and ``physics'' are implemented in ordinary web code to ensure logical consistency, while large language models generate context, narratives, and high-level decisions on top of this structured latent state. We build a suite of WWMs on a realistic web stack, including an infinite travel atlas grounded in real geography, fictional galaxy explorers, web-scale encyclopedic and narrative worlds, and simulation- and game-like environments. Across these systems, we identify practical design principles for WWMs: separating code-defined rules from model-driven imagination, representing latent state as typed web interfaces, and utilizing deterministic generation to achieve unlimited but structured exploration. Our results suggest that web stacks themselves can serve as a scalable substrate for world models, enabling controllable yet open-ended environments.
Figures & tables
Figure 1: Left : Traditional Web Frameworks fix context in databases, limiting scalability. Center : The Web World Model (Ours) decouples logic from content, generating unlimited context via LLMs upon a code-based physics layer without heavy data storage. Right : Fully generative world models can produce unlimited context and rich video/3D content, but when the world is constructed primarily through generation, it is harder to maintain a fixed, deterministic global framework, reducing controllability.
Figure 2: Illustrations of a series of Web World Models introduced in this work. Details are presented in Section 3 .
Figure 3: The Web World Model Architecture: A separation between the deterministic Code Layer (Physics) and the stochastic AI Layer (Imagination).
Figure 4: Deterministic Generation: The inputs (visits) converge on the coordinates, passing through the hash function to produce a frozen seed. This forces the LLM to output the same world state every time.
Figure 5: Infinite Travel Atlas interaction flow. (a) The user selects a geographic coordinate on the reactive globe. (b) This input is hashed to retrieve a deterministic seed and location metadata, grounding the request in the Physics layer ( Sϕ ). (c) The Agent receives this context and triggers the LLM (Imagination layer Sψ ) to generate a structured destination guide, determining visual themes and itinerary details. (d) The resulting content is rendered on the client, providing a cohesive, persistent experience without backend storage.
Figure 6: Galaxy Travel Atlas system architecture. Navigation events trigger a procedural generation sequence where the coordinate hash seeds the local star system layout (Physics). The Agent retrieves this immutable structural state and queries the LLM to synthesize narrative elements, mission briefs, hazards, and lore, conforming to a strictly typed JSON schema. This ensures that while the universe is infinite, every planet remains revisited and logically consistent.
Figure 7: Neural-symbolic architecture of AI Spire . A client-side TypeScript/React combat engine maintains player/enemy state (HP, energy, deck/hand, status effects, and enemy intent); when combat is won, the reward phase triggers either a standard reward (three generated cards) or a user-specified “Wish” for a custom card. In both cases, Gemini Flash acts as a constrained designer and returns a schema-structured JSON specification (name, description, and effect codes), which is checked by a contract-and-validation layer shared via TypeScript interfaces ( ICard / IRelic ). The symbolic core then translates effect codes into deterministic rule execution and updates the deck/relic inventory, closing the loop for the next encounter.
Figure 8: User interface of the reward page of AI Spire . After winning an elite combat, an extra lyrics reward is generated by LLM (red box). Three common cards are generated by LLM and provided to the user (blue box). Besides the common rewards, users could also set a “wish” (green box) to customize the reward card, such as typing “a card that could deal a huge amount of burn to the enemy.” and then the neural-symbolic core will generate a card based on the user’s request, as shown in the orange box. User could also choose to skip the reward (purple box), as in a classical Slay the Spire -like game.
Figure 9: Neural-symbolic architecture of AI Alchemy . A React+Canvas user interface (toolbar and natural-language Creator Console) injects user-defined materials into a symbolic cellular-automata “falling-sand” simulator. Upon particle collisions, the engine applies existing reaction rules when available; otherwise, it queries an LLM (Gemini Flash) to synthesize a schema-constrained reaction outcome, which is cached and immediately integrated into the update loop. An optional AI Supervisor monitors the canvas and guides/perturbs the system, enabling controlled emergent behavior in a self-expanding sandbox.
Figure 10: User interface of AI Alchemy . The upper-left panel (blue box) shows the creator console, where users can use natural language to introduce new elements with desired rules. The lower-left panel (orange box) shows the element bar, displaying current available element. The top overlay (green box) indicates the AI supervisor layer, toggling whether LLMs are introduced into gameplay. The central canvas (purple box) represents the simulation canvas, where all the automata’s behaviors take place. The right panel (red) displays the Alchemist log, recording LLM-generated elements and corresponding reactions.
Figure 11: Neural-symbolic architecture of Cosmic Voyager . A browser-based user interface (mode selection for orbit view, piloted flight, and surface walk, plus planet selection and camera control) drives a WebGL solar-system engine that manages scene/state, procedural assets, navigation logic, and rendering. The engine streams the currently selected celestial body and view context to a symbolic core (Gemini Flash), which generates (i) a short, general sidebar description and (ii) view-dependent “Cosmic Guide” narration that refreshes every 30 s as a bottom subtitle with a typewriter reveal. When the API is unavailable, the system falls back to bundled descriptions to preserve a continuous educational experience.
Figure 12: User interface of Cosmic Voyager (left to right). Orbit Mode (circled with blue box) presents a high-level solar-system overview with selectable bodies; choosing an object (e.g., the Sun) opens a sidebar card (circled with orange box) with key stats and an AI-generated quick summary. Pilot Mode switches to a ship-like free-flight camera for navigable traversal through the system. Surface Walk enables first-person exploration on a generated planetary surface after landing. Across all modes, a persistent bottom “Cosmic Guide” (circled with green box) subtitle strip refreshes every 30 sec with view-dependent narration tied to the currently selected body and camera context.
Figure 13: Wikipedia entry for Superconductor .
Figure 17: Library view. Users pick a UI skin (interface style) and literary tags, then select from LLM-proposed book cards.
Appendix figures & tables23 assets
Supplementary material from the paper’s appendix.
Appendix
Figure 20: Infinite Travel Atlas (a) Initial globe view with an empty cockpit inviting the user to pick any glowing beacon.
Figure 21: Infinite Travel Atlas (b) After selecting Innsbruck, the beacon lights up and the cockpit begins to fill with a themed guide.
Figure 22: Infinite Travel Atlas (c) Full generated guide for Innsbruck rendered as a scrollable cockpit view.
Figure 23: Infinite Travel Atlas (d) Top section of the Innsbruck guide: visual overview and why this trip feels special.
Figure 24: Infinite Travel Atlas (e) Mid-section: a three-day suggested rhythm with morning/afternoon/evening cards.
Figure 26: Infinite Travel Atlas (g) Nairobi, Kenya: warm desert-bloom theme and amber cockpit for a panoramic lookout.
Figure 27: Infinite Travel Atlas (h) Honolulu, United States: urban-pulse theme with a violet palette for an old-town district.
Figure 28: Infinite Travel Atlas (i) Rio de Janeiro, Brazil: coastal-drift theme and blue cockpit for a bay-overlook vantage point.
Figure 29: Infinite Travel Atlas (j) Los Angeles, United States: compact globe framing and atlas labels for an archaeological-site hop.
Figure 30: Galaxy Travel Atlas landing state. The left map plane is already populated by a procedurally generated cluster, while the mission brief panel stays empty and prompts the user to select a planet to open its log.
Figure 31: Atlas map plane close-up. The user adjusts the planet density slider to reshape the visible cluster (dense signal belt) while keeping navigation stable via galaxy controls and persistent node identifiers.
Figure 32: Click-to-generate interaction. Selecting Velis Minor Node triggers the agent to produce a structured mission brief (profile cards for terrain/sky/signal/hazards) plus a narrative mission hook, while the voyager thread summarizes a multi-stop route.
Figure 33: Switching to a new galaxy view. The user steps to another procedurally generated region ( Cinder Array ) and receives a fresh, dense, clickable layout before selecting any specific world.
Figure 34: Theme and content variation across worlds. Choosing Threx Drift Node yields a contrasting setting (scrapyard-metropolis flavor) with a different hazard list and signal description, while the UI structure remains the same.
Figure 35: Another node selection with a different “vibe.” Yaka Outpost renders as an oceanic outpost scenario with its own terrain/sky/signal/hazards cards and a new mission hook, illustrating location-conditioned generation.
Figure 36: Ringed gas-giant colony example. Arda Spire demonstrates how the same atlas interaction pattern supports visually and narratively distinct worlds (e.g., ring structures, atmospheric hazards, and a different exploration prompt).
Figure 37: Generation-in-progress (“syncing”) state. After selecting Krypton Gate Node , the mission panel enters a live calibration/loading phase while the agent prepares the brief, keeping the interface responsive during content generation.
Figure 38: City-world mission brief. Halion Reach Node illustrates another distinct profile: a dense metropolitan terrain with different hazards and a separate mission hook, showing repeatable structure with high-variance content.
Figure 39: Anchor-type destination. Halo Corridor Anchor highlights that the atlas supports non-planet nodes as well, while the Voyager thread continues to stitch worlds into longer exploratory routes across galaxies.
Figure 40: Cosmic Voyager: User can click on the planet to view its description, which is generated by LLM (Gemini 2.5 flash). The AI narration appears at the bottom as a subtitle, showing the description of the user’s view.
Figure 41: Cosmic Voyager: The demo allows the user to land on the planet and walk on it. The terrain is generated by an LLM with rocks and small mountains on it. The day/night light effect also cast shadow on the rocks. The AI narration persists in this mode.
Figure 42: Cosmic Voyager: User can click on an asteroid belt and see its description. The description includes the owner, the mining data, and the size, which is based on the position.
Web agents require massive trajectories to generalize, yet real-world training is constrained by network latency, rate limits, and safety risks. We introduce WebWorld series, the first open-web simulator trained at scale. While existing simulators are restricted to closed environments with thousands of trajectories, WebWorld leverages a scalable data pipeline to train on 1M+ open-web interactions, supporting reasoning, multi-format data, and long-horizon simulations of 30+ steps. For intrinsic evaluation, we introduce WebWorld-Bench with dual metrics spanning nine dimensions, where WebWorld achieves simulation performance comparable to Gemini-3-Pro. For extrinsic evaluation, Qwen3-14B trained on WebWorld-synthesized trajectories improves by +9.2% on WebArena, reaching performance comparable to GPT-4o. WebWorld enables effective inference-time search, outperforming GPT-5 as a world model. Beyond web simulation, WebWorld exhibits cross-domain generalization to code, GUI, and game environments, providing a replicable recipe for world model construction.
World models are moving from generating realistic frames to generating playable worlds, yet whether a delivered world can keep running is not tested anywhere. Existing evaluations stop at generation, at delivery, or at single-step transitions, and each stops at a different point along the way. Correct local state transitions or intermediate outcomes do not guarantee a correctly organized causal event flow. We propose the world agent task, which moves the evaluation point of world generation from the moment of delivery to the continued operation that follows. In this task, a model is not asked to generate a world. It is held responsible for keeping the world running, which requires coordinating events and carrying forward their consequences to constrain subsequent evolution. We instantiate the task in WorldAgent-Benchmark with two complementary tracks. In the maintenance track, the model must ground the events of a continuous narrative into correct transitions of the explicit world state while respecting causal, temporal, and concurrency constraints. In the deduction track, the model must predict how the world will evolve under partial observations and act toward a goal. The maintenance track combines LLM-assisted semantic judgments with programmatic validation and scoring, while the deduction track is evaluated entirely programmatically. Individual judgments are auditable against world states and execution logs, and scores can be recomputed from the saved judgments and execution records. Across 8 models, scores decline steadily as pre-built structure is removed from the world, and causal-relation checking is the weakest component for every model. The benchmark makes the continued operation of a world measurable and distinguishes local completion from failures in event organization. Code and dataset will be released on https://github.com/HCPLab-SYSU/WorldAgent-Benchmark.
Weixing Chen, Weipeng Zhang, Nan An +2
Sun Yat-sen University · South China University of Technology · Guangdong Key Laboratory of Big Data Analysis and Processing +2
Language agents solve complex tasks through plans and actions. A single step the world refuses puts the goal out of reach, and what the agent does next decides the task. Prompted planners fail at exactly this point, rewriting the refused step in new words, meeting the same refusal, and burning the attempt budget without moving. They fail because the plan was never tied to the world, so a refusal has nothing in the plan to attach to. A world is where a task runs, and it has its own rules, its own admissible actions, and its own constraints. We build synthetic worlds across 7 domains and extract training data from them. A program enforces each world's rules and grades its goal, and every world is admitted only if its goal is reachable from its initial state. Agents run inside and leave verified failures paired with repairs that carried the run to a state the world certified, a record of about 226K trajectories. On this record we train the World State Generator, a model that writes a plan as checkable states of the world and keeps that plan aligned with the world it runs in. That alignment is what a plan written in language lacks, since the world it runs in has physical limits, logical dependencies, and required orders the language never states, and the plan encounters these rules only when a state fails. WSG takes that failure as the rule the world has stated and rewrites the remaining states to obey it, so the plan bends to the world as the run goes on. Across 7 public benchmarks, WSG raises end-to-end success for two open models near 30B parameters over prompting and brings to the level of proprietary model.
Sungheon Jeong, Sanggeon Yun, Ryozo Masukawa +3
University of California, Irvine · Northeastern University