AI papers — 2026-07-20

Problem: Existing GraphRAG systems build knowledge graphs in a single LLM extraction pass, producing noisy, duplicated entities and brittle retrieval, while also defaulting to expensive large LLMs and suffering from engineering immaturity (e.g., unsafe eval() on model output).

Method: RAGU is a modular six-stage pipeline (chunking; two-stage typed entity/relation extraction under the NEREL schema with 29 entity types and 49 relation types; DBSCAN-backed deduplication plus LLM summarization via EntitySummarizer/RelationSummarizer; hierarchical Leiden community detection; LLM community-report generation; pluggable refinement) with five retrieval engines (LocalSearch, GlobalSearch, NaiveSearch, MixSearch, QueryPlanEngine) and a three-tier storage abstraction (graph/KV/vector, e.g. NetworkX→Neo4j, NanoVDB→Qdrant). To reduce reliance on large extractor LLMs, the authors introduce Meno-Lite-0.1, a 7B model continually pretrained (1.3B tokens, Russian+English educational/scientific text) and fine-tuned (50M tokens on NEREL-based extraction, multi-hop QA, and query logs) from RuadaptQwen2.5-7B-Lite-Beta, motivated by the observation that language skills (comprehension, extraction, reasoning) scale much more weakly with model size than factual world knowledge (measured via CheGeKa vs. MultiQ F1 on the Qwen2.5-Instruct family, log-linear slopes 0.65 vs. 0.26).

Key results:

• Meno-Lite-0.1 (7B) beats Qwen2.5-32B on knowledge-graph construction IE benchmark by +12.5% relative harmonic mean (HM 0.468 vs. 0.416), driven by relation extraction F1 of 0.347 vs. 0.239.
• On GraphRAG-Bench (Medical), RAGU achieves the highest Evidence Recall at every factoid difficulty level (up to 84% vs. ≤76% for HippoRAG 2/LightRAG).
• RAGU overtakes HippoRAG 2 on Creative Generation (Answer Correctness 59.0 vs. 56.9; Faithfulness 34.2 vs. 26.6; Coverage 57.4 vs. 34.7), while HippoRAG 2 leads on Fact Retrieval (AC 72.4 vs. 54.2) and Complex Reasoning (AC 68.4 vs. 53.7).
• On multi-hop QA with terse prompts, RAGU ties/slightly exceeds HippoRAG 2 on BioASQ AC (72.9 vs. 72.4) and narrows the 2WikiMultiHopQA gap to −5.5pp (58.0 vs. 63.5), but HippoRAG 2 retains a clear lead on MuSiQue (54.4 vs. 40.1).
• Swapping Meno-Lite-0.1 for larger models (up to 32B) changes end-to-end GraphRAG-Bench AC by at most ~1.5pp, and ICL/validation ablation toggles shift AC by at most ~1.5pp.
• Meno-Lite-0.1 has a 128K context window (passkey retrieval 0.98 at 128K), 47% better tokenizer efficiency on Russian text than vanilla Qwen2.5 (3.77 vs. 2.57 chars/token), scores 0.555 overall on MERA, and runs on a single consumer GPU via vLLM.

Why it matters / caveats: RAGU delivers 32B-class extraction quality at 7B compute cost and single-GPU deployability, making GraphRAG more practical and accessible; however, the language/world-knowledge scaling hypothesis rests on a single model family (Qwen2.5), Meno-Lite-0.1 is not a standalone knowledge base and degrades on multi-hop reasoning beyond 32K tokens, its IE benchmark has some train/test schema overlap with NEREL, HippoRAG 2 retains an edge on precise chain-following multi-hop QA, and the default NetworkX graph backend does not scale to massive (multi-million node) corpora without a dedicated graph-database adapter.

Problem: Existing agent skill libraries are hand-written, text-centric, or mined from an agent's own interaction traces, leaving tutorial videos and other multimodal human-created resources (repositories, articles, reference artifacts) largely untapped as a source of reusable procedural knowledge for software agents.

Method: Resource2Skill runs a construction operator (fθ, AD) that distills tutorial videos, source repositories, articles, and reference artifacts into skill tuples s = (p, xtext, xvisual, xcode, m) — path in a domain taxonomy, structured text, visual examples, executable/adaptable code, and metadata/provenance — validated by a domain-specific predicate AD checking completeness, traceable provenance, deduplication, modality consistency, and code executability. Skills are organized into a hierarchical multimodal "Skill Wiki" per domain (e.g., PPT organized by layout/typography/motion, Blender by geometry/material/lighting/composition). At inference, MetaBrowse first uses a BM25 lexical scorer over name/tags/applicability/taxonomy-path to shortlist candidates, then a language model (πφ) selects a subset to compose; selected skills execute via a shared MCP tool surface (plan, MetaBrowse, apply, render) against domain backends (openpyxl/xlsxwriter for Excel, bpy for Blender, ReaScript for Reaper, ezdxf/FreeCAD for CAD, a UE5-MCP bridge, Playwright-rendered HTML/CSS/JS for Web). The same operator is reused online to fill capability gaps when the offline pool is insufficient.

Key results:

• Across 7 domains (Web, Excel, Reaper, PPT, Blender, CAD, UE5) and 4 backends (GPT-5.5, GPT-5.4, GPT-5.4 Mini, GPT-5.4 Nano), w/ Skills beats w/o Skills in all 28 main-aggregate model-domain cells, averaging 56.8% vs 45.0% overall score (+11.9 pp).
• Beats the stronger of two off-the-shelf harness baselines (ClaudeCode-H, Codex-H) in 26/28 cells; paired Wilcoxon p < 10⁻³.
• Largest domain gains on UE5 (+30 to +40 pp); smallest on Reaper.
• Blinded human A/B study (5 raters, 40 matched pairs × 7 domains, 200 ratings): w/ Skills wins 85.5% of non-tied ratings vs w/o Skills.
• Skill-pool scaling: performance rises monotonically and saturates near 200 skills (0→200 gains range +3.1 pp on Reaper to +14.2 pp on Excel; 400→Full adds ≤+0.8 pp).
• Offline+Online acquisition: on Tstandard, online adds only +0.7 pp (65.4%→66.1%); on Tnovel (capability gaps), it lifts mean score from 41.2% to 62.8% (+21.6 pp).
• Source ablation: removing video drops average from 68.9% to 59.4%; video-only library still beats the 3-source no-video library by 7.4 pp (Excel −14.2 pp, Web −11.5 pp when video removed).
• Wiki organization ablation: full Wiki beats a flat pure-text skill list by 2.5–8.2 pp; matched-budget modality ablation shows Text-only=65.0%, +Visual=+1.9 pp, +Code=+2.0 pp, Full=68.9%.
• Selection strategy: MetaBrowse (hierarchy-then-LM) averages 68.9%, vs BM25 66.0%, BM25+Embed 64.2%, Embed 60.0%, Random-FullPool 58.0%, No-Skill 57.3%.

Why it matters / caveats: Demonstrates that video and other multimodal human resources carry procedural/perceptual signal (temporal order, visual effects) that text-only skill libraries under-specify, and that hierarchical organization plus multimodal content outperforms flat retrieval or curated text memory alone; online acquisition is framed as a targeted gap-filler rather than a general performance booster, and gains are domain-dependent (smallest where a no-skill agent already has a competent prior, as in Reaper).

Problem: Robot manipulation policies are bottlenecked by scarce, costly, hardware-bound teleoperation data, which limits the scale and diversity needed to train generalizable vision-language-action (VLA) models the way LLMs and VLMs benefit from web-scale data.

Method: Xiaomi-Robotics-1 uses a Mixture-of-Transformers architecture coupling a pre-trained Qwen3-VL VLM with a diffusion transformer (DiT) that generates action chunks via flow matching, with an auxiliary "Choice Policies" winner-takes-all regression loss on the VLM to accelerate convergence (action-related VLM tokens are excluded from the DiT's attention). Training is two-stage: pre-training on over 100k hours of UMI (Universal Manipulation Interface) handheld-gripper trajectories auto-labeled via a Qwen3.5-27B-based pipeline that captions scene state transitions (producer-consumer pipeline labels the full corpus in ~2 weeks), co-trained with vision-language data (1:9 ratio) under a combined flow-matching + regression + next-token-prediction loss; post-training on ~10k hours of cross-embodiment data (7.2k hours in-house mobile-manipulator/dual-arm data, 1k+ hours instruction-labeled UMI data, plus Bridge V2, RT-1, DROID) to align UMI-gripper action generation to robot embodiments and shift from state-transition descriptions to imperative human instructions. Three model scales are trained: 2.6B, 5.1B, and 10.5B parameters.

Key results:

• Pre-training validation action error (MSE) decreases monotonically with data scale (12.5%→100% of 20k hours) and with model scale (2B→5B→10B), with data scale showing the larger effect.
• Out-of-the-box post-training success rate (4 unseen-environment tasks) rises from 26% (no action pre-training) to 75% with full pre-training data; model scaling raises success from 61% (2B) to 75% (5B) to 79% (10B).
• Downstream fine-tuning on 4 novel tasks with <10 hours of data/task on average: 75% average success rate and 90% average progress, vs. π0.5's 40% success rate and 66% progress (printer refilling: 70% vs. 20% for best baseline).
• RoboCasa: 74.5% average success rate (vs. previous best World2Act 72.6%).
• RoboCasa365: 57.4% average success rate vs. previous best (ABot-M0.6) 46.6%, with the largest gain on the unseen-composite-task split (32.1% vs. 7.9%).
• VLABench: highest average success rate (59.1%) and progress score (70.3%) across five generalization tracks, including +15.2 points success rate under texture shift vs. best baseline.
• RoboDojo: average score 20.07 vs. prior best 13.07 (+7 points), average success rate improved by 5.13 points over the second-best method; ranks first on 4 of 5 capability dimensions (loses only on Memory, attributed to not using history observations in evaluation).

Why it matters / caveats: Demonstrates that scaling both non-robot-embodiment (UMI) trajectory data and model size produces gains in pre-training that transfer directly into real-robot out-of-the-box performance and data-efficient fine-tuning, suggesting data volume (not just model capacity) is the primary bottleneck for further generalization. The paper notes model-size gains are less pronounced than data-scale gains, implying billions-parameter capacity may already suffice for the current data distribution, and one benchmark weakness (Memory dimension on RoboDojo) is attributed to the evaluation setup lacking history observations.

Problem: Looped Transformers have historically failed to beat vanilla Transformers once pre-training compute is matched fairly, since looping a model N times also multiplies pre-training compute by roughly N, so it remained unclear whether recurrent-depth MoE models can win a genuinely compute-matched comparison rather than just a parameter-matched one.

Method: The paper introduces Loopie, a Qwen3-MoE-style decoder-only MoE Transformer family (Loopie-20B-A2B and Loopie-6B-A0.6B) that uses "layer-loop" recurrence—each layer is applied twice in place (Layer1→Layer1→Layer2→Layer2...) rather than the traditional "model-loop" (whole stack repeated, as in Ouro/Huginn). The "Loopie Recipe" halves stored layers, loops each stored layer twice (R=2), and reinvests the resulting activation-memory headroom into a doubled per-device microbatch size and additional model width/depth, with the final architecture chosen by matching measured Megatron-LM optimizer-step wall-clock time (not theoretical FLOPs) against a Qwen3-like 30B-A3B non-recurrent reference. Pre-training uses two stages (3T tokens on Nemotron-CC-v2-HQ over 4 epochs, then 1.26T-token high-quality annealing mixture), followed by a novel "supervised pre-training" (SPT) stage—SFT-style loss masking but at pre-training-scale batch size/token budget (2T tokens)—and then reinforcement learning with GSPO (with DAPO-style asymmetric clipping and dynamic sampling) on math and code data from the Guru-RL corpus.

Key results:

• Compute-matched comparison: Loopie-20B-A2B overtakes a vanilla 30B-A3B baseline trained on the same 800B-token, compute-matched budget after ~600B tokens, maintaining an advantage thereafter.
• Scaling ladder (4 rungs, 0.15B–1B baseline sizes): Loopie models consistently beat compute-matched vanilla counterparts, with the gap growing (+0.6 to +2.2 points) rather than shrinking at larger scale.
• Layer-loop ablation: removing the layer-loop pattern (same params/compute) substantially degrades downstream average score (Loopie-6B-A0.6B vs. its ablation), showing the ordering of recurrence matters, not just extra compute; layer-loop also gives a 2.14x measured speedup vs. one baseline configuration.
• Loopie-20B-A2B trained on only 3.5T tokens matches/beats Nemotron 3 Nano and Nemotron Cascade 2 (each trained on 25T tokens): MMLU 81.28 vs 80.52/81.22; ARC-Challenge 93.52 vs 91.96/93.86; BBH 82.28 vs 68.76/75.86; IFEval 84.72 vs 77.05/79.21.
• Loopie-20B-A2B Thinking: AIME24 92.09, AIME25 83.75 (ties Qwen3-30B-A3B-Thinking), AMC 94.21, OlympiadBench 80.50.
• Loopie-6B-A0.6B beats several larger/similar compact models on math: AIME24 80.42 (vs. Ouro 2.6B Thinking 62.50, Gemma-4 E4B-it 49.58), AIME25 70.83 (vs. Ouro 2.6B 51.67), MATH-500 93.80.
• IMO 2025: with a generate-verify-refine test-time-scaling pipeline (64-candidate pools, up to 16 refinement iterations, GPT-5.5 as judge), Loopie-20B-A2B scores 35/42 total (7,7,4,6,7,4 per problem), reaching the gold-medal threshold of 35.
• IPhO: with a generate-vote-critic test-time-scaling pipeline, Loopie-20B-A2B scores 20.3, above the gold threshold of 19.7.

Why it matters / caveats: The paper argues recurrence can be a genuine compute-efficient scaling axis for MoE LLMs (not just a parameter-saving trick) if width/depth/loop-count are jointly tuned under a fixed compute budget, and layer-loop's execution locality also helps pipeline-parallel training infrastructure. Caveats stated by the authors: compute-matching is based on measured wall-clock optimizer-step time rather than exact theoretical FLOPs; they deliberately limit to R=2 loop steps since marginal returns to looping decay quickly at pre-training scale; and IMO/IPhO gold results rely on heavy test-time-scaling (large candidate pools and iterative refinement) plus LLM-as-judge scoring rather than plain single-pass inference.

Problem: Existing Hyper-Connections (HC) methods for expanding a Transformer's residual stream into N parallel streams saturate at N=4, because naively increasing N yields diminishing loss improvements while training FLOPs grow rapidly (32% more FLOPs from N=4 to N=16 in mHC for only a 0.006 loss reduction).

Method: xHC builds on Manifold-Constrained HC (mHC, which uses Sinkhorn-Knopp normalized residual mixing) and targets two diagnosed bottlenecks: an information-supply bottleneck (each layer injects only one write-back signal into all N streams) and a cubic-cost bottleneck (generating the N×N residual mixing matrix Hres costs O(N^3 C)). It adds (1) temporal feature augmentation — multi-scale causal depthwise 1D convolutions (kernel sizes {4,8,12}) applied after MoE FFN/MLP outputs, combined via modified Gram-Schmidt orthogonalization to enrich the write-back basis — and (2) a sparse residual-stream architecture that uses a sigmoid-based fixed-plus-routed TopK router to update only k=4 of N=16 streams (dense read, sparse write), reducing Hres generation cost to O(k^3 C). A lightweight variant, xHC-Flash, shares routing and pre-mapping computation across sublayers/blocks to cut memory traffic. Evaluated on DeepSeekMoE-style Transformers (GQA, 144 experts, top-8 routing, SwiGLU FFNs) at 18B (1.7B active) and 28B (2.7B active) MoE scales, and via scaling-law fits on a family of models from 1.7e19 to 4.0e20 FLOPs.

Key results:

• At 18B MoE scale, average downstream score rises from 44.8 (mHC) to 48.8 (xHC), a +4.0 point gain, while adding only 4.1% training FLOPs over the vanilla baseline (training loss: 1.758 xHC vs. 1.776 mHC vs. 1.799 vanilla).
• At 28B MoE scale, average score improves from 50.5 (mHC) to 53.6 (xHC), +3.1 points, with only 3.0% extra FLOPs over vanilla; notable per-benchmark gains include CommonsenseQA +5.7, HumanEval +4.3, C3 +3.8, MMLU +3.7.
• Scaling-law fits show the vanilla baseline and mHC need 1.50x and 1.19x the training compute of xHC, respectively, to reach the same loss.
• On a 2.5B MoE model, scaling N from 4 to 16 reduces loss by 0.012 under xHC (vs. only 0.006 under mHC) while adding just ~4% extra FLOPs (vs. 32% for mHC).
• Ablations (10B MoE, Pile validation loss): mHC N=16 baseline 1.998 to 1.984 with temporal augmentation alone, to 1.983 with full xHC (sparse + dense read) while cutting FLOPs overhead from 20.1% to 3.3%; k=4 (1.983) balances k=2 (1.991) and k=8 (1.982); sigmoid routing beats softmax routing (1.983 vs. 1.988).
• xHC-Flash reduces estimated per-sublayer memory traffic from 73.5C (full xHC) to 40C (xHC-Flash-4sub), close to mHC's 34C at N=4, while retaining most of xHC's performance gains.
• With the Muon optimizer on the 18B model, xHC (without Gram-Schmidt orthogonalization) improves average score from 43.1 (Muon vanilla) to 49.9, confirming gains are not AdamW-specific.

Why it matters / caveats: The paper shows residual-stream expansion can become a genuine, cost-effective scaling axis for LLM pre-training beyond the previously stuck N=4 ceiling, but the authors note that even with sparse updates, xHC's raw memory traffic (73.5C) remains about 2.2x that of mHC at N=4, requiring the additional xHC-Flash and kernel-fusion engineering to make it practical.

Problem: No single specialized LLM adequately covers the full range of healthcare use cases together — patient consultation, expert clinical reasoning over text and images, interactive diagnosis, and EHR tool use — because narrow data updates aimed at fixing one capability tend to degrade others.

Method: Cura 1T is post-trained on top of Kimi-K2.6 using LoRA adapters (rank 32) through a human-gated "self-evolution loop" in which a training agent runs a Plan → Train → Evaluate → Refine → Review cycle. Each round trains via a staged SFT → RL → SDFT pipeline (SFT screens the data mixture/hyperparameters, RL optimizes against task reward, and SDFT — self-distillation fine-tuning, minimizing KL divergence between the on-policy student and a privileged-context teacher distribution — consolidates the round), then the agent reads graded benchmark trajectories and applies one of five data-construction skills (Retention Anchor, Reasoning Correction, Knowledge Injection, Behavior Calibration, or task-specific "Other") plus Data Mixture Curation to build the next training mixture, subject to validation gates (format, safety/PII, dedup) and human keep/revert/deploy decisions.

Key results:

• MedAgentBench (EHR/FHIR tool use): improved from 0.883 (Kimi-K2.6 base) to 0.973 across self-evolution rounds; Cura 1T reaches 0.940 after consolidation vs. best frontier baseline Claude Opus 4.8 at 0.937 (GPT-5.5: 0.894, Gemini 3.1 Pro: 0.913).
• HealthBench Professional / Hard (rubric-graded patient care): base 0.503 / 0.222 → Cura 1T 0.662 / 0.368.
• MedXpertQA (expert multimodal reasoning, pass@1): base 0.569 → Cura 1T 0.655 overall (text 0.600, multimodal 0.722); second-best overall behind GPT-5.5 (0.675), ahead of Claude Opus 4.8 (0.628).
• AgentClinic (interactive diagnosis, tool-native harness): base 0.754 → Cura 1T 0.796 overall pass@1, matching/exceeding Claude Opus 4.8 (0.794) and GPT-5.5 (0.684).
• Out-of-domain checks (AIME 2025/2026, GPQA-Diamond, τ²-Bench airline/retail/telecom): Cura 1T stays on par with frontier models on reasoning and τ²-airline, and surpasses publicly reported scores on τ²-retail and τ²-telecom, indicating limited erosion of general capability.
• Case studies show some rounds were reverted despite raising aggregate scores because of subset-level regressions (e.g., a HealthBench "behavior correction" round improved averages but dropped Professional/Hard subset scores by 0.252/0.508 before being reverted).

Why it matters / caveats: The paper argues healthcare specialization is primarily a data-mixture curation problem rather than a training-algorithm/hyperparameter search problem, and demonstrates a repeatable agentic loop for diagnosing and fixing distinct failure modes (rubric omissions, brittle tool calls, missing knowledge, premature diagnosis) without a single generic medical-data update. Authors explicitly caveat that Cura 1T is a research model, not a validated medical service, and that benchmark performance does not establish safety for unsupervised clinical use; results are also bounded by compute/data constraints and current LoRA-based (not full-parameter) training.

Problem: LLM-based industrial recommenders (the RecGPT series deployed on Taobao) suffer from three scaling bottlenecks: stateless behavior modeling that reprocesses a user's entire history on every request, a lossy natural-language-tag-to-item bottleneck between reasoning and retrieval, and prohibitively costly explicit chain-of-thought reasoning (~2,000-3,000 tokens per request) at billion-user scale.

Method: RecGPT-V3 introduces three components. (1) A Memory Hub that performs Structured Behavior Compression (an LLM function F_φ that condenses a user's raw behavior sequence into schema-defined memory units with pattern identifiers and preference summaries) followed by Evolving Memory Curation, which incrementally updates/retains/creates memory units from new behavioral deltas rather than re-encoding full history. (2) A Hybrid-Modal Recommendation Foundation Model built on Qwen3-14B, extended with 65,536 Semantic ID (SID) tokens produced via CN-CLIP + Q-Former multimodal item embeddings and a two-level RQ-VAE residual quantizer, trained via continual pre-training (SID-grounding data + general-domain data) and instruction tuning (bidirectional SID-text translation, sid2sid sequential recommendation, general-domain tasks). (3) Latent Intent Reasoning, which compresses explicit CoT traces (from a DeepSeek-V3.2 teacher) into up to 10 learnable latent <cot> tokens via a multi-granularity masked-reconstruction curriculum (single-segment, multi-segment, full-trace), trained in two stages: Explicit-to-Implicit CoT Alignment (SFT distillation) and Reinforcement Learning from Ranking Feedback (RLRF), a GRPO-based RL stage using a dense CTRScore reward read from the production ranking model plus Constrained Reward Shaping (alignment/diversity/length gates).

Key results:

• Online A/B test vs. RecGPT-V2 (1% traffic each) on Taobao's "Guess What You Like": Item scenario +3.08% IPV, +0.98% CTR, +2.02% PV, +3.10% TC, +7.51% GMV; Feed scenario +1.28% IPV, +1.00% CTR, +0.83% PV, +0.56% DAU, +1.97% TC, +3.97% GMV.
• Memory Hub: reduces Global Planner compute by 55.8% (per-inference cost down to 33.43% of RecGPT-V2 baseline, plus 10.77% curation overhead); human evaluation shows 82.89% accuracy on behavior-pattern identification (2,514 annotations) and 95.27% accuracy on behavior-index attribution (21,268 annotations); token compression of ~94.5%/80%.
• Foundation model: with general-domain data mixing, GSM8K/MMLU/CMMLU/IFEval drop only 1.66%/2.65%/4.49%/~7pp from the Qwen3-14B backbone (e.g., GSM8K 94.31%→92.65%), whereas removing general-domain data causes collapse (GSM8K 4.70%, MMLU 0.12%, CMMLU 0.01%, IFEval 23.29%); general-domain mixing lifts category-level HR@30 by 26.2% (0.2250→0.3050).
• Latent reasoning: explicit CoT (SFT) raises HR@30 from 0.3050 to 0.3508; latent reasoning (10 tokens) matches this at 0.3462 HR@30 / 0.0649 CTR while compressing ~2,700 reasoning tokens into 10 tokens; adding RL (RLRF) reaches 0.3693 HR@30 and 0.0679 CTR, surpassing explicit CoT.
• Inference efficiency: output length drops from 2,840 to 122 tokens (95.7% reduction), giving 3.46x end-to-end speedup (1,020s→295s on a 1,000-sample benchmark) and cutting reasoning token cost by 200x.
• Overall serving resource consumption cut by 52.4% versus RecGPT-V2 (RecGPT-V3 uses ~19% of RecGPT-V1's compute).
• Hybrid text-tag + SID retrieval is complementary: HR@500 0.1503 (tag) vs. 0.1539 (SID) vs. 0.1571 (hybrid); HR@1000 0.2044 vs. 0.2144 vs. 0.2168.

Why it matters / caveats: Demonstrates that an LLM-driven recommender can be made stateful and latency-efficient enough for production at hundreds-of-millions-of-DAU scale while still improving accuracy and cutting compute, suggesting a template for combining persistent memory, joint text/discrete-ID reasoning, and latent CoT distillation in industrial LLM systems. Results are from a single company's (Taobao/RecGPT team) internal deployment and proprietary production ranking model, so generalization to other platforms is not directly demonstrated.

Problem: Standard on-policy distillation (OPD) rewards students with the raw log-probability gap between teacher and student, which also transfers the teacher's stylistic/natural-language preferences unrelated to reasoning, and the paper asks whether a better reward signal can more directly transfer the reasoning capability gained during the teacher's post-training.

Method: The authors propose On-Policy Delta Distillation (OPD2), which replaces the OPD reward log π(yt) − log πθ(yt) with a "delta signal" Rt^Δ = log π(yt) − log π*_base(yt), i.e., the difference between the reasoning-tuned teacher and its own pre-instruction-tuning base model, isolating the learning trace induced by reasoning tuning. To stabilize training they apply two reward-design tweaks: (1) centering, subtracting the expected reward over top-k=1024 student-sampled tokens to form advantages A^OPD and A^Δ, and (2) a joint sign-conditioned advantage A^{D2} that only applies the Δ-based gradient when it agrees in sign with A^OPD (zero otherwise), preventing over-training away from the teacher's signal. Training builds on TRL's GRPOTrainer (single completion per prompt, token-level rewards, no group normalization) with AdamW, temperature 0.7, 100 steps, on a 1:1:1 mixed Math/Science/Code dataset (OpenMathReasoning, OpenScienceReasoning-2, OpenCodeReasoning).

Key results:

• Qwen3-1.7B non-thinking, Math avg: OPD2 54.6 vs OPD 51.0 and ExOPD 51.4 (base model 34.8).
• Qwen3-8B non-thinking, Math avg: OPD2 71.6 vs OPD 65.9 and ExOPD 67.8; Code avg 39.9 vs 35.0/38.1; Science avg 51.6 vs 49.7/50.2.
• Qwen3-4B thinking mode Math avg improves to 74.8 (OPD2) vs baseline 73.3, while OPD (70.9) and ExOPD (72.3) actually underperform the untouched teacher-scale student.
• Qwen3-8B thinking mode HMMT25: OPD2 raises score from baseline 44.3 to 52.3, vs OPD 43.3 and ExOPD 46.3.
• Gemma4-E4B-it Math avg: OPD2 67.8 vs baseline 60.6, OPD 58.9 (degrades), ExOPD 65.3; on Code, OPD2 retains 49.5 avg vs OPD's collapse to 36.9 and ExOPD's 45.1 (baseline 55.2, none surpass it).
• Training dynamics show OPD/ExOPD peak early then plateau or degrade, while OPD2 sustains higher performance throughout the 100 training steps.

Why it matters / caveats: OPD2 gives consistent gains across model sizes (1.7B-8B), both thinking and non-thinking modes, and across model families (Qwen3 and Gemma4), and notably a 4B model trained with OPD2 can surpass an 8B model trained with OPD/ExOPD, suggesting cheaper post-training can substitute for scale. A caveat is that standard OPD and even ExOPD frequently degrade performance on already-strong thinking-mode or strong-domain (e.g., Gemma4 Code) baselines, showing on-policy distillation reward design is fragile without the delta-signal and joint-conditioning fixes proposed here.

Problem: As code review shifts from purely human reviewers to LLM-assisted and now agentic (AI agent) reviewers, there is little empirical evidence on how this transition affects review efficiency and review quality.

Method: The authors mine 1.02 million reviewed pull requests from 207 GitHub projects (May 2022–February 2026) that span three review eras defined per-project by first participation of an LLM or AI agent reviewer: Pre-LLM, LLM, and Agent. They label reviewer accounts (human, rule-based bot, traditional ML tool, LLM reviewer, or AI agent reviewer) via GitHub API plus manual documentation inspection, classify PR types with GPT-4.1-mini (validated against manual labels, Cohen's κ = 0.91), and cluster each project's monthly AI-reviewer-participation time series with soft-DTW clustering to derive AI adoption practices. Reviewer interaction sequences within PRs are modeled as Markov chains fit via expectation-maximization (model selection via BIC) to derive human-AI collaboration patterns, compared using Scott-Knott ESD tests (efficiency) and chi-square tests with Bonferroni correction (review smells, adapted from Doğan and Tüzün's taxonomy: Sleeping Review, Review Buddies, Large Changeset, Ping-Pong, Missing Context, Lack of Review). Finally, logistic regression explanatory models (36 total: 9 efficiency + 27 smell models) with likelihood-ratio chi-square tests and impact-score analysis assess which factors (collaboration pattern, PR characteristics, review activity, participant experience) explain review efficiency and quality, using AUC for goodness of fit.

Key results:

• Three AI adoption practices identified: Gradual AI Adoption (46% of 207 projects), Rapid LLM Adoption (22%), Rapid AI Agent Adoption (32%), from soft-DTW clustering with silhouette score 0.40 (3 clusters).
• Review efficiency (days/KLOC) improves from pre-LLM to agent era by 2.5 days/KLOC for Gradual AI Adoption and 4.5 days/KLOC for Rapid AI Agent Adoption; Rapid LLM Adoption shows no significant efficiency change.
• Rapid LLM Adoption's review smell rate rises significantly versus its pre-LLM baseline: +8.0 points in the LLM era and +4.4 points in the agent era, driven largely by Review Buddies (+26% in LLM era, +23.2% in agent era).
• Agent-initiated and multi-agent collaboration patterns rank R1–R2 (most efficient, Scott-Knott ESD) versus human-only R2–R3 under Gradual AI and Rapid AI Agent Adoption in the agent era; in these patterns, agents handle the inspection step (posting a summary) in 75%–95% of PRs.
• Review-smell prevalence for human-only reviews ranges 69%–76%, versus 78%–94% for AI-involved patterns; Review Buddies rises from 16% (human-only) to 60% (LLM-involved) and 53% (agent-involved) on average.
• In explanatory models, author experience reduces review delay in the Pre-LLM era (impact score -17 to -22); in the agent era, Multi-Agent and Agent-Init patterns are associated with lower delay (impact -50 to -13) under Gradual/Rapid AI Agent Adoption but with much higher delay (+200 to +605) under Rapid LLM Adoption; agent-involved patterns also raise Large Changeset likelihood (+20 to +54 impact) under Gradual and Rapid AI Agent Adoption.

Why it matters / caveats: The results argue against uniform AI-reviewer rollout: efficiency gains from agentic review (Gradual/Rapid AI Agent Adoption) do not automatically translate into better review quality, since agent-involved collaboration consistently raises review smells like Review Buddies and Large Changeset, and traditional review-process factors (author experience, PR type, review activity) remain important even as AI participation grows. The authors note their logistic regression models are explanatory/associational, not causal, and that findings may shift as AI reviewer tools continue to evolve rapidly.

Problem: Existing large-scale music/song generation models struggle to jointly deliver stable melodic development, clear lyric articulation, realistic singing, and high-fidelity acoustic rendering, because compressing music into discrete tokens for scalable sequence modeling loses the acoustic detail needed for high-fidelity waveform synthesis.

Method: Qwen-Music has three components: (1) Qwen-Music-Tokenizer, a 0.6B-parameter, 24-layer causal Conformer trained in four stages (bidirectional BestRQ self-supervised pretraining, causal adaptation, multi-task SFT with CTC lyric/Mel/chroma heads, then VQ-tokenizer training with a 32,768-entry codebook) that produces 25 Hz "Music Semantic Tokens" (375 bit/s); (2) Qwen-Music-LLM, an autoregressive model initialized from a 3B dense Qwen3.5-Omni variant that predicts these tokens from text tags/lyrics, using a novel "Melody-CoT" mechanism where the model first generates an intermediate melody-token plan (derived from an RMVPE pitch curve converted to relative-MIDI melody tokens) before generating the full song, enabling both original composition and reference-melody cover generation; (3) Qwen-Music-Render, a 1.3B-parameter Diffusion Transformer (32 blocks, cross-attending to a frozen Qwen3-Embedding-0.6B text encoder) that predicts continuous latents via conditional flow matching, decoded by a Spec-VAE (192x compression, with a new frequency-aware "Spec-SnakeBeta" activation) and corrected by a Band-Mode Refiner (ConvNeXt-1D) before inverse STFT to 48kHz stereo audio. Training uses a quality-graded pre-training curriculum (7 MOS-reward-ranked quality buckets Q1-Q7 per genre, training on Q1-Q6) over 5M+ hours of multilingual data, followed by progressive post-training (supervised initialization, offline DPO, online GSPO).

Key results:

• In blind A/B tests by 50 professional human raters, Qwen-Music wins 59.1% vs MiniMax Music 2.5+, 66.7% vs MiniMax Music 2.6, 58.3% vs Mureka V8, 55.4% vs Suno V5, and 50.3% vs Suno V5.5 (near parity).
• Ranks 3rd among leading English vocal-music systems on the external Artificial Analysis Music with Vocals Leaderboard (as "JazzCat").
• On a 600-prompt (300 EN/300 ZH) objective benchmark spanning SongBench, SongEval, and AudioBox-Aesthetic (16 dimensions total), achieves best results on 13/16 metrics — first on 6/7 SongBench dimensions and all 5/5 SongEval dimensions.
• Achieves PER (phoneme error rate) of 6.10, second-lowest among compared systems; average tag-following score of 8.44, within 0.04 of the best system.
• Genre-wise Bradley-Terry analysis: best rating in 5/8 genres (Electronic/EDM, Jazz & Blues, Punk & Hardcore, R&B/Soul, Rock).
• Cover-song generation: on an AI-generated reference set, section-level Melody-CoT achieves the lowest Melody MAE (1.48 semitones) versus Suno V5.5 (2.00), Suno V5 (1.87), and MiniMax Cover (1.89); on a real-world popular-song reference set, Qwen-Music outperforms MiniMax Cover on most SongBench, intelligibility, melody-following, and tag-following metrics (e.g., Melody MAE 1.44 vs 1.76).
• Ablations show rewritten textual conditioning (tags+lyrics) plus Text-drop CFG and Spec-VAE (vs. Levo 2 VAE) give the best DiT rendering quality; the Band-Mode Refiner improves reconstruction over Spec-VAE alone on the 546-track Song Describer Dataset (spectral, mel-scale, and stereo metrics).

Why it matters / caveats: Demonstrates that separating song generation into a compact discrete semantic-composition stage (with explicit melody planning) and a generative acoustic-rendering stage can match or beat leading commercial systems (Suno, MiniMax, Mureka) on both objective and human-preference evaluations, while unifying text-to-music and reference-based cover generation in one framework. Trade-offs are noted between the two Melody-CoT variants: section-level conditioning better preserves the reference melody while unique-section-level conditioning improves tag-following/controllability, so no single mode dominates on all axes.

Problem: RL post-training for LLM reasoning is typically studied in isolation from pretraining, leaving open how pretraining choices (model size, data) shape the returns to RL compute and what RL actually does to the inherited policy, questions that are hard to answer in standard LLM settings because pretraining corpora are uncontrolled and full pretraining-RL compute sweeps are prohibitively expensive.

Method: The authors build a controlled chess testbed mirroring the standard LLM pipeline: pretraining dense Qwen3-architecture models (5M to 1B parameters) on tokenized human Lichess Blitz/Rapid games (54B-token corpus) with next-token prediction, SFT on synthetic chain-of-thought reasoning traces (serialized move-sequence trees sampled from the pretrained model and merged by common prefixes), and RL with Group Relative Policy Optimization (GRPO) on 156K quality-filtered Lichess puzzles using a binary outcome reward. They sweep 36 pretraining-RL combinations across 10 model sizes and 11 pretraining compute budgets, fit a joint log-linear scaling law R(C_RL, N, T) = f(L_pt(N,T)) + g(N,T)(log10 C_RL − log10 C_ref) relating pretraining loss/tokens to RL reward, and analyze move-probability redistribution (ground-truth amplification, tail discovery, wrong-mode amplification) plus reasoning-trace structure across RL training. They further test transfer with a 1B OLMo-2 model pretrained on a 200B-token math corpus (70% Nemotron-CC-Math-v1, 30% Dolma3), SFT on NuminaMath-CoT, and RL on GSM8K/MATH/DeepScaler.

Key results:

• Post-RL pass@1 is strongly predicted by pretraining loss: Spearman correlation strengthens from |ρ|=0.93 to |ρ|=0.99 as reference RL compute increases from 10^16 to 10^20 FLOPs.
• RL slope B_{N,T} correlates positively with log pretraining tokens (Pearson r=+0.84 alone; joint fit with log N reaches Spearman ρ=+0.90, Pearson r=+0.92).
• On the compute-optimal frontier, RL compute share increases with total budget, e.g., for the 20M model the RL fraction rises from 5% to 32% along the frontier; overall optimal RL share grows from ~20% at 50M parameters to ~28% at 680M.
• SFT with synthetic reasoning traces improves all pass@k metrics, whereas SFT without reasoning traces improves pass@1 but not pass@8/16.
• Mechanistically, RL mostly amplifies already-preferred correct moves on easy puzzles (ground-truth amplification dominates on B1-B2) but on harder puzzles (B4-B5) it both surfaces correct moves from the low-probability tail ("tail discovery") and reinforces incorrect moves ("wrong-mode amplification"), explaining why pass@1 improves under RL while pass@16 often stays flat or degrades for larger models.
• The math-domain transfer experiment (1B OLMo-2, checkpoints from 10B-200B pretraining tokens) reproduces the same pattern: lower pretraining loss predicts higher post-RL reward (Pearson r up to 0.95-0.99 depending on RL compute level) and the RL slope increases roughly linearly with log pretraining tokens.

Why it matters / caveats: The results argue that RL is strongly initialization-limited at low compute budgets (favoring more pretraining) but that RL's compute share should grow as total budget increases, giving a quantitative basis for compute allocation between pretraining and RL; the authors caution that their empirical slope-token relationship is a local trend over the studied compute range (it can be compressed when models saturate easy benchmarks) and that RL still struggles with long-horizon search (continuations beyond 5 moves), suggesting wrong-mode amplification and shallow search are targets for improving RL beyond pass@1.

Problem: Whether the Muon optimizer, which has proven effective in large-scale pre-training, is beneficial for sparse-reward, long-horizon agentic reinforcement-learning post-training, and whether this depends on the structure of the advantage estimator.

Method: The authors run matched single-seed comparisons of Muon vs. AdamW while training a Qwen2.5-0.5B-Instruct agent on ALFWorld with verl-agent (built on veRL/HybridFlow, vLLM rollouts), applying Muon (5 Newton-Schulz iterations, momentum 0.95, Nesterov) only to the policy's hidden 2D weight matrices while keeping AdamW for embeddings/norms/other parameters. They compare three group-based RL algorithms with distinct credit-assignment structures: GRPO (episode-level advantages), GiGPO (episode-level advantage plus a step-level term from anchor-state grouping, A = A_E + ωA_S), and GraphGPO (transition-level credit from a unified state-transition graph). Learning-rate controls and a matched 2x2 GiGPO ω-ablation (step-level credit on/off) isolate whether Muon's effect is just a nominal step-size artifact.

Key results:

• Under GiGPO (Muon lr 3e-5), final-window validation success rises from 0.290 (AdamW) to 0.546, an 88% relative improvement; final checkpoint success is 0.63 vs 0.32.
• High-rate AdamW controls (1e-5 and 3e-5) lose all validation success after step 0 (flat at 0.000 from steps 5-200), so simply raising AdamW's learning rate does not reproduce the Muon gain.
• Under GRPO (3e-5), Muon improves late-window success from 0.161 to 0.268, but normalized AUC gain is small (0.08 to 0.09).
• Under GraphGPO at Muon lr 1e-5: late-window success reaches 0.901 vs. 0.810 for AdamW, normalized validation AUC rises from 0.399 to 0.556, and 0.5/0.75 success thresholds are crossed 30/60 updates earlier (steps 80/110 vs. 110/170).
• Matched GiGPO step-credit ablation: Muon improves final-window success both with step-level credit disabled (ω=0: 0.141 to 0.361, +0.220) and enabled (ω=1: 0.290 to 0.546, +0.255); enabling the step term also helps AdamW (0.141 to 0.290).

Why it matters / caveats: The results suggest Muon's usefulness in RL post-training is estimator- and learning-rate-dependent rather than uniformly positive or negative, potentially reconciling prior mixed/negative findings (e.g., Muon failing under single-turn RLVR with GRPO). The authors explicitly frame this as an exploratory, single-seed study on one 0.5B model and one environment (ALFWorld), with limited learning-rate sweep coverage and no direct measurement of gradient spectra/SNR; multi-seed, cross-task, and larger-model validation are left as open work.

Problem: Provider-built agent harnesses are too costly to continually update, and no lightweight method exists for iteratively optimizing user-constructed, task-specific harnesses to improve execution-trace quality within only a few update iterations.

Method: The paper introduces Recursive Harness Self-Improvement (RHI), which represents the harness as a prompt-level specification (agent roles/instructions, inter-agent communication "contracts," and workflow "hops") rather than executable code, and iteratively revises it via an LLM-based harness optimizer (Lharness) conditioned on accumulated pairwise preference history. At each iteration an LLM evaluator (Leval) performs a pairwise comparison between the current harness's output and its immediate predecessor's output only (a trajectory-local relaxation of the ideal population objective), and this preference history—not the evaluation prompt itself—guides the next harness update, making each step cost Θ(1) versus Θ(m²) for finite-population search methods like Meta-Harness, AutoHarness, ADAS, or AFlow. RHI is evaluated on 30 synthetic open-ended ML research tasks (10 each in quantitative finance, robotics, pharmacy), generated from real job postings (Citadel, Amazon, Genentech), where each task requires producing a full code repository with standardized deliverables (research_report.md, .png visualizations, metrics.json, index.json), judged pairwise by LLM evaluators (gpt-5.5 and opus-4.7/4.8) across multiple criteria (deliverable coverage, empirical rigor, reproducibility, presentation, engineering quality, task alignment).

Key results:

• Sonnet-4.6: after 2 RHI iterations, high+H[2] beats sonnet-4.6-max in 20/30 pairwise comparisons; normalized cost drops 7% (2.56→2.38) and cache read/write usage drops 33% (4.91→3.31) vs. the max baseline.
• Opus-4.7: a single RHI iteration (H[1]) suffices to beat both opus-4.7-xhigh and opus-4.7-max; cost is 18% lower than max (2.60→2.11) and cache read/write usage 37% lower (3.37→2.11).
• Opus-4.8: after 2 iterations, high+H[2] beats opus-4.8-xhigh, opus-4.8-ultracode, and opus-4.8-max; cost falls 23% vs. max (2.19→1.69) and 60% vs. ultracode (4.15→1.69); cache read/write usage falls 32% and 64% respectively (2.51→1.69, 4.74→1.69).
• Output-token usage stays nearly flat across RHI iterations (sonnet-4.6: 1.71–1.86x baseline; opus-4.8: 1.42–1.81x baseline) even as performance improves, indicating gains are not from longer generations.
• Ablation: applying RHI to the weaker sonnet-4.6-high does not consistently close the performance gap to the stronger opus-4.7-high/xhigh baselines, i.e., RHI complements but does not replace train-time (model) scaling.

Why it matters / caveats: RHI suggests that a cheap, few-iteration, prompt-level self-comparison procedure can outperform expensive test-time-scaling settings (and even a provider's built-in dynamic multi-agent harness, opus-4.8-ultracode) by learning task-specific "sparsity" in inter-agent communication rather than by reasoning longer, while cutting inference cost by up to 60%. The authors caution that gains stem from improved context management rather than inherent superiority over stronger models, and note the opus-4.7 output-token evidence is inconclusive since it spans only two iterations.

Problem: Conventional 3D-VAEs used to build video generation latent spaces are trained from scratch with pixel-level MSE/adversarial losses, which underemphasize semantics and spatio-temporal structure and burden downstream generators, while it remains unexplored whether frozen Video Foundation Model (VFM) representations can instead serve as compact, reconstruction-capable, generation-friendly video latents.

Method: VideoRAE extracts hierarchical intermediate features from a frozen VFM (V-JEPA 2 or VideoMAEv2), fuses them via element-wise summation, and compresses them with a lightweight 1D self-attention projector into 512 or 1024 compact latent tokens. These base tokens are mapped either to a continuous latent (linear projection, 32/64-dim bottleneck) for Diffusion Transformers or a discrete latent via a proposed Multi-Codebook SimVQ (K=4 sub-codebooks, vocabulary size 4096 each) for LLaMA-style autoregressive models. A Transformer decoder reconstructs pixels, trained with L1 + LPIPS reconstruction loss, a GAN adversarial loss, and a Representation Alignment (REPA) objective (local cosine similarity + global pooled cosine similarity to the frozen VFM teacher's final-layer features) that replaces KL regularization entirely.

Key results:

• Discrete reconstruction on UCF-101: VideoRAE(V-JEPA 2) rFVD=13 (vs. LARP-L-Long 35, SweetTok 20); on TokenBench rFVD=28 (vs. LARP 45).
• Continuous reconstruction (1024×64 config): VideoRAE(VideoMAEv2) rFVD=5 on UCF-101, competitive with WAN2.1-VAE (rFVD=4) and CogVideoX-VAE (rFVD=7), using far fewer parameters/scale.
• Class-to-video generation on UCF-101: discrete AR variant achieves SOTA gFVD=40 (vs. SweetTok 65 with 1.9B params/1280 tokens; VideoRAE uses 1024 tokens, 1.3B params); continuous DiT variant achieves gFVD=93 (vs. LeanVAE 164, LTX-VAE 161).
• ~5x faster convergence: AR model on VideoRAE reaches gFVD≈139 in 400 epochs vs. LARP tokenizer needing 2000 epochs for gFVD=136.
• 2B-scale text-to-video experiment (VideoUFO, OpenSora2 framework) replacing LTX-VAE with VideoRAE: VBench Total Score 71.26 vs. 69.35, Quality Score 76.09 vs. 74.03, Semantic Score 51.92 vs. 50.67, plus faster convergence throughout training.
• Ablations: Multi-codebook SimVQ outperforms VQ/SimVQ/MCQ alone (PSNR 29.39 vs. 25.50/28.32/29.10; gFVD 40 vs. 95/59/51); REPA reduces gFVD from 105→93 (continuous) and 67→40 (discrete); multi-scale feature aggregation (layers 8-24) beats deep-layers-only.

Why it matters / caveats: Demonstrates that frozen video foundation model representations, previously used mainly for understanding tasks, can directly replace pixel-driven 3D-VAE encoders for both continuous and discrete video generation, simplifying training (no KL loss needed) and substantially accelerating generator convergence. The paper also notes a trade-off: VideoMAEv2-based latents give better pixel reconstruction (PSNR/LPIPS) while V-JEPA 2-based latents give better generation quality (gFVD), attributed to their differing pretraining objectives (masked pixel reconstruction vs. latent-space prediction).

Problem: Existing audio-visual/omni-modal LLMs mostly handle short clips, are trained on data with scarce joint audio-visual supervision, and lack explicit temporally-grounded reasoning, causing them to degrade sharply on long, real-world audio-visual understanding tasks (e.g., movies, lectures, documentaries).

Method: The authors present Audio-Visual Flamingo (AVF), built on the OmniVinci checkpoint with a SigLip vision encoder (using a "Spatial-Scale-then-Compress" Dynamic S2 module), an AF-Whisper audio encoder (from the Audio Flamingo series, 128-channel log-mel spectrograms in 30-second sliding-window chunks), 2-layer MLP adaptors per modality, and cross-modal temporal interleaving with Constrained Rotary Time Embeddings (CRTE) feeding into a Qwen2.5-7B LLM backbone (36 layers, 16 attention heads), plus an optional streaming TTS module. They introduce Audio-Visual-Skills (AV-Skills), a ~7M-instance dataset (~4.8M QA pairs; AV-Skills-Short: 100K hours/3.8M instances up to 60s; AV-Skills-Long: 140K hours/3.2M instances up to 15 min) covering 13 reasoning skill categories (e.g., temporal reasoning, causal reasoning, hallucination detection, audio/video counting, needle-in-haystack). Training follows a three-stage curriculum: pre-training (init from OmniVinci, then short-context fine-tuning up to 16K tokens/5-min video), mid-training (long-context up to 32K tokens/15-min video, producing AVF-Instruct), and post-training via SFT plus GRPO-based RL on the new AV-Think dataset (~24K samples, avg. 635.7-word reasoning chains) implementing Temporal Audio-Visual Interleaved Chain-of-Thought (TAVIT), yielding AVF-Think. Training used 512 NVIDIA H100 GPUs with hybrid sequence parallelism (Ulysses + Ring-Attention) and FSDP.

Key results:

• MMOU (long/complex AV reasoning): AVF-Think 60.2% vs. AVF-Instruct 56.9% vs. Gemini-2.5 Pro 64.2% vs. Minicpm-o 4.5 at 46.8%.
• WorldSense: AVF-Think 51.6% vs. AVF-Instruct 50.3% vs. OmniVinci 48.2% vs. Qwen2.5-Omni 45.4%.
• DailyOmni: AVF-Think 73.9% vs. AVF-Instruct 72.4% vs. OmniVinci 66.5%.
• MMAU (avg. of sound/music/speech): AVF-Instruct 73.49 vs. Audio Flamingo 3 72.42 vs. OmniVinci 71.60.
• Video-MME: AVF-Instruct 70.7% (w/o subtitles) / 71.2% (w/ subtitles) vs. OmniVinci 67.3%/68.6% vs. NVILA 64.2%.
• ASR: best results on LibriSpeech test-clean (1.64 WER), SPGISpeech (2.8 WER), VoxPopuli (5.8 WER); competitive on TEDLIUM (3.0) and GigaSpeech (10.2).
• AVHBench hallucination (A→V | V→A): AVF-Think 79.0% | 85.9%, up from AVF-Instruct 77.0% | 81.1%.
• CMM Hallucination: AVF-Instruct 86.7% vs. Gemini 2.5 Pro 82.0%.
• MMSU: AVF-Instruct 61.5% vs. Gemini 1.5 Pro 60.7%; MMAR: AVF-Instruct 60.1% vs. OmniVinci 58.4%.

Why it matters / caveats: AVF is positioned as a fully open (data, code, model) alternative that matches or beats much larger closed/open-weight models on long-form audio-visual reasoning, and the TAVIT/AV-Think reasoning stage yields consistent gains over the instruction-tuned variant across nearly all benchmarks. The authors note limitations: AV-Skills is sourced from public datasets and open-internet videos, which may introduce source bias and overlap with prior training data; reasoning over very long, dense videos with sparse/dispersed evidence remains challenging; and current benchmarks don't fully capture open-ended real-world deployment.

Problem: AI4S capability is fragmented across domain-specific models (e.g., AlphaFold 3, ESM3), tool-augmented LLMs, and scientific language models, none of which jointly internalize heterogeneous scientific data, scientific laws, and expert knowledge inside a single model.

Method: S1-Omni uses S1-VL-32B as a shared vision-language backbone that encodes text plus native scientific objects (SMILES, CIF, FASTA protein sequences, spectra, scientific/medical images) during prefill, optionally emits scientific reasoning and a task token, and routes the resulting hidden representation to one of several task-specific decoders (shared linear readout for property regression/classification, a residue-level decoder fused with ESM2 features for protein-site prediction, a molecular diffusion decoder conditioned on SpecFormer spectral features for spectrum-to-molecule generation, a geometric decoder for protein structure, and an MMDiT+VAE decoder for scientific image generation/editing). Training is two-stage: Stage 1 trains the shared VLM end-to-end with an autoregressive cross-entropy loss over reasoning/answer/task-token sequences; Stage 2 freezes the VLM and trains each decoder independently with its own domain-native loss (numerical regression loss, classification loss, structural/geometric losses, latent flow-matching for images). Training data comes from S1-Omni-Corpus, a 200-task, 8M+ record corpus built via a 3-stage pipeline (data foundation, natural-world knowledge alignment using scientific laws/expert evidence, and validation/assembly) to attach evidence-grounded reasoning chains rather than raw statistical labels.

Key results:

• Outperforms both GPT-5.5 and Gemini-3.1-Pro on 16 of 18 TDC ADMET endpoints and on all 7 MoleculeNet tasks (e.g., BBBP ROC-AUC 0.8578, HERG ROC-AUC 0.8734, HIA_HOU ROC-AUC 0.9921).
• Across 48 property-prediction benchmarks (materials, quantum chemistry, ADMET, MoleculeNet), beats the stronger closed model on 40/48 and matches/exceeds domain specialists on 8/48.
• Spectrum-to-molecule generation on QM9S (10K samples): Acc@1 0.4569 vs. 0.4056 for DiffSpectra, MCES 1.1765 vs. 1.3273; best V&U (0.9782) and V&U&N (0.9105) novelty/validity scores among all models; lowest bond-angle error (6.13e-3) in 3D generation.
• Protein-site prediction: PPI-site AUPR 0.666 (vs. 0.540 for MPBind specialist); epitope AUPR 0.472 (vs. 0.268 for RoBep); small-molecule-binding AUROC 0.880 (vs. 0.870 for GraphBind); consistently beats GPT-5.5/Gemini-3.1-Pro on these tasks, though trails specialists on metal-binding (avg MCC 0.467 vs. LABind 0.655) and paratope prediction (F1 0.536 vs. ParaSurf 0.690).
• Ablations show structured, property-constrained reasoning supervision beats both free-form reasoning and no-reasoning baselines (material MAE 17.255 vs. 34.818 vs. 20.457), and question-only hidden-state pooling outperforms full-sequence pooling.

Why it matters / caveats: Demonstrates a practical path toward a single unified model spanning scientific understanding, prediction, and generation across molecules, materials, proteins, spectra, and images, releasing weights, code, and a corpus subset (S1-Omni-Corpus-10K) under Apache-2.0. The paper's own analysis shows S1-Omni still trails specialist domain models on many individual benchmarks (e.g., most JARVIS-DFT materials properties, metal-binding sites, paratope prediction, and OOD tail extrapolation on QM9 under distribution shift), indicating unification currently trades some peak per-task accuracy for breadth.

Problem: In RLVR (reinforcement learning with verifiable rewards), entropy-based advantage shaping cannot distinguish productive exploratory uncertainty from detrimental confusion, so entropy is an unreliable token-level correctness signal, and standard GRPO's binary trajectory-level rewards also waste zero-advantage groups where all sampled responses share the same correctness.

Method: The paper proposes Contrastive Policy Optimization (CPO), which computes a token-level "contrastive disagreement" δ_t as the log-ratio between a reference-guided posterior likelihood π_post(y_t | x, y*, y_<t) (obtained by conditioning the policy on the ground-truth reference answer via a first-person reasoning prompt) and the vanilla prior likelihood π(y_t | x, y_<t). This disagreement is theoretically shown (via Bayes' rule) to be monotonic in the token's true correctness probability g(x, y_<t, y_t), and is combined with GRPO's trajectory-level advantage A_i,t through a magnitude/direction-constrained clipping rule (Eq. 8) to form a shaped advantage Ã_i,t, which replaces A_i,t in the standard GRPO/PPO-clip objective. The paper also shows On-policy Distillation (OPD) is a special case of CPO where an external teacher model instantiates π_post, and evaluates variants (CPO-π_teacher, CPO-π_self(·|ref), CPO-π_teacher(·|ref)) unifying OPD and CPO. Training uses Qwen2.5-Math-7B and Qwen3-Base-4B as base policies, trained via GRPO with CPO's shaped advantage on the MATH dataset (7.5k problems).

Key results:

• On Qwen2.5-Math-7B, CPO reaches an average Pass@16 of 70.2% across MATH-500/AIME2024/AIME2025/AMC2023/GPQA/MMLU-PRO/KnowLogic, vs. 62.5% for GRPO and 63.9% for the best baseline (IB-reg) — a 7.7% average gain over GRPO.
• On Qwen3-Base-4B, CPO reaches 77.0% average vs. 68.5% for GRPO (8.5% gain), with notable jumps on AIME2025 (53.3% vs. 40.0% for GRPO), GPQA (78.3% vs. 56.7%) and MMLU-PRO (82.6% vs. 60.7%).
• On Qwen2.5-Math-7B, CPO improves AIME2025 to 43.3% (vs. 30.0% original/GRPO) and AMC2023 to 92.5% (vs. 82.5% GRPO).
• Compared to entropy-based baselines (Entropy-Tokens, Entropy-Adv, EM-RL-token, RL-ZVP, IB-reg), CPO outperforms all of them on both backbones' average scores, while entropy methods often show out-of-domain degradation.
• In the OPD-unification study (Figure 4), CPO-π_teacher(·|ref) (teacher conditioned on reference) achieves the strongest combined in-domain/out-of-domain average, outperforming plain OPD (with a 72B teacher) and CPO-π_self(·|ref) alone.
• Ablations (Table 3) show shaping only incorrect responses (CPOneg) best preserves in-domain accuracy but hurts out-of-domain generalization (e.g., MMLU-PRO drops to 64.8%), while shaping only correct responses (CPOpos) shows the opposite pattern; full CPO balances both for best overall results.

Why it matters / caveats: CPO gives a theoretically grounded, correctness-aligned alternative to entropy-based advantage shaping, addresses the zero-advantage problem in RLVR, and generalizes better out-of-domain than existing entropy-intervened RLVR methods. The approach requires access to reference answers to construct the contrastive posterior, and results are demonstrated only on math reasoning training (MATH dataset) with two specific backbones (Qwen2.5-Math-7B, Qwen3-Base-4B), leaving broader domain applicability (beyond math/verifiable-reward settings) untested in the paper.

Problem: Autonomous data science agents (e.g., ML-Master, AIDE) rely on expensive trial-and-error execution—ML-Master spends over 86% of its runtime on model training in MLE-Bench—making training and inference computationally costly and slow.

Method: The paper introduces the "Data Science World Model" concept and DSWorld, a framework with four components: a rule-based State Constructor that builds structured state representations (task, data state, execution environment, logs), a Router (a two-layer MLP over action embeddings from an "Harrier OSS v1 0.6B" encoder) that decides whether an action is executed via a Compiler (real execution, with a timeout that falls back to simulation) or predicted by an LLM-based Simulator (built on Qwen3-8B). Training uses a two-stage post-training recipe: SFT warm-up on a curated 8K-sample transition trajectory dataset (DSWorld-8K, combining real agent trajectories and LLM-synthesized transitions from the MMTU corpus of 60K+ tables, verified via execution), followed by "Reflective World Model Optimization" — a GRPO-based RL stage where the Simulator generates a prediction, compares it against ground truth to produce reflection feedback, refines the prediction, and jointly optimizes original and refined rollouts with a KL-regularized clipped objective.

Key results:

• Outperforms the strongest LLM baseline (o4-mini) by 35.6% on average across transition prediction tasks (Table 1), with gains of 33.4%/57.6%/71.5%/50.5% on execution success/error type/result similarity/keyword matching prediction respectively.
• Accelerates RL-based agent training by ~14x (335 min with Compiler vs. 277 min with DSWorld reported in Table 2's comparable run, and Figure 3 shows ~14x cumulative speedup) while remaining competitive on MLE-Bench Lite score (17.67 vs. 18.11 for Compiler-based training).
• Accelerates search-based agent inference (AIDE, ML-Master, AutoMLGen) by ~3-6x versus Compiler-based execution while largely preserving downstream score/medal rates (e.g., ML-Master with Qwen3-8B: Score 12.39 in 1421s with Compiler vs. 10.34 in 371s with DSWorld).
• Using DeepSeek-3.2 directly as a "simulator" (without the DSWorld framework) causes severe performance degradation due to hallucinated transitions, unlike DSWorld.
• Ablations show GRPO/Reflective optimization improves over SFT-only (Qwen3-8B-sft) by 2.36% and over Qwen3-8B-grpo by 1.3%; performance scales favorably with training data size (0.1k→6.4k samples) and backbone model size (0.6B→14B parameters).

Why it matters / caveats: By replacing costly real execution with a learned transition predictor, DSWorld could substantially cut the compute cost of training and running autonomous data science agents. The authors note limitations: it does not model external tool-call transitions, prediction quality is bounded by the underlying LLM simulator's accuracy (which can still err in complex scenarios), and synthesized training trajectories may have distribution gaps versus real-world workflows.

Problem: Outcome-only RL methods like GRPO grade only the final answer, never the reasoning trace itself, so on hard problems models learn to pad chains of thought with hedging and backtracking rather than reason better, since there is no ground-truth label for "good thinking" to train against.

Method: Agon trains two LoRA adapters (rank 16, ∼2% of base parameters) over one frozen base model (Qwen3) as divergent policies A and B, kept apart via different adapter initialization and role rotation. Each optimizer step, one adapter drafts N rollouts from the plain prompt and gets a standalone GRPO update, while the other (challenger) reads the drafter's post-reasoning solution summary (final answer withheld) and generates a paired rollout, receiving a competitive reward R(bi) = 2c(bi) + c(bi)(1−c(ai)) + λϕ(bi) — correctness plus a "conversion bonus" for succeeding where the paired opponent failed, plus a format term (λ=0.5). Roles rotate every step so both adapters train in both streams; at inference the pair deploys as the same two-stage cascade (draft, then challenge). Training uses the hard split of DeepMath-103K (difficulty 8) with group size G=N=8, one epoch over 3,000 problems, evaluated via pass@1 on a 300-problem held-out set, with transfer checks on GSM8K/MATH-500 and a second domain (CodeContests, unit-test verified).

Key results:

• On Qwen3-0.6B / DeepMath-hard: zero-shot 23%, vanilla GRPO 30%, self-refinement 32%, GRPO two-pass self-cascade 35%, untrained Mixture-of-Agents (MoA) 34%, cooperative exchange (no competition) 46%, Agon (competition + exchange) 61% pass@1 — roughly 2x GRPO and 1.8x untrained MoA at the same two-pass inference budget.
• Ablations: role rotation gives 61 vs. 52 without rotation; conversion-bonus reward form gives 61 vs. 49 for a naive margin reward; shared-opponent (no visible exchange) variant collapses to 32, consistent with the paper's proof that a group-constant conversion term is gradient-free under GRPO's group-relative normalization.
• Scaling/generality (held-out pass@1, Agon vs. vanilla GRPO): Qwen3-0.6B 61 vs. 30 (+31), Qwen3-1.7B 70 vs. 46 (+24), Qwen3-4B 71 vs. 59 (+12), Qwen3.5-2B 70 vs. 50 (+20), Gemma-4-E4B 73 vs. 58 (+15) — gains shrink but stay positive with scale; the 0.6B Agon cascade (61) beats vanilla GRPO on a Qwen3-4B model (59), ~7x larger.
• Second domain (CodeContests, Qwen3-1.7B): zero-shot 18%, vanilla GRPO 24%, cooperative 29%, Agon 34% pass@1.
• Transfer sanity checks (Qwen3-0.6B, no extra tuning): GSM8K 62→68→75 (zero-shot/GRPO/Agon), MATH-500 45→52→64.
• Trace lengths shrink alongside accuracy gains: final-stage average tokens 8.1k (GRPO) vs. 3.5k (Agon), vs. 6.9k for untrained MoA; an optional length-tiebreak reward term further cuts length to 2.6k at nearly unchanged accuracy (60% vs 61%).

Why it matters / caveats: The paper reframes "grading reasoning quality" as an implicit, relational signal supplied by a competing peer rather than a learned process reward model, achieved cheaply via dual LoRA adapters on one base rather than two full models. Stated limitations: requires a verifier and reference problems (tested only on math and a smaller code domain), needs the paired models matched in strength but behaviorally divergent (too close collapses to self-play, too far to distillation) with divergence maintained only heuristically, inference requires a two-stage cascade (added latency, cascade direction chosen post hoc), compute parity excludes the challenger's extra prefill cost, and all reported numbers come from single training runs so run-to-run variance is unquantified.