The Institute of Foundation Models has released Uno, a diffusion-augmented language-model approach that tries to remove a familiar inference bottleneck without changing the distribution defined by the underlying autoregressive model. The paper was submitted on September 3, 2026, and the accompanying Apache-2.0 repository includes inference, training and evaluation code plus public checkpoints.
The key idea is to separate the parameters that determine response quality from a lightweight set of parameters trained for speed. Uno keeps conventional autoregressive weights, then freezes them while training diffusion adapters that propose several tokens in parallel. A sampler called Ψ-Spec verifies those proposals against the autoregressive distribution and accepts the longest valid prefix.
Why “lossless” matters here
In this work, lossless has a specific technical meaning. Ψ-Spec uses rejection sampling so accepted tokens are sampled from the same target distribution as the autoregressive model. The claim is therefore not that every run will reproduce an identical text string or that floating-point implementations can never differ. It is that acceleration does not intentionally trade away the base model’s probability distribution for speed.
That separates Uno from two common acceleration paths. Speculative decoding normally needs a separate draft model whose proposed tokens are checked by the target model. Diffusion language models can generate blocks in parallel, but current systems often face a speed-quality tradeoff. Uno instead adds diffusion capability around an autoregressive model and keeps the autoregressive weights as the authority during verification.
The serving result is more interesting than the headline 3× number
The authors report up to 3× speedup over base autoregressive decoding in some settings, but the production-relevant result is the behavior under concurrency. Their throughput test measures batch size 1 and the largest batch that fits on a single NVIDIA H200 GPU. For the end-to-end Uno model, the largest supported base-model batch was 64, where Uno was reported to be 1.5× faster; at batch size 1 it was about 2.2× faster.
For the Qwen3-based Uno variant, the paper reports more than 5,700 tokens per second at the largest supported batch and a 1.6× speedup over the base model. The authors also compare against EAGLE-3 and DFlash and report higher throughput in their tested configurations.
This distinction matters for agent systems. A single user request can fan out into parallel model calls, retries and tool-using branches, so batch-size-one latency can overstate the value of an inference optimization. A method that still improves throughput when the device is busy is more relevant to serving cost and rollout generation.
The released artifact is unusually complete for a new inference paper
The public repository contains a Nano-vLLM-based inference engine, linear and tree Ψ-Spec samplers, training code for the diffusion adapters, evaluation loaders and graders, and runnable recipes for Uno Qwen3 8B, Uno 8B and Uno 1B. The repository also points to public checkpoints and documents how to reproduce training, inference and benchmark runs.
That release signal is important because the performance numbers are still primarily author-reported. The paper says system throughput was measured on a single H200 and reports 5,255 tokens per second for its 8B Uno model in one system-throughput comparison. It also reports a 68.4 score on SWE-bench Verified and stronger results than the compared diffusion models across its agentic, coding and long-context suite. Those comparisons should be treated as results from the authors’ evaluation setup until independent reproduction confirms them.
The architectural consequence is bigger than another decoding trick
Aipolix’s main takeaway is the separation of quality authority from speed machinery. In Uno, the autoregressive weights remain the source of the target distribution, while the diffusion adapters are allowed to become an optimization layer around that distribution. Verification is what keeps the optimization subordinate to the model being accelerated.
That pattern is useful beyond this specific implementation. Production AI stacks increasingly need components that can be replaced or tuned without silently changing the semantic contract of the system. Uno offers a concrete version of that principle at inference time: accelerate proposals aggressively, but preserve a verifier tied to the authoritative distribution.
For teams operating high-volume agents, the practical question is now whether the published gains survive their own model, hardware, context-length and concurrency profile. The open code makes that test possible. A sensible evaluation should compare end-to-end latency, system throughput, GPU memory, acceptance rate, output distribution and rollout cost against the organization’s existing speculative-decoding or standard autoregressive baseline.
What is verified and what remains open
The paper, code, training pipeline, evaluation scripts and public checkpoints are available now. The Apache-2.0 repository makes the implementation inspectable and runnable. The central method is also explicit about its verification mechanism rather than relying on an unverifiable “same quality” marketing claim.
What is not yet independently established is the full performance envelope. The 3× peak, H200 throughput numbers and benchmark comparisons come from the authors’ experiments. Hardware kernels, batching policy, model choice and sampler settings can materially change serving results. Uno is therefore a credible and reproducible new inference approach, but not yet evidence that every autoregressive deployment can obtain the same speedup.