Introduction

A Tsinghua team just open-sourced a way to make video world models follow game rules. On October 19, researchers from Tsinghua University and GigaAI released the code for State World Models, a framework the paper calls Stateful Harness. It's a turn-based game runtime that keeps an explicit world state, settles each action with real rules before any video is generated, and then asks a frozen video model, MiniMax-H3, to render only the outcome that was already decided. The code is Apache-2.0 on GitHub, the benchmark is on Hugging Face, and you can play the games on a CPU today with a placeholder renderer.

The problem it goes after is one anyone who has played with an AI world model will know. The video looks plausible, but the world forgets things. If a door was locked two turns ago, or the boss has 3 HP left, a pixel-only model has no reliable place to keep that fact. Stateful Harness keeps it in a ledger the model can't overwrite.

What shipped

  • Name and team: State World Models / Stateful Harness, from Tsinghua University and GigaAI (project lead Wenzhao Zheng)
  • Modality: interactive game video. Each turn renders about 5 seconds of video from the current frame
  • Open vs closed: open code under Apache-2.0. It uses the open MiniMax-H3 weights (MiniMax H3 Community License) for rendering and Qwen3.8-27B for dialogue and the open-world director
  • Where to run it today: clone the GitHub repo. Game logic, the browser UI and all tests run on CPU with a fake renderer. Real rendering needs 4 or 8 GPUs with 80 GB each
  • Games included: 20 games ship as JSON skins: 9 duels, 10 story games in English and Chinese, and an open-world mode with six scenes (western, anime, chinese, japan, roman and gta)
  • Benchmark: WorldState-Bench, 50 counterfactual twin pairs, released on Hugging Face and ModelScope

How it works

The loop is simple, and that's the point. The video model never decides what happens. It only draws it.

  1. You act: you click a skill in a duel, type dialogue in a story game, or pick an action in the open world
  2. The engine settles the turn: a deterministic rules engine updates HP, relationship, stamina or quest state from the current state plus a seed. Win, lose and branch choices are all fixed here
  3. The outcome becomes an instruction: the settled event is compiled into a structured prompt for the video model
  4. MiniMax-H3 renders it: the frozen model renders about 5 seconds of video starting from the current frame
  5. The last frame carries forward: it becomes the first frame of the next turn. At the end, one click stitches every clip into a captioned replay film

The repo spells out the engine rules, and game devs will recognize them: turns resolve deterministically, game code contains no prompt strings, and a failed render never rolls back state. If the video model has a bad turn, the game state is still correct.

The numbers

WorldState-Bench gives two "twin" cases the same first frame and the same action, but changes one hidden value. One example is "raise the wand," where the hidden element decides whether red or blue flames should appear. A pair only passes if both clips show their own correct ending.

  • Same model, very different result: with identical frozen MiniMax-H3 weights, PairFollow goes from 32% when you just describe the rule in the prompt to 92% through Stateful Harness. PairStrict, which also checks that the wrong ending never shows up, goes from 4% to 90%
  • Against interactive world models: on the stricter probe, the authors report PairStrict of 14% for LingBot-World v2, 8% for Echo-WM Flash and FantasyWorld, and 0% for HY-WorldPlay
  • Human preference: the team reports Stateful Harness was preferred in 98% of blind pairwise comparisons against four baselines, and scored 77.7 on WBench interaction, the highest among the models it reported
  • Speed: a turn takes about 16 to 40 seconds at 480p in the default setup (Qwen on one GPU, H3 on four). A standalone 5-second 480p H3 clip takes about 5.7 seconds on 8×A800

These are the authors' own numbers, judged by Qwen3.8-27B with fixed-choice questions, so treat them as a strong first result rather than an independent score.

Try it

The CPU check needs no GPU and no model weights. It runs the real rules and swaps only the pixels:

git clone https://github.com/Zhangyr2022/StateWorldModel.git && cd StateWorldModel
pip install -r agentic_game/requirements.txt -r worldstate_bench/requirements.txt
cd agentic_game
python download_assets.py
python3 run_demo.py --game duel_oracle_machine_epic --renderer fake --agent auto --turns 3
python3 run_ui.py --renderer fake          # browser lobby at http://127.0.0.1:7860

For real rendering, you'll need the MiniMax-H3 checkpoint (about 210 GB, plus the FastH3 4-step LoRA that the download script pulls by default) and a Qwen3.8-27B checkpoint. Then start the services and run with --renderer h3 --mode remote.

Why it matters for game builders

  • New worlds without code: a new game is one JSON skin in agentic_game/game/skins/. It declares states, transitions, numeric rules and visual prompts, and it's checked when the registry loads
  • New mechanics in five files: if a skin isn't enough, you implement a small GameRuntime protocol under agentic_game/game/<your_game>/
  • Reproducible runs: the same state, actions and seed give the same trajectory, and every run writes a turn_log.jsonl with each turn's settlement and render request
  • Bring your own renderer: the benchmark already includes wrappers for Wan2.2, LongCat-Video and HunyuanVideo-1.5, so you can test how well other video models follow rules

Original Source

https://github.com/Zhangyr2022/StateWorldModel

https://ivg-yanranzhang.github.io/StateWorldModel/

https://arxiv.org/abs/2610.26811

https://huggingface.co/datasets/Louis0411/StateWorldModel

Conclusion

Stateful Harness doesn't try to make the video model smarter. It takes game logic out of the model and puts it back in the engine, where it belongs. The video model just becomes a renderer. For anyone building AI-native games, that's the useful split: your rules stay exact and testable, and the generative model only handles the look. The full rendering stack is still heavy, but the CPU mode lets you design and play-test skins today, then add real pixels when you have the GPUs.

Want to see the renderer on its own first? Try MiniMax H3 on Gen.

—Titus