Checkout should be boring.
A customer adds an item to a cart, applies a valid discount, pays the displayed amount, and receives the product that inventory records said was available. This is not an area where an imaginative AI assistant should decide that loyalty deserves a 70% discount, that an empty warehouse contains one final box, or that payment is optional because the customer asked nicely.
The product description, however, can be imaginative. So can the guided shopping experience, the visual theme, the explanation of why two products work well together, and the conversational path used to help the customer choose.
That division captures the central idea behind Web World Models: code should determine what is true and what actions are permitted; a language model can determine how the resulting world is described, explored, and expanded.[^1]
The paper gives this division unusually ambitious packaging. It presents the ordinary web stack as a substrate for persistent, open-ended “worlds” in which humans or AI agents can navigate, act, and generate new content. Its seven demonstrations range from procedural galaxies and card games to an on-demand encyclopedia and an infinitely extending bookshelf.
The strongest contribution, however, is not the size of those worlds. It is the proposed boundary between deterministic software and probabilistic generation.
That boundary is what makes the paper relevant beyond games and digital atlases. It offers a practical pattern for businesses trying to introduce generative flexibility without allowing a model to improvise inside the systems that enforce money, permissions, inventory, compliance, or operational state.
A World Model Does Not Have to Dream in Pixels
The phrase “world model” often suggests a learned simulator: a neural network builds an internal representation of an environment, predicts how it changes, and uses those predictions for planning. Recent visual world models make the idea especially easy to associate with generated video, three-dimensional environments, and increasingly expensive demonstrations of synthetic reality.
The Web World Model, or WWM, uses the term more broadly.
Its “world” is an interactive environment with persistent rules, entities, possible actions, and observable state. Much of that environment is represented through conventional web technologies: TypeScript modules, JSON objects, interfaces, HTTP handlers, browser components, caches, and procedural generators.
The language model does not need to contain the entire world internally. It receives a structured slice of the current state and generates a bounded addition: a mission briefing, a destination guide, a fictional card, a reaction between materials, an article section, or the next page of a story.
This produces a middle layer between two familiar approaches:
| Approach | What defines the environment | Principal advantage | Principal constraint |
|---|---|---|---|
| Conventional web application | Databases, schemas, code, and predefined content | Reliable, observable, and testable | Experiences are bounded by content and workflows anticipated by developers |
| Fully generative environment | Model-generated representations and transitions | Open-ended content and interaction | State consistency, control, debugging, and cost become difficult |
| Web World Model | Code-defined state and transitions, enriched by model-generated content | Combines programmable rules with expandable content | Flexibility remains bounded by the interfaces and generators developers design |
The third category is less futuristic than a fully generated universe. That is part of its appeal. A Web World Model can inherit decades of web engineering practices while using generation only where variation is valuable.
The Core Mechanism: Code Decides What Happened
The paper divides a world into two conceptual layers.
The Physics layer contains deterministic state and rules. It tracks coordinates, inventories, resources, connectivity, valid actions, game effects, rendering structures, and other invariants. When an action occurs, code calculates its permitted consequences.
The Imagination layer generates perceptual or semantic content conditioned on the resulting state. It may write dialogue, describe a planet, propose a card, explain a location, or continue a story.
The sequence matters:
User or agent action → deterministic state transition → structured state → model-generated content → rendered experience
Suppose a player requests a card that inflicts fire damage and freezes an enemy. A language model may translate that request into a card specification. The game engine still decides how damage, status effects, energy costs, and turn order operate. The model proposes within a vocabulary; code executes the consequences.
This arrangement limits the model’s authority without eliminating its creative role. The model can invent a dramatic name and an unusual combination of permitted effects. It cannot silently rewrite the combat engine while doing so.
For a business application, the equivalent separation might look like this:
| Code-owned reality | Model-owned interpretation |
|---|---|
| Account balances | Plain-language financial explanation |
| Access permissions | Personalized onboarding guidance |
| Inventory availability | Product comparison narrative |
| Approved workflow transitions | Suggested next action |
| Contract fields and validation rules | Drafted supporting text |
| Pricing and discount limits | Conversational presentation |
| Evidence retrieved from approved sources | Structured summary of that evidence |
The architecture does not require every model output to be harmless. It requires the system to decide which outputs are permitted to affect reality.
That is a much more useful design question than asking whether a model is generally trustworthy.
Four Principles Turn the Boundary into an Architecture
The paper distills four design principles from its implementations: separation of physics and imagination, typed interfaces, deterministic procedural generation, and graceful degradation.
They are presented as principles for building open-ended worlds. Read operationally, they also form a compact control framework for production generative systems.
1. Separate the Rules from the Generated Experience
The first principle is the architectural split itself.
State transitions that must remain consistent belong in code. Generative models operate after, around, or within explicitly restricted transitions. The clearer this division becomes, the easier it is to test failures independently.
A malformed travel description should not corrupt geographic coordinates. A weak piece of dialogue should not alter an inventory. A model timeout should not make a locked door become passable.
The difficult part is deciding where the boundary belongs.
In the paper’s Galaxy Travel Atlas, galaxy layouts, star-lane connectivity, planetary identifiers, and resource distributions are generated by deterministic procedures. The model adds mission briefs, hazards, lore, and descriptive texture.
In AI Alchemy, the boundary is more permissive. The model can propose previously undefined reactions between materials, and the resulting rule is cached for future use. Yet the simulator restricts generated parameters such as decay probability and energy use before integrating the reaction into its cellular-automata engine.
Both applications separate physics from imagination, but they assign different authority to imagination. The galaxy model largely decorates a computed structure. The alchemy model can extend part of the rule set, provided the extension passes through constrained interfaces.
For businesses, this suggests that “keep the model out of the rules” is too crude. A more useful hierarchy is:
- Presentation authority: the model may describe an approved result.
- Recommendation authority: the model may propose an action for review.
- Constrained configuration authority: the model may produce parameters inside validated ranges.
- Transition authority: the model may trigger a predefined action after validation.
- Rule-making authority: the model may introduce new operational rules.
The further down the list a system goes, the more validation, monitoring, rollback capability, and human governance it needs. Most enterprise deployments should become suspicious well before level five. Suspicion is cheaper than an incident review.
2. Typed Interfaces Make Generated State Inspectable
In a conventional neural world model, latent state may exist as an opaque vector. In a WWM, the latent state is represented through explicit, typed interfaces.
A generated planet might need fields for its biome, hazard category, risk profile, and sector identifier. A generated card might require a name, cost, card type, and effect codes. A generated article might need a title, section structure, references, and evidence-linked claims.
The model is asked to return structured data that conforms to these interfaces. Validation then