Every single production ML team right now is fighting the same fight. You have a model that works great on benchmarks. When you deploy it, you burn $12k a week in GPU credits, hit latency SLOs 62% of the time, and half your on-call tickets are just OOM kills.

This week six papers dropped that actually fix this. No vaporware. No "100x speedup!!!" marketing garbage. Measured, replicable results that you can implement next week.

Stop wasting 70% of multimodal tokens on whitespace

Everyone started rendering code as images for MLLMs this quarter. It works. No one mentioned that 60-75% of every single one of those code images is just blank pixels from indentation and line breaks.

CodeShrink fixes this. They did not invent better compression. They just stopped rendering the whitespace in the first place.

The framework has three parts:

1. Blank-Free Rendering: strip layout whitespace, inject explicit structural markers instead. This alone cuts visual tokens by 41% with zero accuracy loss.
2. Adaptive Compression: a 120k parameter RL agent picks per-input resolution. No more fixed 1024x1024 for every 3 line bash script.
3. Instruction aware pruning: remove visual tokens for code regions that are not referenced in the user prompt.

Across QA, clone detection and completion it cuts visual token count by 71.2% while matching uncompressed baseline accuracy. That is not a small number. That means you can run 3.5x more multimodal code requests on the same GPU.

No one was measuring this. Everyone was just arguing about which ViT backbone to use.

LoRA interference is not a capacity problem

Everyone knows when you stack 7 different LoRAs on the same base model they start breaking each other. The standard answer has been "make the LoRA rank bigger". That is wrong.

The new multi-policy PEFT paper demonstrates something very simple: you do not need bigger adapters. You need to stop putting incompatible tasks on the same adapter.

They ran all experiments on the TRACE benchmark with identical total trainable parameters. Single shared LoRA hit 37.12 score. Manually split LoRAs hit 41.09. Their automatic task grouping and sequencing hit 44.78.

Same parameter count. 21% improvement.

The mistake everyone was making was assuming all fine tuning updates belong in the same optimization path. They don't. Heterogeneous tasks interfere even when there is plenty of parameter capacity. You will get better results splitting one 64 rank LoRA into four 16 rank LoRAs assigned to compatible task groups.

The grokked illusion: perfect test accuracy means nothing

This is the most important paper released this month, and almost no one is talking about it.

You train a model. It hits 100% train accuracy. 100% test accuracy. You ship it. Then you fine tune it on one new task. The old task breaks completely.

This is the grokked illusion. Two models can have identical test performance, and one will be 20x more robust to fine tuning interference than the other.

The researchers ran a controlled experiment on modular arithmetic transformers. Both models hit 100% test accuracy. Then they forced both models to memorize random garbage labels. The standard AdamW trained model dropped to 72% accuracy on the original task. The high entropy equilibrium model stayed at 95%.

The difference is not visible on any standard benchmark. You will only see it when you touch the model again.

Effective rank of the attention and MLP layers is the only metric that predicts this. If you are fine tuning models for production, start measuring this. Today.

3x diffusion speedup without quality loss

OnlineCache fixes the single dumbest thing about current diffusion acceleration. All existing cache policies use the exact same schedule for every single prompt.

A prompt for "red square" does not need 50 denoising steps. A prompt for "cat riding a bicycle on mars holding a cup of coffee" does. OnlineCache learns this.

It has two tiny networks: one that decides per timestep per prompt whether to cache the intermediate activations, and a tiny corrector that fixes the error introduced when you do cache. Both are trained end to end with policy gradient.

On FLUX.1-dev they hit 2.97x speedup at statistically identical FID. On CogVideoX it hits 2.2x. Every single existing diffusion deployment should switch to this. There is no tradeoff.

Quantization does not break models evenly

Everyone has been lying about quantization. All the benchmarks say 4 bit is fine. Everyone running production knows that sometimes it is, sometimes it completely falls apart for no obvious reason.

We finally have good data on why this happens. The Qwen3.6 27B case study ran 55 different quantization variants against the Incompressible Knowledge Probe benchmark.

Quantization	Total size	T1 Trivia	T5 Obscure	T7 Deep
BF16 Original	54 GB	99.5%	10%	4%
Q8_0	29 GB	99.5%	10%	4%
Q5_K_M	19 GB	99.5%	9.5%	3%
Q4_K_M	16 GB	98%	7%	0%
Q3_K_M	12 GB	92%	2%	0%
Q2_K	9 GB	71%	0%	0%

Obscure knowledge dies first. Common facts, reasoning, code generation survive much longer.

There is a hard cliff. Above ~18GB for this model, you lose effectively nothing. Below that threshold, quality falls non linearly, much faster than it would for an equivalently sized native trained model.

Quantization is not free compression. It is a filter that removes the least frequently activated weights first. That is fine if you don't need those weights. It is catastrophic if you do.

Document translation quantization is broken

The machine translation paper confirmed something everyone suspected but no one had measured properly. All standard quantization benchmarks are useless for long context.

They tested EuroLLM and Hy-MT2 across 1.7B to 22B parameters. On standard sentence level MT benchmarks both models handled W4A8 quantization almost perfectly. On real document level translation, EuroLLM quality completely collapsed at any quantization below 16 bit.

No one had tested this because everyone runs benchmarks on isolated sentences. The interaction between chunking, attention patterns and quantization error only appears when you have context longer than 128 tokens.

There is no universal good quantization setting. The correct choice depends on your model architecture, your task, your context length, and your chunking strategy. Anyone that tells you "always use 4 bit" has never run this at scale.

The unifying pattern

All of these results point to the same thing. We stopped building efficient systems. We started just throwing more compute and bigger models at every problem. Then we wondered why everything is expensive and broken.

Every single one of these gains came from stopping doing something obviously stupid.

• Stop rendering 70% blank pixels
• Stop putting incompatible tasks on the same LoRA
• Stop using the same diffusion schedule for every prompt
• Stop running benchmarks on 64 token sentences
• Stop assuming all 100% accurate models are equivalent

None of these required new math. None required a new 1T parameter model. All of them required just measuring what was actually happening when you run these models.

What you should do next week

1. If you run multimodal code models, deploy CodeShrink. It is on Github today.
2. Stop increasing LoRA rank. Split your adapters by task group instead.
3. Add effective rank measurement to your fine tuning pipeline.
4. Test quantization against your actual production workload, not MMLU.
5. If you run diffusion, pull the OnlineCache implementation.

This is where the actual progress is right now. Not in the next big model announcement. In all the boring, unglamorous work of stopping wasting 70% of every GPU cycle on absolutely nothing.

We spent five years learning how to make models bigger. We are finally starting to learn how to make them not terrible to run.