Pith. sign in

REVIEW 3 major objections 4 minor 50 references

MASS: Multiplayer World Models with Authoritative Shared State

T0 review · 3 major / 4 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read MASS proposes a learned world model that simulates a multiplayer game by advancing one authoritative typed state per tick and rendering every requested camera from that same state, so the cost of simulating the world no longer grows with…

desk verdict A genuinely new typed-state formulation with clean direct logic results, but the 1,024-player/10,000-tick headline is unsupported by any experiment in the appendix and the SOTA comparison is not compute-matched. read the letter →

arxiv 2608.06257 v2 pith:OULMKPTE submitted 2026-08-06 cs.CV cs.HC

Ziqi Cai , Siqi Yang , Yimu Wang , Zixian Gao , Yunheng Liu , Shuchen Weng , Erwin Wu , Kaipeng Zhang
show 1 more author
Boxin Shi
This is my paper · ORCID
classification cs.CVcs.HC
keywords worldmodelsmultiplayersimulationauthoritativestatetypedlearneddynamicsviewrenderingrecurrentmemoryschema-basedmodeling
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that multiplayer world models do not need to carry the world in per-view video latents. Its central proposal is to separate world dynamics from view rendering: a learned Logic Engine advances a global, schema-declared typed state from joint actions, and a learned Rendering Engine decodes any requested camera from that state. The typed state is the only recurrent memory and the synchronization reference, so all views are consistent by construction. On a matched Snake benchmark the paper reports 0.764 state recovery versus 0.128 for the strongest video-based baseline, and it reports rolling out 1,024 simulated players for 10,000 recurrent ticks. If true, this gives a practical route to scalable and consistent multi-agent world simulation at population scale.

What carries the argument

The central object is the authoritative typed state: a schema-declared sequence of entity records whose fields carry named values such as positions, headings, life status, and items. The Logic Engine predicts the next state record-by-record; the transition writes $\hat{s}_{t+1} = F_\theta(\hat{s}_t, a_t, e_t)$ and factorizes as $p_\theta(s_{t+1} \mid s_t, a_t, e_t) \approx \prod_i \prod_j p_\theta(y^{i,j}_{t+1} \mid u^i_t, y^{i,<j}_{t+1})$, so self-attention stays inside each record's own token sequence and the cost scales with the number of records rather than the number of cameras. The Rendering Engine then maps each camera's projection of the typed state to an RGB frame, so every view is a read from one shared state. This factorization is what supports the paper's 1,024-entity rollouts and its construction-level guarantee that simultaneous views cannot disagree.

What would settle it

Train MASS on a game whose rules include a map-wide interaction that crosses the radius-limited context window (for example, a teleport or line-of-sight effect), then compare the predicted state with the engine state at the tick where that interaction occurs; the central claim would be refuted if state recovery collapses at that event while a model with global attention retains it.

Watch

Extended reading notes

Core claim

The paper's core claim is that the authoritative-server contract of online games can be brought to learned world models. Instead of predicting pixels or visual latents, the model predicts a complete typed world state—a collection of entity records whose kinds, fields, and value domains are fixed by a declarative schema. A learned transition advances that state once per tick from the joint player actions and declared exogenous inputs, with no hand-written game rules; then a learned renderer synthesizes each client view from the same predicted state and a camera. The paper argues this makes cross-view inconsistency impossible by construction, lets world-state accuracy be measured directly before any frame is generated, and decouples simulation cost from the number of rendered views.

Load-bearing premise

The load-bearing premise is that a game's full dynamics are expressible through the schema's typed records and each record's local context window, and that ground-truth engine states are available for training.

Editorial extensions

If this is right

  • A single world transition per tick serves any number of cameras, so the simulation workload is independent of the spectator count.
  • Simultaneous views cannot drift apart: every frame is decoded from the same predicted typed state, giving a measured cross-view disagreement of 0.000 on the matched benchmark.
  • World-state accuracy can be evaluated directly on the typed records before rendering, so errors can be attributed to the learned dynamics or to the renderer.
  • When server updates are delayed, a client can continue advancing its last authoritative state with the same Logic Engine; the local player's position stays exact through the tested eight-tick stalls.
  • New games enter through a declarative schema with game-specific weights, so the same architecture runs across the eight tested games and long rollouts without hand-written transitions.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Because the transition factorizes per record with no cross-record attention, the computational ceiling is set by record count; distributing record batches across devices could plausibly extend the 1,024-entity regime far beyond what this paper measures.
  • The renderer is decoupled from the dynamics, so art style, resolution, or camera type could potentially be changed at deployment time without retraining the world transition; a direct test would swap in a renderer trained on a different visual style and verify that state recovery is unchanged.
  • The method is trained on ground-truth engine states, so its practical ceiling lies in environments where such states are obtainable; in settings without simulators, parser-derived pseudo-states or captured engine logs would be needed to apply the same scheme.
  • The record-local context window is the method's expressiveness boundary; adding sparse cross-record attention for long-range interactions would be a natural extension, with the testable prediction that it improves state accuracy on games with map-wide effects without sacrificing the per-record batching benefit.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper proposes MASS, a learned multiplayer world model that separates a shared, schema-constrained typed state from per-view rendering. A Logic Engine advances the typed state from joint actions without hand-written transition rules, and a Rendering Engine synthesizes arbitrary camera views from that same state. The authors evaluate MASS on a matched multi-agent Snake benchmark against video- and latent-based baselines, report state recovery and cross-view agreement advantages, test cross-game generalization through declarative schemas, study client-side prediction during update stalls, and claim scalability to 1,024 players over 10,000 recurrent ticks.

Significance. If the central claims hold, MASS offers a principled way to decouple simulation cost from the number of rendered views and provides a directly inspectable, versionable recurrent state for multi-agent world models. The paper's strengths include a carefully controlled matched benchmark, direct logic-only diagnostics that separate transition accuracy from rendering quality, a schema-driven software architecture that is demonstrated across several games, and a detailed appendix with reproducible protocols. The cross-view consistency result, however, is partly a definitional tautology, and the headline 1,024-player, 10,000-tick scalability claim is not backed by any reported experiment. The core methodology and small-scale empirical comparisons are solid, but the advertised large-scale result needs either supporting evidence or a substantial revision of the claim.

major comments (3)
  1. [Abstract and Section 4.5; Appendix C.3, C.4] The claim that MASS 'advances worlds with 1,024 simulated player entities for 10,000 recurrent ticks' is not supported by any experiment in the appendix. The long-horizon stability study (Table C.2) evaluates only N=2, 4, 8 at horizons up to H=4096, and the N=1024 study in Appendix C.4 uses a single fixed predicted state for a renderer cost sweep and client-side prediction windows of k<=8 ticks. There is no autoregressive rollout with N=1024 and H=10000, so the central scalability number in the abstract is unverifiable and appears to be an extrapolation. The authors should either run and report the 1,024-player, 10,000-tick experiment (with structural validity, roster survival, state diversity, and throughput) or remove this specific quantitative claim from the abstract and main text.
  2. [Section 4.5, Eq. (8)] The reported X-view disagreement of 0.000 is true by construction: Eq. (8) defines every rendered view as a conditional draw from the same predicted state, and the Rendering Engine is deterministic given the state and camera. Presenting this as a 'measured' finding in Table 2 and contrasting it with baselines is circular, because any renderer that deterministically maps the shared state to views would also yield zero cross-view disagreement by definition. The result is useful only as a sanity check that the renderer does not introduce visible inconsistencies; it should be framed as a constructed property rather than a comparative empirical advantage.
  3. [Section 3.2, Eq. (5)] The factorization in Eq. (5) restricts the Logic Engine to per-record prediction with interactions entering only through the local context window c_i^t. This is a genuine representational limitation: long-range effects, emergent entities, or interactions outside the radius-limited context cannot be modeled, and the paper does not discuss this limitation or characterize its impact on the evaluated games. The authors should either state this assumption explicitly as a scope condition or provide evidence about how far the local-context factorization generalizes.
minor comments (4)
  1. [Table 2] The text says MASS leads six of seven metrics, but the Invalid column shows MASS at 0.177, worse than B-PV and B-SL at 0.052. Since Invalid is defined as the fraction of parsed ticks that violate structural consistency, this discrepancy deserves a sentence of explanation; otherwise it undermines the claim of structural validity by construction.
  2. [Section 3.4, Eq. (9)] Equation (9) labels T_server as the 'server workload' but the formula omits the Rendering Engine cost. The surrounding text clarifies that rendering runs locally, but the equation would be clearer if T_server were explicitly defined as the server-side workload excluding client-side rendering.
  3. [Abstract] The abstract does not mention that training requires access to ground-truth engine states and recorded exogenous inputs. This is a standard supervised setup, but it is a material assumption for practitioners and should be stated alongside the claim that no hand-written transition function is used.
  4. [Section 4.5] The sentence 'The same transition architecture also advances worlds with 1,024 simulated player entities for 10,000 recurrent ticks' is repeated in the abstract and main text but is not supported by the appendix; please see the first major comment.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the core claims are evaluated against externally recorded engine states, and the only by-construction element (cross-view agreement) is explicitly labeled as such rather than being presented as a fitted prediction.

full rationale

The paper's central derivation is a learned Logic Engine advancing a typed state from joint actions, followed by a learned Rendering Engine converting that state into views. The state prediction is trained and evaluated against recorded engine states (Appendix B.3, Table B.2), which is an external reference, not a renaming of the model's own output. The parser recovery metric uses a frozen parser validated on ground-truth frames (≥0.99 recovery) and the renderer is trained with a reconstruction loss, not to maximize parser agreement; thus the reported 0.764 parser recovery is a genuine end-to-end measurement rather than a fitted quantity. The one place where a result is 'by construction' is cross-view consistency: Equation (8) makes every view a function of the same predicted state, and Section 4.5 explicitly states 'State-level consistency is guaranteed by construction because every rendered view decodes from the same predicted typed state.' The subsequently reported measured X-view disagreement of 0.000 is therefore a sanity check on the renderer and parser, not an independent discovery, and the paper does not conceal this. No load-bearing self-citations are present; the SRSC protocol cites external judges (TIFA, MT-bench). The abstract's claim of advancing 1,024 players for 10,000 recurrent steps is not backed by a corresponding appendix experiment (Appendix C.3 caps at N=8 and H=4096; Appendix C.4 uses N=1024 only for a renderer sweep at a fixed tick), but this is a missing-evidence or verifiability concern, not a circular-derivation concern, and therefore does not affect the circularity score.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

No new physical or mathematical entities are introduced. The typed state, Logic Engine, and Rendering Engine are architectural components, not postulated entities with independent falsifiable handles.

free parameters (4)
  • spatial_context_radius = 4 cells (9x9 grid)
    Hand-chosen in the schema and used to build each record's context window; determines which interactions the Logic Engine can see.
  • food_bucket_size = 8x8 cells
    Hand-chosen spatial bucketing for food entities in the 1,024-player Snake schema; affects tokenization and locality.
  • max_body_length = 40 segments
    Hand-chosen padding bound in the matched Snake codec; a snake longer than this could not be serialized.
  • viewport_cells = 31
    Camera viewport width used in the matched Snake benchmark; defines the rendered observations and the parser's grid.
assumptions (4)
  • domain assumption The game state is fully representable by a hand-authored schema of typed records with fixed counts and fields.
    Section 3.1 defines the schema Sigma_g and states that every valid state maps to a fixed-width sequence. If the true world has entities or fields not declared in the schema, MASS cannot represent them.
  • domain assumption Interactions between entities are local and captured by the schema-defined context window c_i^t.
    Equation (5) factorizes predictions per record, and Section 3.2 says self-attention stays confined to each record's sequence while interactions enter through the neighborhood window. Long-range effects beyond the window cannot be learned.
  • domain assumption Ground-truth typed states are available for training and evaluation.
    The Logic Engine is trained with teacher forcing on recorded states (Section 4.2 and Equation 12), and the renderer is trained on ground-truth states (Appendix B.1). This is not stated as a limitation in the abstract.
  • domain assumption The frozen parser is a valid state-recovery instrument.
    Appendix B.1 enables semantic evaluation only when parser recovery on ground-truth frames is at least 0.99; the parser is assumed to transfer to model outputs.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MASS: Multiplayer World Models with Authoritative Shared State." pith.science (2026). https://pith.science/paper/OULMKPTE

@misc{pith2026260806257,
  author       = {Pith},
  title        = {Pith review of: MASS: Multiplayer World Models with Authoritative Shared State},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OULMKPTE}},
  note         = {Machine review of arXiv:2608.06257}
}
read the original abstract

Current video world models struggle in multiplayer environments because they entangle world state with view-dependent visual latents, leading to redundant compute, view inconsistencies, and poor scalability. We propose MASS (Multiplayer world models with Authoritative Shared State) to resolve this limitation. Inspired by multiplayer game architectures, MASS disentangles world dynamics and view rendering. A learned Logic Engine advances a global, authoritative typed state from joint actions without any hand-written transition function, acting as the sole recurrent memory and synchronization reference. From this shared state, a learned Rendering Engine generates independent and consistent views for any requested camera on demand. This explicit disentangling allows MASS to achieve superior state accuracy and lower cross-view inconsistency compared to state-of-the-art multi-view baselines on a matched multiplayer Snake benchmark. It advances predicted worlds with 1,024 concurrent players for 10,000 recurrent steps. Our results show that explicit, authoritative state modeling provides a practical foundation for scalable and consistent multi-agent world simulation.

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

50 extracted references · 11 canonical work pages

  1. [1]

    Diffusion for world modeling: Visual details matter in Atari.Advances in Neural Information Processing Systems, 2024

    Eloi Alonso, Adam Jelley, Vincent Micheli, Anssi Kanervisto, Amos Storkey, Tim Pearce, and François Fleuret. Diffusion for world modeling: Visual details matter in Atari.Advances in Neural Information Processing Systems, 2024

    2024

  2. [2]

    Chris Bamford and Simon M. Lucas. Neural game engine: Accurate learning of generalizable forward models from pixels. InIEEE Conference on Games, 2020

    2020

  3. [3]

    Yahn W. Bernier. Latency compensating methods in client/server in-game protocol design and optimization. Game Developers Conference, 2001

    2001

  4. [4]

    Genie: Generative interactive environ- ments.International Conference on Machine Learning, 2024

    Jake Bruce, Michael Dennis, Ashley Edwards, Jack Parker-Holder, Yuge Shi, Edward Hughes, Matthew Lai, Aditi Mavalankar, Richie Steigerwald, Chris Apps, et al. Genie: Generative interactive environ- ments.International Conference on Machine Learning, 2024

    2024

  5. [5]

    Recurrent environment simulators

    Silvia Chiappa, Sébastien Racanière, Daan Wierstra, and Shakir Mohamed. Recurrent environment simulators. InInternational Conference on Learning Representations, 2017

    2017

  6. [6]

    Latency and player actions in online games.Communications of the ACM, 49(11):40–45, 2006

    Mark Claypool and Kajal Claypool. Latency and player actions in online games.Communications of the ACM, 49(11):40–45, 2006

    2006

  7. [7]

    Oasis: A universe in a transformer

    Decart, Julian Quevedo, Quinn McIntyre, Spruce Campbell, Xinlei Chen, and Robert Wachen. Oasis: A universe in a transformer. Project page, 2024. Project credit: Decart and Etched

    2024

  8. [8]

    World models.arXiv preprint arXiv:1803.10122, 2018

    David Ha and Jürgen Schmidhuber. World models.arXiv preprint arXiv:1803.10122, 2018

    arXiv 2018

Show all 50 references
  1. [9]

    Learning latent dynamics for planning from pixels

    Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. InInternational Conference on Machine Learning, 2019

    2019

  2. [10]

    Dream to control: Learning behaviors by latent imagination

    Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. InInternational Conference on Learning Representations, 2020

    2020

  3. [11]

    Mastering diverse domains through world models.arXiv preprint arXiv:2301.04104, 2023

    Danijar Hafner, Jurgis Pasukonis, Jimmy Ba, and Timothy Lillicrap. Mastering diverse domains through world models.arXiv preprint arXiv:2301.04104, 2023

    2023 arXiv

  4. [12]

    Multiplayer interactive world models with representation autoencoders.arXiv preprint arXiv:2607.05352, 2026

    Anthony Hu, Václav Volhejn, Adrien Ramanana Rahary, Chris Mulder, Aditya Makkar, Alyx Liao, Amélie Royer, Manu Orsini, Adam Jelley, Eloi Alonso, Florian Laurent, Fredrik Norén, James Swingos, Jan Hünermann, Kent Rollins, Lucas Hosseini, Matthieu Le Cauchois, Maxim Peter, Pim d...

    2026 doi arXiv

  5. [13]

    WanToFight: Real-time generative game engine for multi-player combat interaction.arXiv preprint arXiv:2607.12592, 2026

    Li Hu, Guangyuan Wang, Peng Zhang, and Bang Zhang. WanToFight: Real-time generative game engine for multi-player combat interaction.arXiv preprint arXiv:2607.12592, 2026

    2026 arXiv

  6. [14]

    MetaWorld: Scaling multi-agent video world model from single-view video data

    Teng Hu, Mingchun Lu, Yating Wang, Jiangning Zhang, Jinkun Hao, Ye Pan, Ran Yi, Lizhuang Ma, and Dacheng Tao. MetaWorld: Scaling multi-agent video world model from single-view video data. arXiv preprint arXiv:2606.02753, 2026. doi: 10.48550/arXiv.2606.02753

    2026 doi arXiv

  7. [15]

    Yushi Hu, Benlin Liu, Jungo Kasai, Yizhong Wang, Mari Ostendorf, Ranjay Krishna, and Noah A. Smith. TIFA: Accurate and interpretable text-to-image faithfulness evaluation with question answering. InIEEE/CVF International Conference on Computer Vision, 2023

    2023

  8. [16]

    White, Sam Devlin, Cecily Morrison, and Katja Hofmann

    Anssi Kanervisto, Dave Bignell, Linda Yilin Wen, Martin Grayson, Raluca Georgescu, Sergio Valcar- cel Macua, Shan Zheng Tan, Tabish Rashid, Tim Pearce, Yuhan Cao, Abdelhak Lemkhenter, Chentian Jiang, Gavin Costello, Gunshi Gupta, Marko Tot, Shu Ishida, Tarun Gupta, Udit Arora,...

    2025 doi

  9. [17]

    Learning to simulate dynamic environments with GameGAN

    Seung Wook Kim, Yuhao Zhou, Jonah Philion, Antonio Torralba, and Sanja Fidler. Learning to simulate dynamic environments with GameGAN. InIEEE/CVF Conference on Computer Vision and Pattern Recognition, 2020

    2020

  10. [18]

    Gamma-World: Generative multi-agent world modeling beyond two players.arXiv preprint arXiv:2605.28816, 2026

    Fangfu Liu, Kai He, Tianchang Shen, Tianshi Cao, Sanja Fidler, Yueqi Duan, Jun Gao, Igor Gilitschenski, Zian Wang, and Xuanchi Ren. Gamma-World: Generative multi-agent world modeling beyond two players.arXiv preprint arXiv:2605.28816, 2026. doi: 10.48550/arXiv.2605.28816

    2026 doi arXiv

  11. [19]

    Current world models lack a persistent state core.arXiv preprint arXiv:2606.20545, 2026

    Jinpeng Lu, Dexu Zhu, Haoyuan Shi, Linghan Cai, Guo Tang, Yinda Chen, Jie Cao, Duyu Tang, Yi Zhang, Yong Dai, and Xiaozhu Ju. Current world models lack a persistent state core.arXiv preprint arXiv:2606.20545, 2026. doi: 10.48550/arXiv.2606.20545

    2026 doi arXiv

  12. [20]

    Playable video generation

    Willi Menapace, Stéphane Lathuilière, Sergey Tulyakov, Aliaksandr Siarohin, and Elisa Ricci. Playable video generation. InIEEE/CVF Conference on Computer Vision and Pattern Recognition, 2021

    2021

  13. [21]

    Transformers are sample-efficient world models

    Vincent Micheli, Eloi Alonso, and François Fleuret. Transformers are sample-efficient world models. In International Conference on Learning Representations, 2023

    2023

  14. [22]

    Streaming multi-agent autoregressive diffusion model with world state registers.arXiv preprint arXiv:2607.21594, 2026

    Sicheng Mo, Yuheng Li, Ziyang Leng, Krishna Kumar Singh, and Bolei Zhou. Streaming multi-agent autoregressive diffusion model with world state registers.arXiv preprint arXiv:2607.21594, 2026. doi: 10.48550/arXiv.2607.21594

    2026 doi arXiv

  15. [23]

    Growing neural cellular automata.Distill, 2020

    Alexander Mordvintsev, Ettore Randazzo, Eyvind Niklasson, and Michael Levin. Growing neural cellular automata.Distill, 2020

    2020

  16. [24]

    Introducing agora-1: The multi-agent world model

    Odyssey. Introducing agora-1: The multi-agent world model. Technical report, 2026

    2026

  17. [25]

    Lewis, and Satinder Singh

    Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L. Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in Atari games. InAdvances in Neural Information Processing Systems, 2015

    2015

  18. [26]

    MultiGen: Level-design for editable multiplayer worlds in diffusion game engines.arXiv preprint arXiv:2603.06679, 2026

    Ryan Po, David Junhao Zhang, Amir Hertz, Gordon Wetzstein, Neal Wadhwa, and Nataniel Ruiz. MultiGen: Level-design for editable multiplayer worlds in diffusion game engines.arXiv preprint arXiv:2603.06679, 2026. doi: 10.48550/arXiv.2603.06679

    2026 doi

  19. [27]

    Khora: A scalable multi-agent world model

    RhOS.ai and Ophilus AI. Khora: A scalable multi-agent world model. Technical preview, https: //www.rhos.ai/research/khora, 2026

    2026

  20. [28]

    Transformer-based world models are happy with 100k interactions

    Jan Robine, Marc Höftmann, Tobias Uelwer, and Stefan Harmeling. Transformer-based world models are happy with 100k interactions. InInternational Conference on Learning Representations, 2023

    2023

  21. [29]

    Battaglia

    Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter W. Battaglia. Learning to simulate complex physics with graph networks. InInternational Conference on Machine Learning, 2020

    2020

  22. [30]

    Solaris: Building a multiplayer video world model in Minecraft.arXiv preprint arXiv:2602.22208, 2026

    Georgy Savva, Oscar Michel, Daohan Lu, Suppakit Waiwitlikhit, Timothy Meehan, Dhairya Mishra, Srivats Poddar, Jack Lu, and Saining Xie. Solaris: Building a multiplayer video world model in Minecraft.arXiv preprint arXiv:2602.22208, 2026. doi: 10.48550/arXiv.2602.22208

    2026 doi

  23. [31]

    Mastering Atari, Go, chess and shogi by planning with a learned model.Nature, 588:604–609, 2020

    Julian Schrittwieser, Ioannis Antonoglou, Thomas Hubert, Karen Simonyan, Laurent Sifre, Simon Schmitt, Arthur Guez, Edward Lockhart, Demis Hassabis, Thore Graepel, Timothy Lillicrap, and David Silver. Mastering Atari, Go, chess and shogi by planning with a learned model.Nature...

    2020

  24. [32]

    Convolutional LSTM network: A machine learning approach for precipitation nowcasting

    Xingjian Shi, Zhourong Chen, Hao Wang, Dit-Yan Yeung, Wai-Kin Wong, and Wang-chun Woo. Convolutional LSTM network: A machine learning approach for precipitation nowcasting. InAdvances in Neural Information Processing Systems, 2015

    2015

  25. [33]

    Prisma-World: Camera-controllable multi-agent video world model.arXiv preprint arXiv:2606.09507, 2026

    Huiqiang Sun, Zhan Peng, Size Wu, Kun Wang, Kang Liao, Dianyi Wang, Xingyu Zeng, Sheng Jin, Yangguang Li, Zhiguo Cao, Ziwei Liu, and Wei Li. Prisma-World: Camera-controllable multi-agent video world model.arXiv preprint arXiv:2606.09507, 2026. doi: 10.48550/arXiv.2606.09507. 11

    2026 doi arXiv

  26. [34]

    Diffusion models are real-time game engines.arXiv preprint arXiv:2408.14837, 2024

    Dani Valevski, Yaniv Leviathan, Moab Arar, and Shlomi Fruchter. Diffusion models are real-time game engines.arXiv preprint arXiv:2408.14837, 2024

    2024 arXiv

  27. [35]

    MultiWorld: Scalable multi-agent multi-view video world models.arXiv preprint arXiv:2604.18564, 2026

    Haoyu Wu, Jiwen Yu, Yingtian Zou, and Xihui Liu. MultiWorld: Scalable multi-agent multi-view video world models.arXiv preprint arXiv:2604.18564, 2026. doi: 10.48550/arXiv.2604.18564

    2026 doi arXiv

  28. [36]

    Learning interactive real-world simulators

    Sherry Yang, Yilun Du, Seyed Kamyar Seyed Ghasemipour, Jonathan Tompson, Leslie Kaelbling, Dale Schuurmans, and Pieter Abbeel. Learning interactive real-world simulators. InInternational Conference on Learning Representations, 2024

    2024

  29. [37]

    Efros, Eli Shechtman, and Oliver Wang

    Richard Zhang, Phillip Isola, Alexei A. Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. InIEEE/CVF Conference on Computer Vision and Pattern Recognition, 2018

    2018

  30. [38]

    Xing, Hao Zhang, Joseph E

    Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric P . Xing, Hao Zhang, Joseph E. Gonzalez, and Ion Stoica. Judging LLM-as-a-judge with MT-bench and chatbot arena. InAdvances in Neural Information Process...

    2023

  31. [39]

    ShareVerse: Multi-agent consistent video generation for shared world modeling.arXiv preprint arXiv:2603.02697, 2026

    Jiayi Zhu, Jianing Zhang, Yiying Yang, Wei Cheng, and Xiaoyun Yuan. ShareVerse: Multi-agent consistent video generation for shared world modeling.arXiv preprint arXiv:2603.02697, 2026. doi: 10.48550/arXiv.2603.02697. 12 Appendix A MASS in detail A.1 A real game schema All game...

    2026 doi arXiv

  32. [40]

    # STATE marker 14 # --- state segment (421 tokens) --- [5, 5, 13, 19] # tick = 142, as 4 hex nibbles (base 5..20) [CELL, CELL, ..., CELL] # 64 sorted food cell coordinates

  33. [41]

    # player_count = 2 # Player slot 0: body length 3, heading east, alive [BODY_LEN] # body_length = 3 [CELL, CELL, CELL] # body cells (23,45), (22,45), (21,45) [PAD] x37 # padding to MAX_BODY_LENGTH = 40 [HEADING] # heading = east [ALIVE] # alive = true [PAD] # dead_at = None (p...

  34. [42]

    # ACTION marker [4, 2, 0, 0, 0, 0, 0, 0] # player 0 = right, player 1 = up, rest no-op # --- exogenous inputs (13 tokens) ---

  35. [43]

    # EXOGENOUS marker [5, 5, 13, 19] # tick = 142

  36. [44]

    # spawn_count = 2 [CELL, CELL] # spawn at (10,22) and (43,7) [PAD] x6 # padding to MAX_FOOD_SPAWNS = 8

  37. [45]

    # OUTPUT marker (the model decodes the next state here) The decoder receives the entire prefix and predicts the next state tokens autoregressively after the OUTPUT marker. The schema-derived mask ensures that each field decodes to its declared type, for example the tick positi...

  38. [47]

    For each image separately, inventory every visible entity by class (snake head, body, food, wall, empty, ...), identity (player index), team, and owner

  39. [48]

    Assign each entity to a coarse spatial sector (left/center/right, top/middle/bottom) and note relative 27 spatial relations

  40. [49]

    Establish correspondence between the two inventories

  41. [50]

    consistent

    Check object states (alive/dead, moving/stationary), interactions (collision, collection), and list any hallucinated or missing entities. Ignore differences in artistic style, texture, lighting, and image sharpness. Focus only on semantic content: what entities exist, where th...

  42. [128]

    Appearance alone therefore does not reveal whether a recurrent carrier has preserved the entities that define the game

    MultiWorld loses most parsable content by tick 8, and B-UN begins near zero despite a comparatively low LPIPS. Appearance alone therefore does not reveal whether a recurrent carrier has preserved the entities that define the game. Count and position reveal complementary behavi...

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.