Apple trains an 8-step diffusion model that beats its 1,024-step teacher
Apple's machine-learning group published two papers in the same batch that go after the two weaknesses of diffusion language models: the number of passes they need to write a sentence, and how awkward they are to fine-tune with reinforcement learning. Read together, they argue the architecture was never the problem — the training trajectory was.
Trajectory-Shaped Discrete Flow Matching (TS-DFM) trains an 8-step student that beats its own 1,024-step teacher: 32% lower perplexity while generating 128× faster. Discrete flow matching builds text by jumping through a chain of midpoint states until noise tokens become a sentence, then distills that long trajectory into a student that imitates it in a few steps — and when the student underperforms, the standard explanation is insufficient capacity. Apple's team argues the opposite: the trajectory is the bottleneck. Each teacher trajectory is assembled through blind stochastic jumps with no evaluation of the sequence quality, so one bad decision at an early midpoint propagates through every step after it, and the student is asked to faithfully imitate the damage. TS-DFM replaces those jumps with guided navigation — a lightweight energy compass scores candidate continuations at each midpoint and keeps the most coherent — and every bit of that shaping happens only during training, leaving inference cost untouched.
On a 170M-parameter language model, the shaped student at 8 steps beats the best perplexity of every discrete-generation baseline the authors compared against, including methods trained on 6× more data or using 5× larger models, and the gains hold across source distributions and three evaluators of increasing scale. That last detail matters more than the headline number: the recipe is training-only, so it can be applied to a model you have already trained and shipped. Apple is not the first lab to push diffusion language models toward production — we explained the architecture in September — AI 101 — What is a diffusion language model? — and Inception's Mercury 2.5 is already the largest one shipping (Inception ships Mercury 2.5, the largest diffusion LLM yet). What was missing was a cheap path from hundreds of steps to a handful; this is a candidate.
The second paper, DACA-GRPO, fixes reinforcement learning for the same architecture — and it is built to drop into an existing GRPO trainer without retraining anything. Group Relative Policy Optimization was designed for autoregressive models that emit tokens in order and reward them at the end. Diffusion models denoise positions in parallel, and existing RL methods treat every denoising step as equally important while leaning on mean-field likelihood estimates that are systematically biased. Apple's fix has two parts: Denoising Progress Scores, which pull per-token importance weights out of the intermediate predictions the model already computes, at no additional forward cost; and Stratified Masking Likelihood, which partitions token positions into strata so each token gets predicted with most of the sequence as live context, cutting the bias. Stacked on three different GRPO base methods, DACA-GRPO improved results across seven benchmarks — up to 5.6 points on math reasoning, 7.4 on code generation, 5.9 on JSON schema adherence, and a startling 36.3 points on constraint satisfaction, where autoregressive models tend to be strongest.
The honest caveat on both papers is scale. These are 170M-parameter results on academic benchmarks, not a frontier model, and the constraint-satisfaction jump is the kind of number that usually shrinks when the model grows. The transferable claim is narrower but more useful: for diffusion language models, fixing credit assignment and trajectory quality buys more than adding parameters — and both fixes are cheap enough that the next lab to test it can do so in days.
NVIDIA says its edge inference stack completed MLPerf's new Edge Agentic benchmark 6.4× faster than the reference, running a 27B agent locally on a single Jetson AGX Thor dev kit. The benchmark is the one MLCommons added in this week's round — MLPerf v6.1 adds agentic inference tests — and NVIDIA's Rubin shows up — and it measures a real agent loop rather than a single prompt: 20 conversations, 1,007 generated turns, with context growing to about 23.5K tokens as the model calls tools and reads results. NVIDIA's submission, published alongside the results, runs Qwen3.6-27B at NVFP4 weights with an FP8 KV cache in the 128 GB unified memory of the Thor board, and most of the speed comes from not recomputing what it already knows — roughly 96% of prompt tokens are served from a hot cache, leaving only about 0.5 million of 13.6 million prompt tokens to prefill across the whole run. Tree-based multi-token prediction, which verifies several candidate continuations at once instead of one, adds about 40% more decoding throughput on this workload.
The framing that matters for anyone shipping a robot or a vehicle: an agent is not a chatbot with a longer prompt, and edge hardware has a fixed power and memory envelope. Serving a 27B model with 23.5K tokens of rolling history is the actual job, and the benchmark now scores it. Edge agents that can hold a long tool-use conversation locally change what runs on the device instead of a data center.
What to watch: whether a frontier lab ships a few-step diffusion model built on guided trajectories, or an instruction-tuned diffusion checkpoint trained with a GRPO-style recipe. Either one means Apple's two papers are a recipe, not a research artifact.
Would you trust an 8-step model's output over its 1,024-step teacher's if the perplexity says it's better? Tell us in the comments.
Sources: MLCommons — Edge Agentic example
