Duo-1.0-causal-base: 153 GB of Weights, a Paper, and No Launch Post

At 06:32 UTC on 12 November, a Hugging Face repository called Duo-1.0-causal-base took its initial commit: 80 files, 153.46 GB, and a package containing a vision-language backbone, an audiovisual diffusion transformer, two codecs, a speech recognizer and a forced aligner. The paper behind it had gone up on arXiv the day before. Three sibling repositories followed within twenty-four hours, one of them still uploading this morning. The repository's own news block, dated 13 November, calls all of it a release. Almost nothing else does. There is no launch post, no hosted endpoint, no pricing page and no independent benchmark for Duo-1.0-causal-base that I can find — and the license file sitting inside those 153 GB excludes the European Union, the United Kingdom, South Korea and the United States from its grant.

So this is not a launch piece, because there was no launch. It is also not a leak piece, because the weights are public, ungated and complete. What follows separates the two things that get blurred whenever a research lab drops a repository instead of a product: what the files and the paper actually establish, and what nobody has confirmed yet.

What landed, and in what order

The sequence is readable off repository metadata, which matters because it is the only first-party record.

• The paper — arXiv 2611.15131, Duo: A Reciprocal World Model for Full-Duplex Interaction, twenty authors from Hengyuan Cao to Zhenzhong Lan, submitted 11 November 2026. The Hugging Face paper page shows 27 upvotes and no coverage beyond it.

• The weights — four repositories under the inclusionAI organization, which describes itself as the home of Ant Group's AGI initiative and whose project page carries a 2026 Ant Research copyright. Duo-1.0-causal-base and Duo-1.2-causal-base were created at 06:30 and 06:32 UTC on 12 November; Duo-1.0-distill twenty-five seconds earlier; Duo-1.0-distill-quant this morning at 08:09 UTC.

• The code — github.com/inclusionAI/Duo, Apache-2.0, created 6 November but holding exactly one commit, timestamped 09:13 UTC today, with six stars and no forks at the time of writing.

• The statement — the README's news block, all three lines dated 2026/11/13: the paper, the vLLM-Omni and SGLang-Omni streaming pipelines, and the v1 weights plus offline inference code.

The bundle sizes are the first thing a reader can act on, because they are not interchangeable.

• Duo-1.0-causal-base — 153.46 GB across 80 files. Realization weights 69.07 GB, Intent model 66.73 GB, video and audio codecs 11.02 GB, speech stack 6.54 GB, and an 84.8 MB adapter.

• Duo-1.2-causal-base — 153.46 GB across 80 files, described only as "improved generation quality," with its distilled and quantized variants listed as coming soon.

• Duo-1.0-distill — 2.78 GB, eight files. An overlay, not a model: it downloads into the same directory as the base bundle and replaces the sampler settings with Euler at four steps and a flow shift of 5.0, against fifty steps at 1.0 for the base.

• Duo-1.0-distill-quant — 47.03 GB. The same four-step overlay in ModelOpt FP8 with per-channel scaling, and the card is explicit that the runtime has to support that format or offer a conversion route.

Two modules and a 708-millisecond clock

The architecture is legible from the config files, which is more than most model cards give you. Duo splits the job in two.

The Intent module is declared as Qwen3VLForConditionalGeneration — 64 layers at 5120 hidden, 64 attention heads with 8 key-value heads, an intermediate size of 25600, a 151,936-token vocabulary and a 27-layer vision tower with a patch size of 16. The shards add up to 66.71 GB of bfloat16 weights. That is a large vision-language model, and the card never states a parameter count, so the size class is an inference from the config rather than a vendor figure. On top of it sits a LoRA adapter with rank 8 and alpha 16, targeting the query, key, value and output projections plus the language-model head, and four trainable special tokens: <wait>, <blank>, <chunk_708> and <speak>.

That token set is the whole idea in miniature. Every chunk, the Intent module emits either <speak> with text or <wait> with nothing. Deciding when to talk is a separate prediction from deciding what to say, which is the difference between a model that answers when you stop and one that can interject, hold silence, or keep talking while you do.

The Realization module is a MiniMaxH3DiTModel: 50 layers at 5376 hidden, 56 heads of dimension 128, a feed-forward width of 14336, a 1×2×2 patch, 24 latent channels for video and 32 for audio, and a two-layer token refiner that folds the Intent module's hidden states into the conditioning. It is initialized from MiniMax H3 weights, and the NOTICE file names the upstream license. The shards total 66.28 GB across 535 tensors.

The clock that ties them together is the number worth memorizing. Interaction runs in chunks of 17 video frames at 24 frames per second — 708 milliseconds. Each chunk encodes as five video latents with a 1-4-4-4-4 frame split, and as 2×29 audio latents, because audio runs at 40 latents per second per channel at 32 kHz, one every 25 milliseconds. Positional encoding is three-dimensional RoPE keyed to playback time. The attention masks are built so that no chunk can see the clean media of its own future, which is what makes the whole thing causal and streamable rather than a diffusion model that needs the finished clip before it can start.

The latency claim is real, and it is an eight-GPU claim

The paper's streaming section is the most concrete thing in the release, and the least reproducible on the hardware most readers have.

• Intent inference — 90 to 160 ms per chunk.

• Joint latent generation at 768×576 — 200 to 450 ms.

• Streaming decode — about 30 ms per four-frame group.

• Overhead — about 40 ms.

• Total — 330 to 650 ms, against a cycle target of 17/24 of a second, with a further 708 ms of sampling delay if an utterance ends mid-window.

Those numbers come from an eight-GPU layout. The Intent module runs tensor-parallel across four ranks on GPUs 0–3 alongside the speech recognizer; the diffusion transformer spreads across all eight, choosing tensor or sequence parallelism per chunk by whichever minimises cycle time under the memory bound; the streaming VAE tiles spatially four ways on GPUs 4–7. GPUs 0–3 run Intent for chunk k+1 while GPUs 4–7 decode chunk k. Output is released as a one-frame anchor plus four four-frame packets, and the shortest playback interval, 1/24 of a second at about 41.7 ms, is deliberately longer than the 30 ms decode so the buffer can absorb jitter.

Now read the README's requirements against that. The reference offline deployment asks for two CUDA GPUs — one for Intent and the codecs, one for Realization — two Python environments because the pinned qwen-asr package drags in its own Transformers version, and FFmpeg on the path. That is the configuration the shipped demo actually runs. The 330 to 650 ms figure assumes eight GPUs of unstated model. Both numbers are honest; they answer different questions, and the gap between them is the distance between a paper result and a box you can build this week.

93.3% is the authors marking their own exam

The evaluation is unusual in a way that deserves to be stated before the percentage is quoted anywhere.

Thirty real-time duplex cases were replayed side by side on a shared timeline and judged at normal playback speed with sound, against six binary criteria with written failure conditions: content responsiveness, language adherence, speech intelligibility, visual identity stability, audiovisual synchronization, and audiovisual emotional consistency. Of 180 checks, 168 passed — 93.3%. Ninety of ninety passed on language adherence, speech intelligibility and visual identity stability combined. Emotional consistency came in at 96.7%, lip alignment at 90.0%, and content responsiveness at 73.3%, or 22 of 30.

Three things follow, and only the first is flattering.

First, 93.3% over 180 binary checks with written failure conditions is a more falsifiable claim than a leaderboard Elo, and the failure analysis is unusually specific: jokes and oblique remarks that need the model to read past the literal words, and intent that only resolves when speech and video are read together — the paper's example is a user indoors mentioning a shared bike as it starts to rain, which the model treated as a request for advice rather than a scene change.

Second, the judges are the authors. There is no third-party run, no blind pairwise study, no panel of outside reviewers. A binary rubric with written conditions is the right instrument; applying it to your own outputs is not independent verification.

Third, and most telling, there is no baseline comparison anywhere in the paper. The only quantitative contrast is an ablation on data synthesis: over a sixty-second sequence of ten six-second blocks, the baseline loses 34.2 luma levels by the ninth block while the proposed method stabilises at roughly 99. Related work — Moshi, Qwen-Omni, Wan-Streamer, EMO, OmniHuman, LiveTalk, Self Forcing, CausVid — is discussed qualitatively with no head-to-head numbers. The paper also never states parameter counts or training-data volumes. So the honest summary is that Duo v1 has been measured against a rubric, not against another model.

The license is the part that decides your week

This is the section that changes procurement decisions, and it is buried in a 17 KB LICENSE file rather than in the model card's prose.

The weights are not Apache-2.0. The code repository is; the weights are not. Every Duo checkpoint carries minimax-h3-community-license, because the Realization module was initialized from MiniMax H3 and the license travels with the derivative. The agreement inside the bundle is dated 2 August 2026 and defines "M​iniMax" as Nanonoble Pte. Ltd.

Its grant is territorially limited. "Applicable Territory" means worldwide excluding the Excluded Territories, and the Excluded Territories are the European Union, the United Kingdom, the Republic of Korea and the United States of America. The license text invites anyone in those territories to contact M​iniMax about obtaining a license "based on robust controls and guardrails," which is a route, not a permission.

Practically: a research group in Singapore, Switzerland, Japan, India, Brazil or Canada can download and run this today under the stated terms. A team in San Francisco, London, Berlin or Seoul cannot, on the plain reading of the file, and should not discover that at the end of a two-week integration. That asymmetry is also why the license — not the benchmark — is the thing to check before you schedule anything.

What you can actually run today

The offline path is documented and short. Clone the repository, build two virtual environments — one for Realization, one for the speech stack — download a base bundle, copy configs/inference.example.json to configs/inference.json, point it at the weights and the two Python executables, and launch run_demo.py --config configs/inference.json --port 4173. The interface is a browser page at /video/index.html.

For streaming, the README points at two branches: vLLM-Omni, marked recommended, and SGLang-Omni. That is the path the latency figures describe, and the one that needs the eight-GPU layout.

Two caveats about what you will see. The project page's demos are drawn from training data and offline inference — it says so, and adds that real-time full-duplex results "will be added soon." And the release is explicitly a preview: "Duo v1 is a preview release for researchers," supporting "basic audiovisual conversation," with v2 promised to condition Realization directly on user audio and video for visual interaction. If your interest is a model that watches you and reacts to objects, that capability is not in this drop.

Who should care this week, and who should wait

• Full-duplex interaction research — this is the most concrete open release in the category: a paper with a latency budget, a chunk clock, a distillation recipe and weights that actually download. The dual-rollout distillation — rolling out the frozen Intent module and then generating media from the model's own outputs, rather than from recorded history — is the transferable idea even if you never run Duo.

• Teams building an avatar or companion product — worth reading for the 708 ms framing alone. That is the number that decides whether an interjection feels like a person or a lag, and it is a design constraint you can adopt without adopting the model.

• Teams in the excluded territories — wait, and treat the license conversation as the critical path rather than the GPU budget.

• Anyone who wants an API — this is not that. The model card states plainly that no inference provider is serving it, and there is no vendor endpoint.

That last point is where a router honestly fits and where it does not. OrcaRouter does not host Duo-1.0-causal-base and cannot route it: a 153 GB two-module diffusion stack with a fixed 708 ms chunk clock is not a chat-completions target, and no amount of routing changes that. What is routable is the turn-based fallback that most teams ship while a duplex experiment runs behind a flag — speech in, a language model, speech out. The speech-out leg can be a hosted text-to-speech model rather than another process on the same two GPUs, and doing it through one API for more than 200 models with provider list price passed through at 0% markup keeps the cost arithmetic unchanged when a vendor moves a price. Automatic failover belongs on those hosted legs, not on the self-hosted one: it keeps a demo alive when a provider wobbles, and it does nothing for a stack you are running on your own hardware.

The other honest use is evaluation discipline. Keep the production path on models you can call, and treat Duo-1.0-causal-base as a bench experiment with a written rubric — which, given that the only existing rubric was applied by its authors, is exactly what it is.

What would change the verdict

Three things, in ascending order of how much they would matter.

A third party scoring the six criteria on prompts the Duo team did not choose. The rubric is already published, which makes this cheap for someone to do and expensive for the model if content responsiveness is really 73.3% on unseen cases.

A hosted endpoint or a serving recipe that does not assume eight GPUs. The two-GPU offline demo and the eight-GPU latency claim are both true, and the gap between them is where most readers will actually live.

License terms that include the excluded territories. Nothing about the architecture changes that arithmetic, and no amount of benchmark improvement does either.

Until then the accurate description of Duo-1.0-causal-base is this: a complete, ungated, 153 GB research bundle with a real latency budget and a self-scored evaluation, released as a paper and a repository with a dated news line and no product behind it. That is more than a preprint — the weights are there and the demo runs — and considerably less than a model you can plan a quarter around. The open question is not whether Duo can hold a conversation in 708-millisecond slices. It is whether anyone outside the team will be allowed to check.