Parallel decoding has been stuck in the middle ground for years. Either run autoregression honestly and emit one token per forward pass, letting latency die on a serial line; or reach for discrete diffusion and paint a whole block at once, but quality never quite reaches a same-scale autoregressive model. Continuous flow matching has been waiting on the sidelines, since its controllability and acceleration tricks transfer directly from image and video generation, but nobody had pushed it to billion-parameter scale for language modeling.
Adapted from a pretrained AR model, not trained from scratch
Lafa (Large flow language model) uses blockwise autoregression: the prefix keeps causal attention, while each block runs a bidirectional, asynchronous flow. The payoff is direct. The model can be converted into a block denoiser from pretrained autoregressive weights rather than built from the ground up. The paper reports scales of 0.5B, 7B and 8B trained on fewer than 30B tokens in total, against discrete diffusion language model adaptation that can reach 500B tokens, a gap the authors put at at least 18x.
Two training choices keep earning their place in the ablations. Block-internal attention has to be bidirectional: a fully causal version averages 32.7 percent accuracy, and block-bidirectional lifts that to 38.0. And time must be asynchronous, giving each position its own step so earlier tokens advance faster. That tokenwise time is not hand-set. It is learned during training from the denoising loss, so hard noise levels automatically receive more training samples and integration steps. The learned schedule does show a left-to-right bias, but nothing hard-codes it.
A counterintuitive side effect: learning the flow strengthens AR
Joint training produces an unexpected bonus. Flow training does not merely preserve the pretrained autoregressive capability; a multi-token prediction effect leaves Lafa more accurate than matched pure SFT baselines. Average autoregressive decoding accuracy beats the corresponding SFT baseline at all three scales.
That side effect is the most valuable part of the paper. With a stronger autoregressive predictor in hand, Lafa uses it to verify its own one-step flow drafts. The same weights serve as both drafter and verifier, with no small auxiliary model bolted on as the draft. Across the six benchmarks, this self-speculative decoding path commits between 2.5 and 5 tokens per forward pass while holding accuracy close to or above AR SFT.
Where the 2.54x comes from
Throughput was measured end-to-end on a single H100 at batch size one in bfloat16, averaged over IFEval, GSM8K and HumanEval. At block size sixteen, Lafa 7B reaches 2.54x the throughput of 7B AR SFT at comparable average accuracy. Dropping to block size four is about twice as fast and more accurate on average. By comparison, DeepSeek-MTP and MARS match or exceed AR SFT accuracy but reach at most 1.4x its throughput, while discrete diffusion baselines fall below AR SFT accuracy overall and lose more the faster they are tuned.
The authors are candid about what carries the speed. Pure flow decoding itself needs multiple integration steps to reach AR quality; what actually delivers throughput is verifying one-step flow drafts. Flow map distillation compresses the student model to one or two steps, but the paper admits a quality gap remains against multi-step flow decoding.
Weights and checkpoints are out
All three checkpoints ship under Apache 2.0, with 0.5B and 7B built on Qwen2.5 Instruct and 8B on Qwen3 Base, all at block size four. Each checkpoint supports flow, autoregressive and self-speculative decoding, and switching between them is a single argument change. Noise-level embeddings are initialized with a fixed norm and learn direction only, and that variant takes the top ablation score of 38.0.
So what: if you work on inference optimization, the interesting part is not another 8B model but the idea of one set of weights acting as both drafter and verifier, which sidesteps the long-standing mismatch between draft and target distributions. Reference implementations are at arXiv:2610.28559 and github.com/lafa-gh/large-flow-lms.