CADRE — Causal Diffusion Representation autoencoders — was announced on Kyutai’s blog on 22 October 2026, with code released on GitHub on 1 October and weights on Hugging Face from 29 September. The work is by Adrien Ramanana Rahary, Yutong Bai, Nicolas Dufour, Patrick Pérez and David Picard, across Kyutai, École Nationale des Ponts et Chaussées and BAIR at UC Berkeley.
It addresses a problem that sounds like plumbing and is actually about whether a generated world feels inhabited.
The latency trap
A world model does not generate pixels. It generates in an autoencoder’s latent space, and the autoencoder’s compression therefore sets both the cost per frame and — the part everybody skipped — the delay before your input can take effect.
Write the compression as τ×s×s, where τ is frames per latent and s is the spatial factor. Latency is τ divided by frame rate, plus generation and decode time. At τ = 8 and 20 fps, the chunk alone contributes 400 ms before anything else happens.
Here is the reference point the paper leans on: humans notice their own movement lagging beyond roughly 230 ms. So a world model inheriting an autoencoder from a text-to-video generator — where packing eight frames into a latent is simply efficient, because nobody is pressing a button — starts almost twice over budget. That is why so many impressive world-model demos are videos rather than things you play.
How CADRE is built
The encoder borrows the MIRA recipe: a frozen DINOv3 ViT-B/16 (86M parameters, not trained) extracts per-patch features from each frame, and one trained 3D convolution compresses them into a 64-channel latent. Only that bottleneck differs across the seven family members — roughly 476M trained parameters each.
The decoder is a causal diffusion transformer, 24 blocks, streaming chunk by chunk. Progressive self-distillation teaches it to decode in one or two steps, in a single training stage and without an adversarial loss — which is a notable omission, since GAN losses are the usual way to buy sharpness in a video autoencoder and the usual source of training instability.
The autoencoders were trained on 23 public video sources, about 76,000 hours, spanning web, robot, driving and game footage.
The numbers
Kyutai trained the same 1.2B-parameter causal diffusion transformer on each autoencoder, across four environments — robot manipulation, human manipulation (EgoDex), driving (PhysicalAI AV) and indoor navigation (RealEstate10K). Each model sees 2 seconds of real video, then generates 4.8 seconds. Video is 288×512 at 20 fps on one H100.
Reaction latency, one decoding step, one H100:
| Autoencoder | Reaction | Notes |
|---|---|---|
| DC-AE | 118 ms | frame-by-frame |
| CADRE-2×32×32 | 185 ms | 23.4 fps sustained |
| Wan 2.2 | 317 ms | |
| LTX-2 | 492 ms | |
| Cosmos | 605 ms |
CADRE is reported as being as fast and better in 42 of 48 comparisons against MIRA, Wan 2.2, Cosmos and LTX-2, with a driving FVD of 162.6 for CADRE-2×16×16 at one step against 599.7 for Wan 2.2.
And the weakness, which Kyutai publishes rather than buries: on robot-manipulation action following (ARR, where 1.0 matches real video), CADRE-2×32×32 scores 0.45 against Wan 2.2’s 0.85. The configuration that reacts fastest is the one that listens least well. That is a straightforward compression trade — 32× spatial reduction throws away the detail an inverse-dynamics probe needs to tell what action was taken — and it is the honest counterweight to the latency headline.
What is released, and what is not
We checked rather than trusting the announcement.
kyutai-labs/cadre-autoencoders-and-world-models— real, MIT licensed, created 29 September, last commit 20 October (“Serve four world models with shared GPU concurrency”). Trains and evaluates the autoencoders, the world models and the action probes, and serves the demo.- Weights — published on Hugging Face:
cadre-2×16×16-multires,cadre-2×32×32-multires,cadre-4×16×16-multires,cadre-8×16×16-multiresand world-model checkpoints, created 29 September to 1 October. Download counts are in single and double digits, which is what a pre-publicity research release looks like. - The demo — live at
cadre-wm.kyutai.org, serving all four environments on one H100 with two concurrent users and a queue. You can also run it locally:uv run --extra demo python demo.py. - The paper — not released. The repository’s own badge reads “arXiv: coming soon.”
That last point needs saying because the secondary coverage of CADRE cites “the research paper” repeatedly as a source for specific figures. There is no paper to cite yet. The numbers in this article come from Kyutai’s blog post, the repository README and the model repositories — all primary, all checkable, and all we were able to confirm.
One smaller finding: the README’s own link to the blog post, kyutai.org/blog/2026-10-07-cadre, 404s. The post is live at kyutai.org/blog/2026-10-22-cadre, dated 22 October. Somebody moved the publication date and the badge did not follow.
Why this matters outside robotics
Three of the four evaluation environments are robotics and driving, and that is where the funding is. But the thing CADRE enables is the thing interactive artists have been waiting for: a generated world that responds to a controller inside the window where response feels like causation rather than consequence.
Everything in that genre so far has either been a non-interactive clip or has had enough lag to break the illusion. 185 ms, at 23.4 fps, with MIT code and published weights, on hardware you can rent by the hour, is the first version of this that is reachable.
The resolution is 288×512 and the content is driving footage and robot arms. Nobody is shipping an exhibition on this next month. But the latency problem was the structural one, and this is a credible answer to it.
Sources
- CADRE: Rethinking Video Autoencoders for Interactive World Models — Kyutai blog, 22 October 2026
- kyutai-labs/cadre-autoencoders-and-world-models — GitHub (MIT)
- Interactive demo — cadre-wm.kyutai.org
- kyutai/cadre-2x32x32-multires — Hugging Face weights
- Kyutai CADRE: Video Autoencoders That Cut World Model Lag Below 230 ms — MarkTechPost