Olympiad Gold Becomes a Two-Step Recipe

Featured

01 Olympiad Gold Becomes a Two-Step Recipe

Olympiad-level reasoning used to look like something only frontier labs could reproduce. SU-01 reframes it as a portable recipe — one you can drop onto any post-trained reasoning backbone. Two moves do the work: a reverse-perplexity curriculum SFT (difficulty ordered by "reverse" perplexity) instills proof-search and self-check behaviors, then a two-stage RL amplifies them. Verifiable-reward RL first, then proof-level RL. Test-time scaling extracts the last bit.

The authors ran it on a 30B-A3B backbone with about 340K sub-8K-token trajectories for SFT plus 200 RL steps. The model handles reasoning chains over 100K tokens and won IMO 2025, USAMO 2026, IPhO 2024, and IPhO 2025 gold.

Discount the "simple and unified" framing. The abstract leaves three questions open: how reverse-perplexity actually orders difficulty, where those 340K high-quality trajectories came from, and whether teams without olympiad-grade annotations can reproduce it. If the recipe really transfers across backbones, training costs for reasoning models get rewritten. If it doesn't and the win is in the data, this becomes another "reproducible only with frontier-lab resources" story.

Key takeaways: - Olympiad gold has been packaged from a one-off capability into a two-stage recipe (curriculum SFT plus two-stage RL). Cross-backbone reproduction decides whether it generalizes. - Reverse-perplexity curriculum and high-quality trajectory data are the recipe's hidden costs. Don't assume cheap reproduction before you see the details. - A 30B-active-3B MoE sustaining 100K-token reasoning chains is a useful engineering reference for teams building long-chain reasoning products.

Source: Achieving Gold-Medal-Level Olympiad Reasoning via Simple and Unified Scaling

02 Multi-Turn Agents Need More Than "You Failed"

In ALFWorld and WebShop tasks, RL hands the model one trajectory-end reward. It walked fifteen steps and missed, and nobody — least of all the model — knows which step went wrong. The natural fix is OPSD (On-Policy Self-Distillation): a teacher branch with more context gives dense per-token supervision. This works on single-turn reasoning. On multi-turn agents it breaks. Errors compound, the teacher's own signal drifts, and when the teacher vetoes a token it could mean the model lacks the skill or that the teacher didn't retrieve the right one this time. Treating every veto as a negative is wrong.

SDAR demotes self-distillation from main course to gated auxiliary. RL stays the backbone. The distillation signal passes through a sigmoid gate that strengthens teacher-approved positives and softly damps teacher-vetoed negatives. On Qwen2.5 and Qwen3, gains over GRPO are +9.4% on ALFWorld, +10.2% on WebShop, and +7.0% on Search-QA. The bigger result is that naive GRPO+OPSD's training collapse never appears.

Key takeaways: - The pain point in multi-turn agent RL isn't a weak algorithm. Reward signals are too coarse, and dense supervision is worth the investment. - Single-turn distillation tricks blow up in multi-turn settings. The supervision interface needs redesign, not reuse. - Wins came on interactive multi-turn tasks rather than reasoning benchmarks, which says more about agent training progress. Longer-horizon stability is the next question.

Source: Self-Distilled Agentic Reinforcement Learning

03 AR Accuracy and Diffusion Speed in One Frame

Autoregressive decoding emits one token at a time — slow but accurate. Diffusion language models parallelize but lose quality. Orthrus stops choosing sides. It freezes the original LLM, adds a light trainable module, and lets two views share one KV cache. The AR head handles prefill to preserve representation fidelity. Diffusion handles parallel generation. An exact consensus mechanism keeps the two aligned, with the authors claiming lossless inference, up to 7.8× speedup, and O(1) memory overhead.

The headline numbers are clean, but the full paper has to clear two questions: how heavy is that "light" trainable module in practice, and how does consensus degrade on long sequences.

Key takeaways: - AR fidelity plus diffusion parallelism as a combination — not a choice — is the right direction in this acceleration wave. - Lossless plus O(1) memory is deploy-friendly on paper. Real inference loads need to confirm it. - Teams running high-throughput inference services should test whether Orthrus bolts onto existing Transformers.

Source: Orthrus: Memory-Efficient Parallel Token Generation via Dual-View Diffusion

04 Video Models Already Follow Camera Trajectories

Camera-controlled video generation has gone two ways: train a dedicated camera encoder on labeled video, or pay an inference-time optimization tax. Warp-as-History changes the framing. Feed the camera-induced image warp into the model's existing visual history channel as pseudo history frames, align the positional encoding, drop invalid tokens. Done.

Under this interface, a frozen video model shows non-trivial zero-shot camera-following. Add LoRA fine-tuning on one annotated video and it generalizes to unseen scenes. One training video sounds aggressive — the full paper needs to show how far that generalization actually reaches when scene content shifts hard.

Key takeaways: - Camera control may not need a dedicated camera encoder. The model's existing history-frame path already carries the signal. - Zero-shot capability is there before any training. One video of LoRA is bonus, not gate. - Teams building controllable video generation can probe their backbone with this zero-training interface first, then decide whether heavier pipelines are worth it.

Source: Warp-as-History: Generalizable Camera-Controlled Video Generation from One Training Video

05 Write Multi-Hop Reasoning as Code

Multi-hop QA failures in RAG usually aren't about retrieval quality. They're about hidden state — the model's mid-chain reasoning lives inside natural language, query drift goes unnoticed, and the only thing that catches errors is the same model that made them. PyRAG rewrites the pipeline as an executable Python program. Each retrieval is a function call. Intermediate answers are explicit variables. The whole reasoning chain becomes a trace you can rerun and step through.

Error detection moves from model self-criticism to execution feedback and compiler errors. Self-repair gets a grounded signal. On HotpotQA, MuSiQue, 2WikiMultihopQA, and two other benchmarks, the more compositional the dataset, the bigger the gain. Training-free and RL settings both win.

For teams building multi-hop QA systems, the value isn't the benchmark number. It's swapping "prompts tuned by superstition" for code execution you can manage with normal engineering tools.

Key takeaways: - The real bottleneck in multi-hop RAG is invisible intermediate state, not retrieval. - Expressing reasoning as code means the runtime catches errors instead of the model itself. - Multi-hop QA teams can treat this as an engineering template that pulls them out of prompt-only work.

Source: Retrieval is Cheap, Show Me the Code: Executable Multi-Hop Reasoning for Retrieval-Augmented Generation