Tsinghua and GigaAI propose State World Models: rules settle first, then render, paired compliance rate rises from 32% to 92%

Lead: Anyone doing interactive generation will sooner or later run into this: the frame you are currently looking at simply does not contain enough information to decide what should happen next. This paper separates "rule execution" out of the pixels: first settle the events, then let a frozen video model render them. One-minute overview: Looking only at the camera is not enough: navigation control can explore, but it does not decide the consequences of an interaction; the consequences depend on semantic state that is invisible in the current frame (Abstract / Sec. 1). Split it apart: the rules first settle definite events, and the frozen video model is only responsible for drawing the events into pixels, with zero training and zero fine-tuning (Sec. 3). 50 twin pairs: the two cases share the first frame and the action, differing only in one hidden value, covering 49 hidden variables and 21 themes (Sec. 4). Baseline ceiling: under Rule-only, the best paired joint compliance rate among 11 backends is 32% (Wan2.2, MiniMax-H3). Writing the outcome clearly solves only half the problem: MiniMax-H3's PAIRFOLLOW goes from 32% to 64%, while PAIRSTRICT is still only 4%. Connect the harness: with the same frozen weights, PAIRFOLLOW 92%, PAIRSTRICT 90%, TWINCONTRAST 96% (Table 1).

The same treasure chest, the same frame, the same "open" action—when you have the key in hand it should open, and when you do not have the key in hand it should fail to open. These two things are completely identical in pixels: the starting frame is the same, the action is the same, and you cannot tell from the image whether there is a key in your backpack. Any video world model that looks only at "current frame + camera motion" has no information to rely on at this step.

This is exactly the problem addressed by arXiv:2610.26811v1 "State World Models: Execute the Rules, Generate the Pixels". The authors are from the Department of Automation at Tsinghua University and GigaAI, and their judgment is direct: navigation control makes the scene explorable, but it does not decide the consequences of interaction; to make actions obey persistently valid rules, "how the world evolves" and "how the picture grows" must become two separate things.

Their approach is to wrap a completely frozen video model with a stateful runtime (harness): the rule program settles actions into definite events before generation, the compiler compiles the events into instructions and spatial previews, and the video model is only responsible for drawing the already-determined outcome. The cost is zero training, and the benefit is a strong numerical contrast—among 11 off-the-shelf backends on the same batch of counterfactual twin samples, the best paired joint compliance rate is 32% (Figure 1); switching to the same frozen MiniMax-H3 connected to this harness gives 92%.

Figure 1 | The same frame and the same action (raising the staff) lead to two outcomes under two hidden states: the rules first settle the event, and the frozen video model then draws it into the picture. Pushing the camera can explore, but it does not guarantee that actions have consequences.

Let us first make this gap clear. Interactive video world models in the past two years have basically followed the path of "conditional generation": given an image, a camera trajectory, or a player action, the model continues writing a next segment that looks coherent. What it is good at is spatial continuity—push forward, turn right, go around and come back, and the scene roughly still matches. Explorability is not the same as interactability.

But "actions must have consequences" is another matter. The example the paper gives is small: the same key, the same treasure chest, and only when the player actually holds the key should "open" succeed. This difference depends on semantic state—inventory, progress, character attitude, endgame flags—and these quantities are simply invisible in the current frame. The authors split the requirement into two: there must be semantic state recording "what is in the backpack", and there must be addressable spatial state preserving "scene layout and camera path". The difficulty is compressed into one sentence.

I think this split is crucial. Earlier work did not lack explicit state: programmable engines, learned game variables, and NPC states recovered from generated frames have all been tried. But their evaluations focused on a few selected mechanisms and did not answer a more basic question—whether a frozen video model can render the outcomes prescribed by newly specified rules involving hidden state. Explicit state itself does not guarantee that the consequences required by the rules will appear in the picture, so the paper states the difficulty in one sentence: make state transitions authoritative and faithfully render their consequences. A pair of twin samples puts hidden state on the table.

To test this, the cleanest way is to create a pair of samples that are "identical except for the hidden state". The authors call this counterfactual twins: the two cases share the same first frame, the same action script, and the same rule program, differing only in one hidden value, and this hidden value requires two different visible outcomes. Why evaluation must be paired.

The benefit of this design is that a single video with the "correct outcome" does not prove the model is sensitive to hidden state—it might just be a coincidence. But if a pair of twins produces the same outcome under two different hidden states, then at least one of them violates the rules—this is a logical necessity, and no judge needs to guess (Figure 2). The paper gives this phenomenon a name: twin collapse. The upper half of the figure shows typical unwrapped model behavior: both cases render "chest open," and the case with haskey = false directly violates the rules; the lower half shows that after connecting the harness, the same set of rules resolves the two cases into "locked" and "open" respectively, which are then handed to the same frozen model for rendering. How the 50 pairs of samples were constructed

The evaluation set is called WorldState-Bench: 50 twin pairs, drawn from 49 hidden variables and 21 scenario themes (magic academy, dungeon, open world, romance, visual novel, escape room, sailing, farm, cards, detective, stealth, cooking, fishing, etc.). The first frame is uniformly generated by FLUX.2 at 1280×720, and then each frame undergoes 8 rounds of VLM auditing across 6 dimensions—object existence, color attribution, text, spatial cues, quantity cues, state cues—and once the audit finds evidence in the frame that could reveal the hidden value, the prompt is revised and the frame is regenerated. Hidden values are divided into three families by response type: mechanism selection (42 cases), character response (6 cases), and form selection (2 cases); by trigger method, they are divided into four categories: spellcasting, gesture, mechanism, and area. Writing the case as a program

The case itself is written as a declarative program with fixed and validated fields: theme and first-frame prompt, hidden variable declaration (name, A value and B value, list of evidence that should not appear in the frame), action (actor, verb, target, phase), and two mutually exclusive and complementary rule branches, each specifying the prescribed ending, prohibited items, and question phrases for judgment. The accompanying checker requires that the inputs of the two cases differ only in the hidden value and its consequences, and that the first-frame prompt must not leak the hidden value—the latter is not enforced by the author's self-discipline, but by the auditing of rendered results described above.

Figure 2 | Counterfactual twins: the two cases look completely identical in the frame, differing only in one hidden flag. The unwrapped model renders "chest open" in both cases; the harness first resolves, then renders. How state is stored: a semantic ledger plus a clay model

The harness maintains the world state as st = (zt, ut), belonging to two slots: semantic and spatial. zt is a serializable typed ledger: resources, entity attributes, progress counters, attitudes, ending states—all fields are typed. The benefit of this design is that it is inherently readable and writable by rules, verifiable, and replayable—rather than a blob of latent vectors that only the model itself can understand (Figure 3). The spatial half: a clay model

ut is the spatial half. Given an image, a single forward pass of a geometric model yields depth, world points, and part features; after clustering, per-instance oriented boxes are obtained, with scale anchored by a 1.7-meter human body prior and the recovered camera height; these boxes instantiate an untextured Blender scene—the clay model repeatedly mentioned in the paper. It records boxes and cameras, supports rule-based editing, and also supports procedural camera (push-in, orbit, head advance) rendering of preview clips. The deployment configuration uses a single-subject version: a SAM3-based 1.2B detector, WildDet3D, paired with LingBot-Depth to localize the subject, placing a box under a pinhole imaging model with a real height prior, and then fitting the ground in the subject's neighborhood.

What I appreciate most is the minimalism of this representation. The clay model is very rough—no materials, no joints, no textures—but it provides exactly the two things the renderer needs: layout and camera. Roughness is not a compromise but a deliberate division of labor: appearance is left to the video model, while geometry and camera are left to the editable scene asset. Position compared with peers

Placing this approach among peers makes it clearer. Programmable World Model couples the engine and 3D oriented box conditions to the pixel level; Code World Model compiles code-maintained state into proxy video and fine-tunes its own renderer; WorldMind recovers NPC state from generated frames, with spatial state also inferred back from pixels; Unbounded takes the narrative route of character life variables plus language routing. The combination in this paper is: a persistent editable scene asset, a semantic ledger, plus the standard reference inputs that the frozen renderer already has. In the authors' own words, "this combination is minimal"—a new rule world requires only a small typed program, no engine, and no fine-tuning.

Figure 3 | Stage 0: a coding agent writes an executable game definition; Stage 1: each turn first resolves rules and state, then compiles them into a visual script handed to the frozen video model. How rules are executed: resolve first, then render

At each turn, the user selects an action at. The first thing the runtime does is not generation but resolution. The rule program τR takes the current state and the action to evaluate the guard conditions and outputs three things: a tentative semantic state z̄t+1, a spatial edit script εt, and a rule event et; the edit script can add, delete, or move boxes, and can also change the camera path; applied to the clay model, it yields the tentative spatial state ūt+1. Resolution precedes generation

This ordering is the hardest constraint of the whole method. The authors state it plainly in the appendix: a rendering failure will not reverse an event that the rule program has already fixed—failure handling can retry, can reuse the previous round's anchor, or can terminate generation, but the outcome is not decided by rendering. I think this sentence captures the attitude of the entire paper: it demotes the "image" to an expression and promotes the "event" to a fact.

The language model can still participate, but it is kept in a cage. The optional neural core ρ can propose dialogue or free-form narration; the runtime performs syntax parsing, numeric clipping, a limited number of retries, and finally falls back to the default value specified by the rule program; the support set after the gate is constrained within the rule-allowed set, that is, Supp((G∘ρ)(·|s,a)) ⊆ Aτ(s,a). In other words, the model can decide "how this thing is said," but not "which thing happens."

The same caution appears in the validation order: schema checking, numeric clipping, limited retries, and fallback to defaults, tightening in four levels in sequence; the paper specifically points out that a finite schema alone is not sufficient to guarantee the containment relation—every accepted proposal must be checked against the allowed set, including the fallback values themselves. The nine-step turn lifecycle

The complete lifecycle of a turn is broken into nine steps in the appendix, and it reads much like a server-side design: gate check (end state, turn budget, empty action space → terminate) → select action (scripted, random, human, and LLM players all go through the same rule layer) → resolve on a copy of the state (without modifying the input) → map into a visual script by the domain director → the compiler validates and rejects illegal records → render (transient errors are retried a limited number of times; the default failure policy is to reuse the previous round's anchor and mark this turn as played) → update the anchor with the last frame → the VLM observes and writes back the state → write a JSON line (before/after states, events, intermediate representations, compiled prompts, seed, latency, rendering errors). Of these nine steps, only step 6 touches the video model; the rest is entirely deterministic logic—which is also why it can reproduce the entire pipeline. From events to pixels: compiling instructions, freezing rendering, and reading back state

Only after the events are fixed do the pixels come into play. The VisualScript compiler translates the resolved state and events into a typed visual script: style, first-frame anchor, camera, actors and appearance, actions, goals and reactions, dialogue, effects, stability constraints, required end state, soundscape, shot breakdown, and duration. Each slot has machine-checkable validation rules, for example, action, actor, and end state must not be empty; free text must not contain shot-breakdown markers; multi-shot sequences must be declared in the shot-breakdown slot. The compiler and the two channels

The compiler is deterministic: the same record and the same backend adapter produce the same instruction string, with no sampling and no model calls in between. At the same time, the clay model programmatically renders a preview clip rt from the edited spatial state; it carries layout and camera trajectory, but its appearance is clay-colored. The two channels are fed together into the frozen video model: vt+1 = Vθ(pt, rt, ft), where ft is the visual anchor, initially taken from the input image and thereafter taken from the last frame of the previous segment each round. Side effects of the reference channel

Here is an engineering detail I think is well worth copying: the instructions must explicitly tell the renderer that "the preview is only a layout reference." The paper reports thirty generated clips to illustrate this—if the instructions do not specify the reference as a layout preview, the renderer will reproduce the clay's gray material as appearance. The reference channel has side effects, and its interpretation must be spelled out. After generation, the loop closes: the VLM observer Oψ looks at the generated clip and proposes updates to semantic or spatial fields; the runtime adopts them only when the proposal is legal and compatible with the fixed rules. A visual detail that contradicts a resolved event is not recorded as "the event changed," but as a rendering inconsistency. Reproduction boundaries

The authors are also restrained on reproducibility: rule resolution and compilation are deterministic for a fixed program, input state, action, and accepted neural proposals, and the rendering seed is baseseed + t; but pixel-level reproduction also requires that the backend itself be deterministic under the same instructions, references, seed, and serving conditions—frozen weights alone do not establish this property. How compliance is judged: two instruction conditions and a twin-pairing metric

The evaluation protocol is called Change-to-Comply. Change asks whether this action produced a visible event beyond camera motion; Comply asks whether this event satisfies the rules under the given hidden state. Separating the two is meant to distinguish "nothing happened" from "something happened but violated the rules"—the latter is often more subtle. Clips with no discernible event or that cannot be interpreted are recorded as UNCLEAR and receive no points. How the metrics are layered

The metrics are layered. Clip level: ENDFOLLOW requires the specified outcome to appear in the final frame; CNTABSENT requires the forbidden outcome (that is, the specified outcome of the other example) to be absent throughout; STRICT requires both, i.e., only the single specified outcome is presented, with no contradictory content and no dual-branch montage. Pair level: PAIRFOLLOW requires both examples to be ENDFOLLOW-correct, PAIRSTRICT requires both examples to be STRICT-correct, and TWINCONTRAST records whether the outcomes judged for the two examples differ—it measures "whether this pair of samples is distinguishable to this system" and is specifically designed to diagnose copy-paste behavior. What the judge relies on to decide

The judge is Qwen3.8-27B-VL, which samples frames at 3 fps plus the final frame and answers two fixed-choice questions: which outcome appears in the final frame (specified / forbidden / uninterpretable), and whether the forbidden outcome appears anywhere in the clip (yes / no). The judge can see the specified outcome for that branch, but cannot see the hidden variables, the rule text, or the expected result of the other example. To avoid missed judgments, the authors conducted blind human verification: 17 cases, 102 clips, each clip independently scored by three people; additionally, 25 pairs of cases underwent forced-choice human battles (Figure 4).

The rule text itself is written plainly, with each family using a fixed sentence framework, for example "if the flame is red, the barrier shatters and the door opens; if the flame is blue, the barrier holds and the door remains closed." Both branches clearly state their own final state, so that the rule program can directly derive the expected outcome and can also define the forbidden item as "the specified outcome of the other example." This point is critical to the evaluation: the expected answer is fixed before generation, and the judge is not interpreting the visuals after the fact.

The experiments use four image-to-video generators and seven interactive world models, all driven through their respective standard interfaces, with no additional training or fine-tuning. There are two instruction conditions: Rule-only gives the original case instruction, hidden value, selected rule branch, and action; Rule+end additionally appends an explicit final-state requirement. The table below lists three metrics under the Rule-only probe: single-clip outcome (ENDFOLLOW), paired joint (PAIRFOLLOW), and paired strict (PAIRSTRICT).

| Backend (Rule-only probe) | Single-clip outcome↑ | Paired joint↑ | Paired strict↑ | | --- | --- | --- | --- | | Wan2.2 A14B | 65% | 32% | 14% | | LongCat-Video 13.6B | 47% | 8% | 0% | | HunyuanVideo 1.5 | 57% | 20% | 6% | | MiniMax-H3 | 66% | 32% | 0% | | LingBot-World v2 | 48% | 16% | 8% | | Echo-WM Flash | 57% | 26% | 8% | | FantasyWorld | 34% | 8% | 8% | | AlayaWorld | 37% | 12% | 10% | | InSpatio-World | 19% | 2% | 0% | | Astra | 11% | 0% | 0% | | HY-WorldPlay | 9% | 0% | 0% | | STATEFUL HARNESS (same frozen MiniMax-H3) | 96% | 92% | 90% | Where the gap falls

What is most worth watching in this table is not the last row but the gap in the middle: MiniMax-H3 has an ENDFOLLOW of 66%, but at the pair level only 32% remains. In other words, the proportion of single videos where "the outcome is right" is twice as high as "both examples are right"—the model often draws the same outcome under two different hidden states, which is precisely the quantitative form of twin collapse. The upper bound of the benefit from explicit outcomes

Writing the outcome explicitly helps, but it does not help with strict paired compliance. For MiniMax-H3, PAIRFOLLOW rises from 32% to 64%, yet PAIRSTRICT is only 4%; under Rule+end, the highest PAIRSTRICT among unwrapped backends is Wan2.2's 26%. The same frozen weights connected to the full harness yield PAIRFOLLOW 92%, PAIRSTRICT 90%, TWINCONTRAST 96%, and UNCLEAR 2%. Where the gains come from

A component-chain decomposition attributes the gains to two parts: the explicit outcome specification contributes +32 points, and execution state plus compiled reference contributes another +28 points; both are significant under the paired exact McNemar test on 50 pairs (p = 4.0×10⁻⁴ and 2.6×10⁻³, with paired bootstrap 95% intervals of [16,48] and [12,44], respectively). Looking separately at the STRICT change for each backend between the two probes (Figure 5): Wan2.2 gains 9 points, LongCat-Video gains 7, while HunyuanVideo 1.5 drops 3 points, and the average across the ten backends is only +2.3. In other words, the path of merely "writing the requirements more clearly" yields gains that are neither stable nor large enough.

One point on fairness is worth noting: each backend generates only one clip of a few seconds per turn (ranging from 77 to 128 frames, 15 to 24 fps, and 592×336 to 1280×720), while the harness side is fixed at 864×480 and 24 fps; moreover, the harness's score is not cherry-picked by repeated sampling—it first settles the action by the rules, then renders once, without using compliance judgment to select among multiple samples. This makes the meaning of the 92% figure relatively clean.

Figure 5 | Strict compliance changes for each backend after writing the required outcome into the instruction: Wan2.2 gains 9 points, HunyuanVideo 1.5 instead drops 3 points, and the average is only +2.3. Three failure modes: copy-paste, wrong direction, leakage

The authors do not stop at the total score but break failures into three identifiable categories, which is also my favorite part of this paper—it turns "not good enough" into a locatable engineering problem. Three identifiable failure categories

The first is copy-paste: a twin pair gives the same outcome. Under Rule+end, 82% of HY-WorldPlay's pairs are like this, 72% for InSpatio-World, and 70% for Astra, with their TWINCONTRAST only between 10% and 22%. The second is wrong direction: choosing the wrong rule branch—under Rule-only, Astra and HY-WorldPlay have wrong-direction rates of 89% and 91%, respectively, while their CNTABSENT is as high as 96% and 95%, showing that "not drawing what should not be drawn" does not prove "drawing what should be drawn correctly"; in many cases the state change is simply too small. The third is leakage: drawing forbidden content in addition to the specified outcome; HunyuanVideo 1.5 does so in 25% of clips under Rule-only, and under Rule+end this instead rises to 34%, the highest among all external backends—which also explains why its STRICT gets worse. The trade-off between leakage and wrong direction

The key point is the trade-off between leakage and wrong direction. For unwrapped MiniMax-H3, from Rule-only to Rule+end, wrong direction drops from 34% to 18%, while leakage rises from 40% to 53%; looking at the two numbers together explains why ENDFOLLOW rises while PAIRSTRICT remains at 4%. Under the deployed first-frame reference configuration, the harness suppresses all three at once: copy-paste 2%, wrong direction 4%, leakage 1%, with TWINCONTRAST 96% (Figure 6). The double edge of spatial reference

Incidentally, a finding I did not expect: the spatial reference channel itself is a double-edged sword. Without spatial reference, the harness has copy-paste 0%, wrong direction 6%, and leakage 5%; after adding the first-frame reference, copy-paste rises to 2%, but wrong direction and leakage drop to 4% and 1%. The authors therefore keep the first-frame reference as the deployment configuration—trading a little copy-paste risk for higher directional accuracy.

Figure 6 | Horizontal axis: whether the outcomes of the two examples are judged different; vertical axis: strict compliance rate: different outcomes do not equal compliance, and this method (starred) is highest on both. Image quality does not drop, while setting adherence instead rises from 71.1 to 87.2

Looking only at one's own benchmark easily raises the suspicion of "trading image quality for compliance." The authors therefore connect the method to the external benchmark WBench and run two configurations of frozen MiniMax-H3 using the official evaluation pipeline: the official text protocol, and the full harness with spatial preview video. The result is image quality 78.0 and physical plausibility 68.8, essentially on par with the text-driven class averages (77.4 and 66.9); setting adherence rises from 71.1 to 87.2, and interaction 77.7 is the highest value in the comparison.

| WBench Metric | Official Text Protocol | Full Harness | | --- | --- | --- | | Video Quality (mean of 6 items, full score) | 77.9 | 78.0 | | Setting Adherence (2 items) | 71.1 | 87.2 | | Camera Trajectory (navigation split) | 68.9 | 77.7 | | Consistency (8 items) | 83.8 | 77.8 | | Physical Plausibility (2 items) | 69.3 | 68.8 | | Overall (full / navigation) | 74.2 / 74.7 | 77.9 / 79.0 | The Contribution of Each Ingredient

Channel ablation makes the contribution of each ingredient visible. Adding only first-frame anchoring raises the full score from 74.2 to 76.1, jumps setting adherence from 71.1 to 89.6, and barely moves camera trajectory (68.9 to 69.0); adding the control video as well raises the camera trajectory of the navigation split from 69.0 to 77.7 and the navigation overall to 79.0, while consistency drops from 83.8 to 75.3 and then returns to 77.8. Interestingly, feeding the same control video to the original text protocol without any explanation yields only 67.1 overall, with setting adherence falling to 53.0—who gets the reference channel and how it is explained matters more than whether it is given at all. The Difficulty Spectrum by Trigger Type

Cutting again by trigger type reveals the difficulty distribution: spell-casting 20 clips all correct (100%/100%), gesture 42 clips 95.2%/90.5%, mechanism 26 clips 92.3%/84.6%, area trigger 12 clips 91.7%/83.3% (11/12 clips, 5/6 correct). The area category is the hardest—because it additionally requires the renderer to draw "the state of the area"—but it is also the family with the largest gain from first-frame reference; with text only, STRICT is just 66.7%. This also explains why the authors keep the spatial channel. Multi-Turn Uses Only Qualitative Material

The multi-turn part uses only qualitative material: under the same frozen weights there are three real episodes, run for 15, 29, and 11 turns respectively, covering three genres—town exploration, romance narrative, and turn-based duel. The values on the HUD are monotonically traceable—stamina drops from 28 to 0 and then returns to 60 by resting, affection rises from 47 by one point per turn to 75, and in the duel the arbiter's health goes from 128 down to 0. Each of the three genres is a new executable game definition, with the runtime and video model weights unchanged. The Finding I Consider Most Valuable

If I could take away only one thing, it would be this: "responsive" and "stateful" are not the same thing, and the latter can be supplied by a non-training runtime layer. Today's interactive video models are already very responsive—you give an action, and it moves. But responsiveness is not statefulness: it does not guarantee that consequences are remembered, accumulated, or constrained by rules. The paper turns this distinction into numbers using twin samples (32% versus 92%), and this is what I find most remarkable, because it grounds a philosophical-sounding statement in a measurable quantity. Where Authority Should Lie

The second takeaway is where authority lies. The most counterintuitive point in the whole design is this: authority over world evolution lies in the rule program, not in the renderer. A rendering failure does not reverse events; frames that contradict already-settled events are recorded as rendering inconsistencies rather than new facts. This clear division of "who has the final say" is precisely the missing link in many generative systems—once you hand decision-making to the generative model, you can no longer guarantee that the same action takes different branches under different hidden states. The Orientation Toward a Minimal Interface

The third is the orientation toward a minimal interface. The authors position themselves modestly when comparing with related work: they do not build an engine or fine-tune the renderer; they use only the three interfaces the frozen model already has—text, image, and video reference—to compress a new world into a small typed program. This has a very practical consequence—changing genres means writing a definition, not training a model, and that is how the three episodes came about. Applicable Boundaries and Open Problems the Authors Themselves Point Out

The first boundary is the expressive power of the rules. The rules in the paper are deterministic programs of guards plus effects, able to express resource thresholds, branch selection, state updates, and goal determination, but with no temporal conditions and no quantified conditions; in their limitations the authors explicitly list "a richer rule language, including temporal and quantified conditions" as future work. That is, rules like "trigger an event after three consecutive turns without using an item" cannot yet be written in the current form. The Precision of the Spatial Representation

The second is the precision of the spatial representation. The box-based clay model is only a rough layout, and errors in instance recovery propagate directly into the preview; text instructions also cannot always stop the renderer from reproducing the clay appearance—the authors admit this themselves and cite "thirty clips" as evidence. Articulated poses and fine appearance are still determined by the video model, and the spatial pipeline still runs offline. Better geometry requires a finer scene representation. The Boundaries of the Evaluation Itself

The third is the boundaries of the evaluation itself. The main benchmark has only 50 pairs, and although the positive compliance rate is high, each error costs 2 percentage points; the judge is a VLM, and the authors calibrate it with blinded human verification (Q1 agrees with the human majority vote 91.2% of the time, Q2 86.3%), but the human verification covers only 17 cases. In the human battles the baseline wins not a single point, and the paper also states that the remaining comparisons have auditor disagreements and that under the aggregate decision rule no case is awarded to the baseline. In addition, the harness comparison runs only one frozen backbone, MiniMax-H3; the effect of changing the backbone is not given in the paper. Quantities the Paper Does Not Give

There are also several quantities readers would care about that the paper does not give: the end-to-end latency per turn and the cost per clip (it only states that evaluation used one 8-GPU A800 80GB node and that the harness logic runs on CPU), the exact number of human auditors, the construction failure rate of the clay model, and statistical significance tests on WBench. These all require one's own stress testing or supplementary work before drawing conclusions. A Few Takeaways After Reading

First, if your world model needs "consequences" rather than "pixels," first look at where the state lives. If the state is implicit, it can be neither audited nor replayed; replace it with a document-style ledger plus an editable coarse geometry, and rule settlement and debugging immediately become feasible.

Second, putting "settlement" before "generation" is a very cheap correctness guarantee. It requires no model changes, only one extra program step before calling generation; and the benefit it brings is that failures are recoverable—if rendering crashes, the facts remain.

Third, the reference channel needs a manual. With the same control video, explicitly telling the renderer "this is a layout reference" brings setting adherence to 89.6; without saying so clearly, the reference is treated as an appearance to be reproduced, and the overall score ends up lower than giving no reference at all. This lesson holds in any system that "uses geometry or sketches to guide generation." Evaluation Criteria Must Be Paired

Fourth, evaluation must use pairs, not single clips. Single-clip accuracy systematically overestimates capability: MiniMax-H3's ENDFOLLOW is 66%, but paired it is only 32%. As long as what you care about is "should the same input have different consequences," pairing is the quantity that can state it clearly.

Conclusion: This paper does not propose a stronger, prettier video generator. It proposes something more modest—taking "how the world evolves" out of the pixels, handing it to a readable, testable, replayable set of rules, and then letting the frozen model focus on drawing the settled facts well. For those working on interactive generation, this division of labor is more worth learning from than another image-quality metric.

Paper information and figure notes: This article interprets the arXiv preprint "State World Models: Execute the Rules, Generate the Pixels" (arXiv:2610.26811v1, announced October 19, 2026, 36 pages), by Chan Yan Ki, Yanran Zhang, Wenzhao Zheng, Xiaofeng Wang, Zheng Zhu, Lei Chen, Jie Zhou, and Jiwen Lu (the first two contributed equally), from the Department of Automation at Tsinghua University and GigaAI; the original is at https://arxiv.org/abs/2610.26811v1. The paper is released under the CC BY 4.0 license, and attribution and the license notice must be retained when reposting. The six figures in this article are taken from Figures 1, 2, 3, 4, 11, and 12 of the original; I rendered the full pages, composited them onto a white background using the alpha channel, tightly cropped them to the measured ink bounding box within the bitmap, and cropped out the original English captions; the captions, table reformatting, and interpretive text are all original. Terminology quick reference Counterfactual twins: two cases share the first frame, action script, and rule program, and differ in only one hidden value, which requires two different visible outcomes; a correct single-case outcome does not show that the model is sensitive to the hidden state (Sec. 4). Twin collapse: a pair of twins gives the same outcome under two different hidden states, in which case at least one case necessarily violates the rules (Fig. 2). Semantic ledger zt: a serializable typed record that stores resources, entity attributes, progress, attitudes, and final states; it is the half of the world state that is readable, writable, verifiable, and replayable by the rules (Sec. 3). Clay model: per-instance oriented boxes plus ground and camera obtained from a single feed-forward geometric inference, instantiated as an untextured Blender scene that provides only layout and camera (Sec. 3.1). VisualScript: a record format that writes settled events as a typed visual script, with slots for style, first-frame anchor, camera, actors, actions, goals and reactions, stability, final state, and so on (Table 11). Change-to-Comply: an evaluation protocol: Change judges whether a visible event exceeding camera motion occurs, and Comply judges whether the event satisfies the rules of that hidden state; PAIRSTRICT requires both cases to comply and the forbidden outcome never to appear throughout (Appendix B.1). Engineering implementation checklist First confirm where the state exists. Implicit state is neither auditable nor replayable; only by switching to a document-style ledger plus an editable coarse geometry do settlement and debugging become feasible. Put rule settlement before generation. A rendering failure affects only the picture and does not reverse the facts; the failure policy can be retry, reuse the previous round's anchor, or terminate (Appendix F.1). Write a manual for the reference channel. When labeled as a layout reference, setting adherence reaches 89.6; feeding it to the raw text protocol without explanation gives only 67.1 overall and drops setting adherence to 53.0 (Table 8). Evaluate with paired metrics. MiniMax-H3 has 66% on single-case ENDFOLLOW, but only 32% when paired; reporting only single cases systematically overestimates capability (Table 1). Change the world, change the definition, not the weights. Under the same runtime and weights, the three-episode segments of 15, 29, and 11 turns correspond to three definitions (Sec. 5.3). Frequently asked questions (FAQ) Q1: Is this just building another game engine? Answer: No. The paper does not write an engine; it uses the minimal combination of "a persistent editable scene + a semantic ledger + the reference inputs that come with a frozen renderer"; a new world is compressed into a small typed program, with no engine written and no video model fine-tuned (Sec. 2). Q2: If the required outcome is written clearly, why is strict compliance actually worse? Answer: Because direction errors and leakage can move in opposite directions. For unwrapped MiniMax-H3, going from Rule-only to Rule+end lowers direction errors from 34% to 18%, but leakage rises from 40% to 53%, so PAIRFOLLOW reaches 64% while PAIRSTRICT remains at 4% (Appendix D). Q3: Does it still work with a different video backbone? Answer: The full harness has been compared only using the frozen MiniMax-H3; the paper does not give results for changing the backbone. At the method level it relies only on the backend's three interfaces for text, image, and video reference, and the authors list "bringing it to more video backbones" as future work (Appendix I).