We got nine good papers dropped on arXiv last week. None have a live demo. None claim GPT-5 parity. Every single one contains something you can deploy in production within 30 days to make your LLMs run faster, cheaper, or more reliably.

This is not a hype roundup. This is what matters for people running LLMs at scale.

Stop deleting entire layers

Everyone doing post training compression has been operating on one unexamined rule: you remove whole layers. You pick contiguous blocks. You throw away either an entire attention block or an entire FFN.

This was wrong.

SubFit demonstrates that redundancy is not arranged at layer boundaries. Redundancy lives inside submodules, scattered non-contiguously across the entire model depth. Some attention outputs are useless. Some FFN projections are dead. None of them line up nicely so you can delete layer 17 whole.

At 25% sparsity SubFit retains 84.6% of downstream accuracy. The previous best baseline hit 81.6%. That 3 point gap is the difference between compression you can actually ship and compression that breaks your product. It also gets you 2.42x perplexity degradation instead of 4.34x. No retraining. Just calibration data. Code is published. Go run it this week.

Speculative decoding finally works for diffusion LLMs

Everyone knew diffusion language models had throughput potential. Everyone also knew you could not run speculative decoding on them. Until now.

SimSD fixes this with one extremely obvious change that no one thought to implement for 18 months. They add a static attention mask that isolates draft reference tokens during verification. That is it. No retraining. No fine tuning. Plug and play.

They measured 7.46x throughput improvement on SDAR models. No quality loss. In some benchmarks quality went up.

This is not an incremental improvement. This removes the single largest remaining practical barrier to dLLM adoption.

Soft errors will break your production LLM

No one talks about this. If you run LLMs on any non trivial cluster, you are getting silent bit flips. Most of the time they do nothing. Sometimes they completely derail generation.

LLMFI is the first proper fault injection framework for LLMs. The authors ran 130,000 fault injections across 3 models and 13 tasks.

The worst finding: 1 bit flip in the KV cache will corrupt output for the next 127 tokens on average. One bit. You will not get an error. You will just get garbage output that looks plausible.

They also published four software only mitigations that add less than 1% overhead. Every production inference stack will implement these by the end of the year.

Attention sinks are not learned early

For two years the standard narrative was: attention sinks form during the first 1% of training, and everything after that just builds on top.

That was wrong.

This study tracked three 1B parameter models through full training, checking head behaviour every log step. Induction circuits form very early, at 0.3-2% of total training tokens. Attention sinks do not. On OLMo 1B they show a sharp phase transition jumping from 7% to 70% of heads between two adjacent checkpoints, 60% of the way through training.

They are two separate transitions. Not one.

This changes everything about intermediate checkpoint pruning, distillation and early stopping. Almost everyone was stopping too early.

SSM and attention finally fuse properly

All previous hybrid models put SSM blocks and attention blocks next to each other. Jamba alternates them. Hymba runs them as separate heads. None let them actually interact inside the attention calculation.

SISA fixes this. They inject the SSM importance score directly into the attention softmax. It becomes one standard SDPA call. No custom kernels. No recurrent state.

At 152M parameters SISA hits 17.3% on LAMBADA greedy. Vanilla transformer gets 13.9%. Mamba 3 gets 15.5%. It also gets perfect needle in haystack performance from 1000 training steps, 7x faster than standard transformers.

This is the first hybrid architecture that actually delivers on the promise of both approaches. Not one better than the other. Both working together.

Activation spikes are just bias vectors

Everyone has fought activation spikes when quantizing LLMs. You spend three weeks tuning clipping thresholds. You give up and go from 4 bit to 5 bit.

It turns out those spikes are not random noise. They are structural bias vectors. The model intentionally builds them. They implement the attention sink mechanism.

INSERTQUANT does not try to avoid spikes. It recognizes them, removes them, and replaces their function with a precomputed template vector. The result is perfectly flat activation distributions. You can quantize cleanly down to 3 bit per tensor with zero accuracy loss.

This works on every LLM tested. It also works on ViTs. This will obsolete every existing post training quantization method.

Merging RL fine tunes does not work the way you thought

All existing spectral merging methods throw away the residual components of task vectors. Everyone agreed all the signal was in the leading singular direction.

That assumption was wrong for RL fine tunes.

ResMerge authors decomposed RL task vectors and found that the residual component contains half the usable task knowledge. It is also far more stable to merge across multiple experts. The leading singular vector carries strong signal but causes catastrophic cross task interference.

ResMerge first builds a consensus backbone out of the residual components, then carefully adds back the leading signal only where experts agree. On average it preserves 18% more expert capability than all existing merging methods.

If you are merging multiple fine tunes, stop what you are doing and test this.

Latent reasoning cuts generation length by half

Chain of thought works. It is also extremely expensive. You pay for every single reasoning token.

Geometric Latent Reasoning replaces the first N reasoning steps with continuous traversal in embedding space. The model does not emit tokens for those steps. It just moves through the latent space until it gets close enough to an answer.

On GSM8K this produces correct answers with 47% fewer total generation tokens. There was no length penalty in the training objective. The model just naturally takes the shortest path once you allow it to move continuously.

This is the first demonstration that we do not need to generate explicit tokens for every intermediate reasoning step. This will halve reasoning cost once productionized.

Blockwise diffusion closes the gap with autoregressive

BlockGen finally gives us a fair comparison between autoregressive, masked diffusion and uniform diffusion models.

The headline result: at 16 token block size, masked diffusion matches autoregressive accuracy on GSM8K at half the number of forward passes.

We are no longer talking about theoretical future advantages. Diffusion models now deliver better cost / accuracy on reasoning tasks than standard autoregressive transformers.

Nobody won the architecture war. We just got a third valid option that is better for certain workloads.

What happens next

None of these papers got posted to Hacker News front page. None had a twitter thread with 10,000 likes.

This is where actual progress happens. Not in 1T parameter model announcements. In the quiet, boring, incremental work of fixing all the broken unexamined assumptions that everyone has been building on top of for five years.

Every single one of these techniques will be standard in every inference engine 12 months from now. Most teams will have them deployed before anyone writes a press release about them.

You can wait for the wrapper libraries. Or you can go read the papers this week.