XGEN-JING and DAO: the renderer shipped, the world engine didn't

XGEN Labs calls its new pairing JING (镜, "mirror") and DAO (道, "the way") — a generative first-person experience model coupled to what the announcement calls a computable, shared-world engine. The pitch, in their words: "DAO (道) computes the shared world's state and dynamics, while JING (镜) generates each observer's first-person experience," in a loop where "actions change the world" and those changes "shape what humans and agents experience and how they act next." The closing line of their own research page is more ambitious still: "Together, DAO and JING move beyond generating the next frame toward simulating the world behind it," with an explicit nod to OASIS — "a persistent shared world that people can inhabit, rather than a sequence of scenes generated on demand."

That is a real, well-posed problem. Almost every "world model" demo you've seen fails the same test: walk away from something and look back, and the room has quietly changed, because there was never a world there — only a sequence of frames conditioned on the last few frames. Splitting a symbolic, authoritative state from a generative renderer is a genuine answer to that failure mode. It is also, plainly, the same split every networked video game has run for decades: a server owns the world and decides what's legal; a client only ever sees, and renders, the slice the server hands it. XGEN has swapped the rasterizer for a diffusion transformer. That reframing is the useful way to read this announcement — and it immediately raises the sharp question underneath it: if DAO computes the consequences of actions, what is JING actually responsible for? Is either of them doing physics, or is one of them doing appearance and calling it a world?

I read the GitHub repo end to end, pulled the Hugging Face repo's file listing, and checked the WBench leaderboard directly rather than trusting the announcement's numbers. Short version: the headline WBench rank is real and current. The architecture story is real too, but only half of it is something you can download.

What JING actually is

JING isn't a from-scratch world model. It's MiniMax-H3 Ref2VA — an existing open audio/video diffusion transformer — plus FlashGen, a four-step distillation LoRA, wrapped in a camera-control layer and a demo harness. The Hugging Face repo ships 15 safetensors shards totaling 66,885,741,424 bytes (~66.9 GB), created September 16, 2026 — two days before this leaderboard result. The Hub's own metadata parser didn't return a parameter count for it (safetensors comes back empty in the API response), so as a sanity check: at bf16 (2 bytes per parameter), 66.9 GB of weights is ~33.4B parameters — a back-of-envelope number, not one XGEN states anywhere, but consistent with a sizeable single-observer video/audio DiT.

The transformer's own config.json is the actual architecture disclosure, and it's worth reading over the prose:

// jing_flash_v1/config.json (Hugging Face: XGENlabs/XGEN-JING)
{
  "_class_name": "H3Transformer",
  "num_attention_heads": 56,
  "attention_head_dim": 128,
  "hidden_size": 5376,
  "num_layers": 50,
  "ffn_dim": 14336,
  "in_channels": 24,
  "audio_in_channels": 32,
  "control_config": { "enable": true, "dim_in": 6, "dim_out": 512 },
  "attention_backend": "fa4"
}

control_config.dim_in: 6 is the camera-control vector — six dimensions, FiLM-injected into every transformer block. But the WASD parser that fills it, models/control.py, only ever populates two of those six:

# models/control.py — control_vector()
return [
    float(("d" in keys) - ("a" in keys)),  # strafe
    0.0,
    float(("w" in keys) - ("s" in keys)),  # forward / back
    0.0, 0.0, 0.0,
]

So "keyboard-controlled movement," in the release you can actually run, is planar strafing and forward/back — there's no turning (yaw) dimension driven by keys. The other four slots exist in the architecture and sit at zero in this demo. It's a small thing, but it's the kind of small thing that separates a marketing clip from a released control surface.

Inference runs on six H100 GPUs — one for the text encoder, one for the video/audio VAEs, four for the transformer under sequence parallelism, with FlashAttention-4 as the default backend — and the license is the MiniMax H3 Community License Agreement, inherited as-is because JING is a derivative of MiniMax-H3. That license carves out four "Excluded Territories" — the EU, the UK, South Korea, and the United States — and gates commercial use over $20M/year behind separate written authorization. I covered that clause in detail in the MiniMax H3 piece; it applies to JING unchanged.

The split: an authoritative server with a diffusion renderer

XGEN's own diagram for DAO — literally a five-chip pipeline on their research page — reads: GLOBAL STATE → RULE VALIDATION → STATE UPDATE → OBSERVER FILTER → JING PROMPT. That is not a loose metaphor for a game server's tick loop; it is one, chip for chip. Global state is the authoritative world. Rule validation rejects an illegal action before it can touch anything. State update commits the legal consequence. The observer filter is the area-of-interest culling every multiplayer server runs before it sends a client its next update — and its output, a "JING prompt," is the packet handed across the wire. JING never sees the world; it sees only what DAO decided this one observer gets to perceive.

XGEN says this plainly in their own capability comparison, where "World-State Management" is a dash for Veo 3.1, Genie 3, and GWM Worlds 2, and reads "Maintained and updated by world engine DAO" for XGEN-JING alone. So by their own accounting, JING doesn't manage world state — it renders. Which answers the sharp question directly: DAO is claimed to own the physics; JING owns only the appearance. Handing persistence to a symbolic engine instead of a neural one is a real, defensible engineering answer to the "walk away and look back" failure mode — a rule-checked state table doesn't drift the way an autoregressive video model's hidden state does. But it also means the generative half of this system, the part that's actually released, is not the part keeping the world consistent. If DAO isn't running, nothing in the public artifact is holding a persistent world at all — and, as the next section covers, DAO isn't running.

What's actually released

I searched the entire XGEN-JING GitHub repository for the string DAO. It appears exactly once, and it's a false positive: Dao-AILab, the GitHub org for FlashAttention (named after its author, Tri Dao — unrelated to XGEN's 道). There is no DAO client, no DAO API call, no world-state object anywhere in the inference pipeline. pipelines/bidirection.py reads a single static JSON file of pre-written prompt and WASD-control chunks (read_cases), encodes the whole thing, denoises it in four steps, and decodes one finished clip — the entire sequence of "actions" is authored up front, not supplied step-by-step by anything reactive:

# pipelines/bidirection.py — read_cases()
allowed = {
    "name", "prompt", "control", "slices", "chunks",
    "save_name", "reference_images", "height", "width", "num_frames", "seed",
}

And attention in models/attention.py is explicitly non-causal:

# models/attention.py
out, _ = flash_attn_func(q, k, v, causal=False)

That's the "bidirectional" in JING-Flash-v1's own name: it denoises the entire pre-written clip at once, not frame-by-frame in response to a live action. The README says exactly this, and says what's missing: "This release provides four-step bidirectional inference... The causal model and technical report are coming soon." A causal, frame-reactive model is the one you'd actually need to sit downstream of a live DAO loop. It isn't released.

DAO fares worse. There's no XGEN-Labs/DAO repository, no Hugging Face model, and no arXiv listing — the JING repo's own badges read "arXiv: Coming Soon," and there's no separate DAO badge at all. The DAO section of XGEN's research page has no GitHub link and no Hugging Face link, unlike the JING section directly above it, which has both. What DAO does have is an elaborate interactive demo — a hand-drawn 1893 town called "Oakhaven," rendered as a WebGL panorama viewer with sprite-based characters walking a hand-authored graph. I read that page's source rather than just its rendered output, and its own code comments are unambiguous:

DAO big-map simulation — Canvas 2D, no deps, no LLM. Draws the real Oakhaven 1893 town — the hand-authored oblique painting — and the eight real character sprites, then plays a hand-written script: per beat, every actor has a timeline of waypoints and facings...

COMPILE THE WORLD — four observers of one scripted event on Main Street, Oakhaven 1893. No LLM: every beat, position, perception and plan below is authored by hand.

Elsewhere the same file's comments reference what sounds like a real backend for the actual system — "the engine's PromptBuilder actually assembles for a reactive_decision" — but that backend isn't what loads in your browser. What loads is a deterministic stand-in for it: 114 hand-placed standing anchors, a walk graph, eight sprite sheets, and a six-beat narrative written by a person, not computed by anything. DAO, as anyone outside XGEN can currently observe it, is a demonstration of the idea of a computable world engine, not a running instance of one.

The WBench claim, checked

The headline claim checks out. WBench's live leaderboard, as of today, shows XGEN-Jing (bidirection) ranked #1 on the Full split — 289 cases, five scored dimensions (video quality, setting adherence, interaction, consistency, physics) from WBench's own benchmark — at an 81.0 average, just ahead of XGEN-Jing (4-step AR) at 79.9, then Kling 3.0, Wan 2.7, Seedance 1.5, HY-Video 1.5, Cosmos3-Super, and LTX 2.3.

expand

On the Navi split (158 navigation-only cases, a larger field of 39 models), the ranking XGEN claims is also accurate, and it's the more interesting one to look at directly: Alaya-EVOKE-Turbo edges ahead at 82.0, XGEN-Jing (bidirection) is #2 at 81.9, and XGEN-Jing (4-step AR) sits at #6, tied with two other models at exactly 81.0.

expand

Three things the announcement doesn't say, that the primary source does:

• The ranking is hours old, not settled. Both XGEN-Jing rows carry an "Updated 2026/09/18" timestamp — today. So does Astronex-World a few rows down, and Zing-0.5 (updated the day before). The top of this board is being actively re-shuffled right now; a #1 that's one day old and a #1 that's held for a month are different claims, and this is the former.
• The scores are marked self-evaluation in the leaderboard's own markup. The attribute is data-evaluation-source, and it is rare rather than routine: of 108 data rows across the board's four tables, exactly 10 carry it, and all 10 read self-evaluation. Those 10 resolve to three distinct models — XGEN-Jing's two variants and Alaya-EVOKE-Turbo — each flagged in every table it appears in. The other 98 rows carry no such attribute in any form, which reads as WBench having run those itself. The flag isn't surfaced anywhere in the rendered page — no badge, no tooltip, no footnote — so a reader scanning the visible table has no way to know it's there. I can't tell you what WBench intends by it, only that it's in the source and that it singles out exactly the two labs at the top of both splits.
• Only one of the two ranked XGEN entries is something you can go run. "4-step AR" — the #2 Full-split, #6 Navi-split entry — is almost certainly the autoregressive/causal variant the GitHub README lists as "coming soon." The bidirectional model, the #1 entry, is real and downloadable. The runner-up isn't.

The vision versus the research preview

XGEN's own limitations section is candid, and worth quoting rather than summarizing, because it undercuts the OASIS framing more precisely than I could:

Generative World Simulation is a research preview, and practical economical real-time deployment requires lower latency, better visual fidelity, and more reliable interaction. Fast motion and rapid viewpoint changes can reduce camera and action precision, while extended sessions may introduce drift in scene details, spatial relationships, and interaction context.

"Drift in scene details" over extended sessions is precisely the failure mode the DAO/JING split is supposed to have designed away — DAO holds ground truth, JING just re-renders it, so a returning observer should see the same room. That guarantee only holds once DAO is a running system with an API, and today it's a hand-scripted demo page. One more detail, tucked into a single tagline with no elaboration anywhere else on the site: "DAO makes the world computable. XGEN-JING makes it perceptible. SHEN turns experience into action." SHEN doesn't appear again — not in the repo, not in the doc pages, not in any release-plan checklist. Whatever it is, it's earlier-stage than DAO.

Bottom line

The architecture claim is real and worth taking seriously: DAO-as-server, JING-as-renderer is a coherent, defensible design, and naming the split explicitly is more honest than most "world model" marketing, which usually hides that there's no persistent state at all. The WBench rank is also real, current, and independently verifiable — I checked, and XGEN-Jing does sit at #1 on Full and #2 on Navi today. What doesn't hold up is the implied symmetry: the announcement reads as one coupled system, but only the generative half has weights, code, and a leaderboard entry you can reproduce. The computable half — the piece actually responsible, in their own words, for making the world persist — has no repository, no weights, and a public demo that explicitly disables the one thing (an LLM-driven agent loop) that would make it resemble the thing it's describing. Judge JING as a first-person video/audio diffusion model built on MiniMax-H3, because that's what shipped. DAO, for now, is a diagram and a demo.