This is not a list of viral demo models. This is the actual technical work that landed in the last four weeks that will change how you build, train and deploy LLMs for the rest of this year.

None of these got 100k reposts. None had a CEO demo thread. Every single one is already shipping in production models, and every engineering team that ignores them will be operating on an obsolete baseline by Q4.

On-policy distillation is the new default post-training step

If you have been wondering why every new frontier model released in 2026 is suddenly 2-3x better at tool use and trajectory consistency for the same parameter count, this is the answer. On-policy distillation (OPD) is not another alignment trick. It is a fix for the single largest flaw in RLHF and DPO as they were practiced last year.

The core problem OPD solves is credit assignment over long trajectories. Standard preference optimization only sees the final reward for a full rollout. It spreads that signal uniformly across every token in the sequence, most of which had nothing to do with the success or failure of the task.

OPD works differently. After running a rollout, a separate critic model identifies the exact token position where an error was introduced. It injects a single hint token immediately before that position. You run one forward pass, not a full regeneration, and the hint will cause the model to naturally assign lower probability to the bad action that followed. You then distill that adjusted probability distribution back into the base model.

No new sampling. No new rollouts. No reward hacking. Just one forward pass per failure.

This is the post-training used for Qwen 3.6, GLM-5.1, DeepSeek-V4 and every other model that suddenly jumped ahead on agent benchmarks in March. As of this month it is now the standard final training step for every frontier model. No production model will ship without it by the end of the year.

If you are still running vanilla DPO on your fine tunes, you are already two generations behind.

MiniMax Sparse Attention rewrote the memory access rulebook

Everyone has been arguing about sliding window attention and streaming attention for three years. MiniMax just skipped the entire debate.

Their new MSA architecture does not approximate attention. It does not drop tokens. It does not compress KV cache. It restructures the entire operation around how hardware actually fetches memory.

All prior sparse attention implementations run Q as the outer loop. For every query token, they go and fetch the relevant KV entries. This produces thousands of tiny scattered memory reads. Every modern GPU dies on this pattern. Cache hit rates drop to single digits. 90% of execution time is spent waiting for memory.

MSA inverts the loop. It iterates over KV blocks first. For each block, it gathers all queries that will hit that block, computes all the scores in one batch, then discards the block. Every memory read is contiguous. Every block is fetched exactly once per generation step.

The numbers are not incremental. At 1M token context:

• 4x faster than Flash Sparse Attention
• 1/20th the per-token compute of their prior generation
• 9x faster prefilling, 15x faster decoding

This is not a clever kernel optimization. This is a fundamental change to what attention is allowed to do. For the first time, long context does not come with a performance penalty. It comes with a performance improvement.

We are already phasing out explicit chain-of-thought

Three years ago Chain-of-Thought doubled reasoning performance on every benchmark. Everyone concluded that LLMs reason in language.

That conclusion was wrong.

Chain-of-Thought was never the reasoning. It was the scaffold. Transformers do a fixed amount of compute per generated token. Generating intermediate thought tokens was just a hack to trick the model into allocating more compute to the problem. The language itself was incidental.

We have now run the control experiment. We know you can get almost all of the performance gain without ever emitting the thought tokens.

Quiet-STaR trains models to generate internal rationales that are never output. COCONUT removed language entirely, running reasoning iterations directly over continuous hidden states. Fast Quiet-STaR retains 92% of the CoT performance gain while cutting inference time by 65%.

This is not a minor adjustment. This is a complete reversal of the direction the entire field was moving 12 months ago. We spent three years making reasoning more visible. We are now spending all our effort making it invisible again.

The open question is no longer "can LLMs reason". It is: if reasoning is just computation over state, how much of it ever needed to be language at all?

DPO works for every failure mode, not just chat alignment

Everyone thought DPO was for making chatbots polite. It turns out it is the best tool we have for fixing almost every structural failure mode in autoregressive models.

Dharma AI published the first large scale benchmark of DPO applied outside alignment. They used it to eliminate text degeneration in OCR models. The results are unambiguous.

Across five different model families, supervised fine tuning reduced degeneration inconsistently. In one case it actually made degeneration 5x worse. Then a single DPO stage run on exactly the same data reduced degeneration by an average of 59.4% across every model. Best case reduction was 87.6%.

No exceptions. No outliers. It worked every single time.

The reason is simple. SFT optimizes token by token. It can never see that a sequence has entered a repetition loop. It only sees that each individual token was locally the most probable choice. DPO optimizes over full completions. It can see and penalize the failure mode as a whole.

This is generalizable. Any failure mode that can be recognized as a complete output can be suppressed with DPO. This works for repetition. It works for hallucinations. It works for tool call formatting errors. It works for every failure mode that SFT structurally cannot touch.

If you are still fighting failure modes with inference time hacks and prompt engineering, stop. You are treating symptoms. DPO fixes the distribution.

The SFT / DPO division of labour is now formalized

We can now state clearly what each training stage does, and what it cannot do. This was the single largest outstanding open question in LLM training as of 6 months ago.

SFT moves the model into the task domain. It teaches vocabulary, syntax, output format and general competence. It cannot remove failure modes. It will often introduce new failure modes as a side effect of increased capability.

DPO reshapes the distribution inside that task domain. It removes attractor states, suppresses consistent failure modes, and sharpens the boundary between acceptable and unacceptable outputs. It cannot teach the model new capabilities. It will never make a model good at a task it could not already perform.

These are separate operations. They address orthogonal failure dimensions. Running one without the other is a waste of time.

This is not an opinion. This is empirical observation across every model family tested in the Dharma benchmark. The Qwen 2.5-VL 3B result demonstrates this perfectly: vanilla model had 0.6% degeneration because it could not even produce long structured outputs. SFT made it capable at the task, and degeneration rose to 3.23%. DPO then brought degeneration back down to 1.41% without losing any of the capability gained during SFT.

Nemotron 3.5 solved the enterprise safety tradeoff

For two years enterprise safety models forced an impossible choice: you could have low latency binary verdicts, or you could have auditable reasoning. You could not have both.

Nemotron 3.5 breaks this tradeoff properly. It is a 4B parameter multimodal model that runs on 8GB VRAM, supports 140 languages, accepts custom natural language policies at inference time, and can output an auditable reasoning trace on demand.

Most importantly, it does not force you to pick one mode forever. You run the low latency binary verdict inline for every request. You run the full reasoning trace asynchronously for audit logging, edge case review and policy iteration.

This is the first safety model that actually matches production requirements. Prior models assumed you would either block everything or log everything. Production systems need to do both, at different times, for different traffic.

It also addresses the single largest unspoken flaw in multimodal safety datasets: 99% of the training images are real photographs, not SDXL generations. Every existing multimodal safety benchmark fails completely on real world content. This one does not.

EVA-Bench 2.0 is the first agent benchmark that actually predicts production performance

Almost every agent benchmark is useless. They test happy path tasks that no real user will ever ask. They have ambiguous success criteria. Scores correlate with nothing that matters when you deploy.

EVA-Bench 2.0 fixes this. It has 213 scenarios across airline support, IT service management and healthcare HR. Every scenario has exactly one correct resolution path. Every one was validated against three frontier models. Every one includes authentication flows, unsatisfiable requests and adversarial user behaviour.

Most importantly, there are no trick questions. Every scenario is exactly the kind of call that a real support agent receives 100 times per day.

This is the benchmark that will kill the demo agent. For the last two years every team could show a 90% success rate on their own curated test set. Now there is a common baseline that everyone will be measured against.

If your agent scores 60% on EVA-Bench it will work in production. If it scores 40% it will not. There is no middle ground.

What none of this means

None of these advances get us to AGI. None of them solve hallucinations. None of them fix alignment.

What they do is move the baseline. Every single one of these techniques will be standard, boring, default practice 12 months from now. Right now almost no one is using all of them. That gap is where all the practical advantage will live for the rest of this year.

This is the quiet part of progress. No demo threads. No press releases. Just engineers fixing actual problems, one at a time. This is the work that actually changes what you can build.

References

1. On-policy distillation entry on PapersWithCode: https://paperswithcode.co/methods/on-policy-distillation
2. MiniMax Sparse Attention announcement: https://www.reddit.com/r/MachineLearning/comments/1tvameq/minimax_dropped_a_new_attention_architecture_n/
3. Nemotron 3.5 Content Safety: https://huggingface.co/blog/nvidia/nemotron-3-5-content-safety
4. EVA-Bench 2.0: https://huggingface.co/blog/ServiceNow-AI/eva-bench-data
5. Direct Preference Optimization Beyond Chatbots: https://huggingface.co/blog/Dharma-AI/direct-preference-optimization-beyond-chatbots