Hy-Nomas: What Tencent's Free-Form Interactive World Model Actually Does

The most useful thing to understand about Hy-Nomas is that it does not make a video. It makes the next four seconds of a video, shows them to you, waits for your instruction, and then makes the four seconds after that — carrying everything it has already rendered in a cache so the street corner you turned at two minutes ago still has the same shop on it. Tencent Hunyuan published the weights, the inference code, a fine-tuning pipeline, a 280-case benchmark and a browser demo between 21 and 23 October 2026, under Apache 2.0, with no announcement post and no benchmark results. The model card's own gallery includes a sixty-second, five-turn clip called clockwork-flight; that clip is a better explanation of the product than either the repository or the paper that has not been published yet.

What follows is a walk through what actually shipped, how the interactive loop is built, and the one number the release does not contain. It is written from the repository, the model card, and the released configuration files — not from a hands-on run, because as of 24 October there is no third-party evaluation of Hy-Nomas to cite.

Four artifacts, only one of which is a model

Tencent released a bundle, and the bundle is the story. The first artifact is the checkpoint set on Hugging Face, roughly 196 GB across the base autoregressive DiT, a distilled DiT, an INT8 build, the DCAE-V video autoencoder, a fine-tuned PixelUMM decoder in FP32 and FP8, and the Nomas-PE prompt enhancer. The second is the GitHub repository: an inference harness, a captioning harness for building fine-tuning data, offline sequence packing, a LoRA trainer, and a merge script. The third is Hy-Nomas-Bench, a 280-case evaluation set in four tracks with about 220 reference camera trajectories. The fourth is the demo at hy-nomas.hy.tencent.com, where you move through a generated scene with WASD or a mouse drag.

That combination is unusual for a world model release. Most publish a paper and a gallery. Tencent published the machinery and left the evaluation empty. If you want to know whether Hy-Nomas is good, you can now find out yourself; you cannot yet read the answer.

The loop: one segment at a time, with the past kept in cache

Hy-Nomas is a segment-autoregressive diffusion transformer. It renders a short span of video, appends it to the session, and conditions the next span on a lifelong KV cache that holds the earlier latents and their keys and values. That is why the model can keep a scene consistent across turns without a separate memory module or a retrieval step: the history is inside the attention context, and it grows.

The architecture underneath is a 54-block dual-stream MMDiT with hidden size 2,048, 16 attention heads and 3D rotary position embeddings. Text is encoded by Qwen2.5-VL-7B-Instruct. Camera extrinsics enter through cross-attention rather than being baked into the text prompt, which matters for the control story below. Tencent does not state a parameter count; the FP32 checkpoint is 34.2 GB, which implies roughly 8.5 billion parameters if you assume 32-bit storage and no optimizer state — arithmetic, not a vendor claim, and worth treating as an estimate rather than a specification.

• Output — 720 × 1280 at 24 FPS, with the 24 FPS figure describing playback, not generation speed

• Denoising — 8 steps in the distilled configuration; the code accepts 4, 6 or 8

• Latents — 32-channel DCAE-V, decoded by a fine-tuned PixelUMM decoder; an FP8 decoder is provided

• Context — a lifelong KV cache carried across segments, not a fixed window that resets

Two steering wheels, and only one of them is a prompt

The text channel is free-form and multi-turn. You can add an object, change the weather, restyle the scene, or describe an action, and the instruction applies from the next segment rather than re-rendering what came before. The repository's own framing is "free-form multi-turn text prompt control" — the point being that the prompt is not a one-shot caption for a clip but a turn in a conversation with the world.

The camera channel is the more interesting one, because it is not language. You supply a trajectory of camera extrinsics, and the model renders the world from that path while the text prompt continues to describe what is in it. Text and camera can be used together: a prompt that says "the market is closing" and a trajectory that walks down the aisle are two separate inputs that compose. This is the concrete difference between Hy-Nomas and a text-to-video model. A text-to-video model infers a camera move from prose and hopes; Hy-Nomas is told where the camera goes.

There is a third, quieter control: Nomas-PE, an online prompt enhancer that rewrites a terse instruction into something the model conditions on more effectively. It is optional, and it is the kind of component that tells you where the failure modes are — if the base model handled a five-word prompt well, the enhancer would not exist.

The feature nobody is discussing: a domain LoRA in 2,000 steps

Two adapters ship with the release. The Cinematic LoRA merges into the distilled DiT to improve visual quality. The Robotics LoRA was trained on the RealSource-World robotic-arm dataset and merges into the same distilled checkpoint to improve manipulation scenes. Tencent documents the recipe: rank and alpha 256, zero dropout, Muon at a constant learning rate of 1e-4 for 2,000 steps, training only the LoRA parameters, using a technique called segment forcing, then merging the adapter into the distilled weights for inference.

This is the part with the longest half-life. A 2,000-step adaptation on a single domain is cheap enough that a studio with a house look, a robotics lab with its own arm, or a game team with a specific art direction can specialize the model without touching the base weights. It also gives the release a plausible community trajectory that a closed model cannot have: expect the interesting Hy-Nomas results over the next month to come from LoRA merges, not from the base checkpoint.

What it costs to run: eight GPUs, or one 4090 with concessions

The default path is eight GPUs with eight-way sequence parallelism. The low-memory path is the one that made headlines: a single RTX 4090, using INT8 DiT weights and an INT8 KV cache, a sliding-window history cap, CPU offload, FlexAttention for the DiT and CUTLASS FP8 for decoding, with sequence parallelism disabled. Tencent warns that CPU offload needs enough system RAM and adds transfer overhead, which is a polite way of saying the single-GPU mode is real but not free.

The download footprint differs by path too. The documented demo route pulls about 86 GB; the low-memory route needs roughly 38 GB plus the text encoder. Neither is a laptop download, and neither comes with a hosted endpoint. There is no API, no per-second price and no managed service from Tencent for Hy-Nomas — you run it, or you do not use it.

• Default serving — 8 GPUs, 8-way sequence parallelism; training example uses 128 GPUs as 16 data-parallel replicas × 8 sequence-parallel

• Single-GPU serving — RTX 4090 with INT8 DiT, INT8 KV cache, FP8 decoder, sliding-window history and CPU offload

• Footprint — about 196 GB for the full checkpoint set, 86 GB for the documented demo path, 38 GB plus text encoder for low-memory

• Cost — no vendor pricing exists; the cost is your GPU hours

If you are building around an open-weights model like this, the parts that are not the model still need a stack: captioning, prompt enhancement, evaluation harnesses, and whatever LLM sits in the agent loop deciding the next instruction. That layer is where a single API earns its place — OrcaRouter puts 200+ hosted models behind one key at 0% markup, passes provider list price through unchanged, and fails over automatically when a provider degrades, so the orchestration around a self-hosted world model does not need a second contract for every auxiliary call. Hy-Nomas itself is not on our catalogue; the weights are the vendor's, and we are not going to pretend otherwise.

The missing number

Hy-Nomas-Bench is real. It has 280 cases across four tracks — multi-turn text control, camera navigation, interleaved text-and-camera control, and spatial memory — and about 220 reference camera trajectories. What it does not have is a results table. The repository links the dataset; the dataset page carries no scores; the technical report link resolves to nothing and the README says "Coming Soon". Tencent's model card describes architecture and sampling defaults, and those are configuration details rather than benchmark results.

That absence is not a scandal, but it changes what a fair sentence about this model can say. "Hy-Nomas generates 720 × 1280 video at 24 FPS with eight denoising steps" is a specification you can verify from the config. "Hy-Nomas maintains long-horizon consistency" is a design claim, supported by a demo clip, not a measured result. "Hy-Nomas beats model X" is not a claim anyone can currently make, because neither side of that comparison has a published number on the same test.

The honest position, three days after the weights appeared, is that Hy-Nomas is a well-documented capability release with an unevaluated quality claim. The documentation is good enough to reproduce it. The evaluation is good enough to run yourself. The verdict is missing, and it is missing on purpose or by haste — either way, it is not ours to invent.

What to watch, and what to do now

Three things would change the picture. A technical report with actual numbers would turn Hy-Nomas from a claim into a baseline. A community LoRA wave would tell you whether the 2,000-step adaptation recipe works outside Tencent's own examples. And a reproduction on a single 4090 — not a demo, a measured run — would tell you whether the low-memory path is usable or merely possible.

Until then, the sensible way to read this release is by artifact, not by headline. The weights are open, the code runs, the benchmark is a shell, and the demo is a five-turn conversation with a world that remembers. That is more than most labs have shipped this month, and less than a benchmark table would prove. If you have the GPUs and a domain that needs its own look, the LoRA recipe is the reason to download it today. If you need a number before you commit, the number does not exist yet.