AI papers — 2026-09-15

Problem: Frontier-grade mathematical reasoning and agentic tool-use are widely assumed to require hundred-billion-parameter models trained with proprietary, closed recipes, locking compute-constrained researchers out of both training and studying such systems.

Method: ZGCM-1 is a 7.39B-parameter dense decoder-only Transformer (32 layers, hidden dim 4,096, SwiGLU intermediate 11,008, 32 query/8 KV heads, GQA, RMSNorm, RoPE with 0.33 partial rotary fraction, QK-norm) using a hybrid attention backbone that interleaves gated 128-token sliding-window attention (27 layers) with global causal attention (5 layers) at a 5:1 ratio, supporting up to 256K context. Pre-training runs on Megatron Core with the Muon optimizer (momentum 0.9, 5 Newton-Schulz steps) for matrix parameters, hybrid FP8 (E4M3/E5M2) with TWEO outlier regularization, across 0.99T (Stage 1) + 3.20T (Stage 2) general pre-training tokens tokenized with the GLM-5.1 tokenizer, followed by 600.51B-token Mid-Training with progressive context scaling (16K→64K→256K) that reformulates agentic interaction traces into MDP state-action supervision. Post-training combines SFT (4,921,933 examples; mixed think/no-think objective; two variants at 65,536 and 262,144 max sequence length) with mixed RL using GRPO (actor LR 2×10⁻⁶, dynamic sampling, KL regularization plus length penalty) over mathematics, code, and general-capability rewards.

Key results:

• Ranks first on average across 14 reasoning benchmarks at the 7B–8B scale: 97.13% MATH-500, 75.00% AIME 2026, 70.42% HMMT 2025.
• Hybrid SWA 5:1 gives 3.94× throughput speedup and 6.4× KV-cache reduction (5.0 GiB vs. 32.0 GiB full attention) at 256K context.
• Combined SWA + FP8 + Muon + Pre-LN yields ~4.2× pre-training time-to-loss speedup over a BF16/AdamW baseline (1.4× × 1.5× × 1.8× × 1.1×).
• Agentic search: 63.09% on WebWalkerQA, 19.43% on BrowseComp, 42.52% on GAIA text-only, and 62.00% accuracy on the new Binary Function Search benchmark (vs. 12% for Qwen3-8B, 0% for other 7B/8B baselines; comparable to GLM-5.1's 66% and above DeepSeek-R1's 36%/GPT-4o's 18%).
• SFT tiered pruning (removing ~50% of raw candidates) improved a six-benchmark mean from 67.78 to 68.83, with BBH gains of +10.10.
• AI4AI autonomy assessment (9 contributors, 99 ratings): experimentation/monitoring and deployment reach L4 autonomy, while architecture and learning-algorithm design remain capped at L2–L3.

Why it matters / caveats: Demonstrates that a fully open, 7.39B dense model trained with transparent, academically-tractable compute can match or approach frontier models orders of magnitude larger (Qwen3-235B-A22B, GLM-5.1) on math and agentic-search benchmarks via internal reasoning plus tool use rather than parametric memorization; the authors note the model still trails on closed-book recall tasks, exhibits verbosity/instruction-following trade-offs from heavy reasoning supervision, performs modestly on broader software-engineering/terminal benchmarks (e.g., SWE-bench Verified, Terminal-Bench 2.0), and is sensitive to tool-schema and environment-feedback brittleness.

Problem: As AI agents take on increasing responsibility in AI research and development itself, it is unclear who identifies worthwhile problems, chooses among proposed methods, and decides what to pursue next, and standalone task performance cannot answer this.

Method: Atria Dawn Preview is an agentic language model built on a 744-billion-parameter mixture-of-experts foundation model from Z.ai (2026), trained via a "Verifiable Experience Pipeline" that ties every training task to a real execution environment where the agent observes state, calls tools, produces artifacts, and receives feedback, with outcomes checked by domain-specific external signals (executable tests, experiment metrics, file/application state, geometric checks, source support); trajectory curation then removes incomplete, contradictory, duplicate, or behaviorally invalid rollouts, and failure analysis feeds back into new task construction and environment refinement. It is evaluated on 16 benchmarks against DeepSeek V4 Pro 0813, KIMI K3, Qwen 3.8 Max, GLM 5.3, GPT 5.6 sol, and Claude Opus 5.

Key results:

• Highest reported score on 5 of 16 benchmarks: AutomationBench (53.8, +4.1 over runner-up Qwen 3.8 Max), BFCL v4 (77.0, +2.9 over GLM 5.3), DeepSearchQA (96.0), BrowseComp (92.5), and CyberGym (86.5, +2.0 over GLM 5.3).
• Second-highest on SkillsBench (66.4, within 0.3 of leader), Workspace-Bench (65.0, within 0.8), and Workspace-Bench-Lite (68.2, within 1.9); GDPval 1583 and JobBench 50.3 also lead among reported comparators.
• Case studies: trains a >0.4B-parameter ViT-based weather model on >100GB of data for 45,000 steps over 69 variables; achieves a 1.46× baseline/candidate latency ratio in Gated Delta Network decode optimization (52/54 formal workloads passing); builds a working MiniOS (serial shell, disk access, persistent filesystem, interpreter) from an empty workspace in ~20 minutes.
• Development case study of Atria Dawn's own R&D: 96.5% of 739 tasks with clear responses involved AI; daily median ratio of agent actions to human prompts rose from 11.0 to 28.5 over four weeks (Aug 7–Sep 4, 2026); 33.2% of 455 completed AI-assisted tasks were rated infeasible without AI (151 tasks, 27 of 56 participants).
• Among method/parameter decisions, "AI proposes, human selects" occurred in 55.4% of cases; humans made the final choice in 85.5% of method/parameter decisions, 93.4% of goal/scope decisions, and 81.9% of acceptance-criteria decisions; AI's proposal share ranged from 16.9% (goals/scope) to 55.4% (methods/parameters) while its final-decision share stayed 6.1–9.2%.
• Of 588 tasks with a recorded difficulty, 76.0% advanced via human intervention (mostly adding context/clarification, 35.2%, or diagnosis/method change, 34.7%) versus 23.0% agent self-recovery and only 1.0% unresolved; of 627 tasks, 56.5% involved substantive output revision, with the AI performing the revision after human feedback in 75.4% of those cases.

Why it matters / caveats: The results argue for a "project-level coworker" stage of human–AI collaboration in which agents generate most options and execution while humans retain final decision authority and supply missing context/judgment, suggesting recursive self-improvement requires not just task competence but the ability to identify valuable directions and internalize experience—challenges the authors say remain unsolved; benchmark comparisons and figures are drawn from the official release website rather than independently reproduced, and several showcased capabilities (weather model, GDN speedup, CAD assemblies) are presented as illustrative case studies rather than benchmarked accuracy/validation claims.

Problem: Recursively self-improving AI discovery agents need effective exploration strategies, but online optimization of these exploration policies is bottlenecked by delayed, expensive feedback (each policy must be tried over a long, costly rollout) and a vast meta-policy search space.

Method: Dream-RSI adds a lightweight orchestration layer that makes the exploration policy explicit executable code, separate from a fixed underlying coding agent and evaluator; it cycles through (1) Online Exploration, where policy π_t drives the discovery agent (via the Gemini CLI, using Gemini-3.1-Pro or Gemini-3.7-Flash as the discovery backbone) to build a discovery tree over up to K1 decision rounds, (2) Simulator Construction, converting the recorded discovery tree into a deterministic replay world, and (3) Dreaming-based Policy Improvement, where a fixed LLM policy-development agent generates M candidate policy revisions and scores each by replaying it over all accumulated historical trees using a replay objective (Eq. 1) that combines best discovered score, a cost penalty β1·N (number of revealed nodes), and a parallelism bonus β2 based on attempts per decision round; the best-scoring revision (arg max average replay score) is redeployed online, expanding the simulator pool for the next round. The primary baseline, "Recursive Fixed Exploration," uses the same setup but keeps a fixed parallel-refining policy across rounds.

Key results:

• Algorithm engineering (Lasso path, vs. SimpleTES/sklearn/glmnet): with Gemini-3.1-Pro, Dream-RSI cuts average held-out runtime from 3587.1ms to 2931.0ms using only 317 discovery-agent calls vs. 550 for fixed exploration; with Gemini-3.7-Flash, runtime drops from 2516.7ms to 2350.6ms using 1879 vs. 3200 calls; achieves up to ~162× fewer agent calls than SimpleTES (51,200 generations) while beating sklearn/glmnet on all 6 held-out datasets.
• Math optimization (Sum-Difference, Autocorrelation, Circle Packing, vs. AlphaEvolve/AlphaEvolveV2/OpenEvolve/CodeEvolve/ShinkaEvolve/TTS-Discovery/ThetaEvolve/EvoX/SimpleTES): Dream-RSI reaches Sum-Diff 1.145427 (best among compared methods), Circle Packing 2.635983 (matches best reported), and Autocorrelation 1.456375, all using fewer than 1,000 generations vs. SimpleTES's 51,200 (over 50× budget savings).
• GPU kernel engineering (KernelBench: VGG16, LayerNorm, ConvDiv, ConvMax, Gemini-3.1-Pro): reaches comparable performance with 2.43× (VGG16) and 1.79× (LayerNorm) fewer generations, and achieves 2.09× (ConvDiv) and 1.44× (ConvMax) higher performance under matched budgets vs. Recursive Fixed Exploration.
• Ablation on ConvDiv shows that treating history as an interactive replay simulator outperforms injecting it merely as semantic textual guidance into prompts, for both fixed and Dream-RSI policies.
• Exploration-behavior analysis on ConvDiv shows the learned policy adaptively contracts evaluated attempts per round (e.g., 110 → 50) as performance improves, then re-expands effort when progress plateaus.

Why it matters / caveats: By treating a completed discovery history as a cost-free "replay simulator" (analogous to Dreamer-style world models), Dream-RSI turns costly, delayed meta-policy evaluation into fast off-policy "dreaming," enabling exploration strategies themselves to recursively self-improve without extra online trials. Caveats: replay evaluation only reflects previously observed branches/outcomes (it cannot generate genuinely new candidates), the approach still relies on a fixed underlying discovery agent/evaluator and an LLM-based policy-development agent, and some results (e.g., Autocorrelation) remain below the best specialized baseline (SimpleTES) despite far lower compute.

Problem: Existing video generation models (Sora, Veo, Wan, Seedance) and the authors' own prior Vidu S1 follow an offline or narrowly-scoped streaming paradigm, limited to 540p talking-head avatars with fixed references and no support for real-time editing of an incoming video stream or spatial (stereoscopic) output.

Method: Vidu S2-Avatar is an audio-visual joint Diffusion Transformer trained with a bidirectional-to-causal pipeline (segment-wise conditioned I2V/R2V pretraining, block-wise causal attention with hybrid Teacher/Diffusion Forcing) and a new Self-Replay Forcing (SRF) stage — an on-policy DMD method that re-noises a detached student rollout per Diffusion Forcing and replays it in a single gradient-enabled causal pass so DMD and perceptual losses backpropagate across block boundaries; diffusion-based DPO (bidirectional stage) and Streaming NFT (causal stage) provide further preference/reward optimization, and a one-step latent-space super-resolution Refiner (using asymmetric TwinCache-style noise levels) lifts 540p output to 720p at 25–42 FPS. Vidu S2-Editing is a separate DiT trained with the same bidirectional-then-causal-SRF recipe but with frame-aligned attention (each target frame attends only to the temporally aligned source frame, reference tokens visible to all frames) for style transfer, virtual try-on, subject replacement, and background replacement; training data (800K clips, split into four disjoint 200K-clip task subsets) is built via reconstruction-based V2V models (e.g., using NormalCrafter-estimated surface normals) plus several external editors (Bernini, SCAIL-2, Wan2.1 VACE, SAMA-14B, CoinVE-Edit) with post-filtering/comparative selection. Inference uses a layer-wise hybrid of SageAttention/SpargeAttention/Sparse-Linear Attention, per-block W8A8 GEMM quantization, Triton/CUDA kernel fusion and CUDA Graphs, and Ulysses-style multi-GPU context parallelism with quantized inter-GPU communication and shared-timeline scheduling of the VAE encoder/backbone/Refiner/VAE decoder. Real-time spatial video is produced by converting monocular streams to stereo via per-frame depth estimation and disparity-based warping (with hole-filling and temporal depth stabilization), applied either after generation/editing or jointly on stereoscopic input pairs.

Key results:

• On StreamAV-Bench, Vidu S2-Avatar achieves the best score on every reported metric among 13 baselines (e.g., VA .687, VQ 3.370, AVSync .353, SC .998, BC .993), including gains over Self-Forcing, LongLive, PixVerse R1, and HeyGen-class systems.
• On Sparkle-Bench, Vidu S2-Editing attains the highest Overall score (3.74) versus offline (Bernini-R 14B: 3.50) and streaming (Decart-Lucy2.5: 3.67) baselines.
• On joint OpenVE–RefVIE evaluation, Vidu S2-Editing scores Joint Overall 4.26, beating the strongest offline baseline Bernini-R 14B (3.92) by 0.34 and streaming baseline Decart-Lucy2.5's RefVIE Overall (3.71) by 0.07.
• On the ViViD unpaired virtual try-on test set, Vidu S2-Editing achieves VFIDI 9.9515, far below CatV2TON (19.5131) and ViViD (21.8032).
• In internal GSB human preference tests, Vidu S2-Avatar is preferred over Runway Character GWM-1 in 85.7% of overall-quality comparisons and over PixVerse Image Avatar and HeyGen in 100%; Vidu S2-Editing shows mean consistency scores of 3.56 vs 2.59 (Decart-Lucy2.5) and 1.67 (XMax-X2.0) on a 150-case internal editing benchmark.

Why it matters / caveats: The paper argues real-time interactive video demand (scaling with user count) exceeds offline-video demand (which is diluted by replay/sharing across viewers), positioning streaming generation/editing as a key industry direction; caveats include that internal-benchmark GSB comparisons rely on the authors' own 20 trained evaluators and undisclosed sample sizes for some baselines, spatial video generation is explicitly described as an exploratory feasibility study still requiring higher resolution and lower latency for practical VR headset deployment, and some comparison tables mark competitor metrics as unavailable ("–") rather than reporting them.

Problem: Building a single physical foundation model that unifies embodied scene understanding, action generation, and future-state prediction within one "physical loop" of observation, interaction, and environmental change, rather than relying on separate specialized systems.

Method: Built on Qwen3-VL-Instruct (8B), the vocabulary is extended with action and visual tokens (V = Vlang ∪ Vact ∪ Vvis) so language, end-effector motion, and visual-state targets are all generated autoregressively through the same backbone, token embedding, and output head under a single masked next-token-prediction loss. End-effector trajectories (16-step chunks, 10D: 3D translation + 6D rotation + gripper) are tokenized with an ActionPiece tokenizer trained on 28.7M trajectory segments (459.2M timesteps) into a 512-token vocabulary, encoding each wrist trajectory as 32 discrete tokens, with a preceding action chunk given as motion context for "homogeneous action continuation." Future RGB, depth, and robot/human masks are jointly tokenized by a shared VQ-VAE (128×128 input, codebook K=16,384, 16×16 grid) and spatially interleaved (RGB–depth–mask per location) into a 770-token sequence generated by the same LM head. Training uses ms-swift with Megatron-Core, two stages (physical-aware pre-training then embodied SFT, one epoch each), distributed Adam (β1=0.9, β2=0.95, wd=0.1), peak LR 2×10⁻⁵ with 3% warmup and cosine decay, 32,768 max sequence length with packing, ~2K samples/global batch, bf16; pre-training supervision (24.3M perception + 31.2M human action + 26.8M future-state + 14.9M general samples) is derived entirely from ~30,000 hours of human interaction video (Xperience-10M, Egocentric-10K, Ego4D, EgoVerse, EgoDex, EgoLife, Ego-Exo4D, plus in-house PhysBrain-Human and PhysBrain-Ego360), while SFT adds 6.61M understanding + 5.4M action (2,620h real-robot/sim across 17 sources + 500h human motion) + 1.2M future-state + 1M general samples from human, robot, and simulated data.

Key results:

• Across 28 embodied-understanding benchmarks, the 8B model achieves an overall average of 72.5, the top open-source score, versus GPT-6-Astra 73.3, Gemini 3.6 Flash 73.0, Claude Opus 5 67.9, and best open-source baseline Hy-Embodied-VLM-1.0 66.0 (surpassed by 6.5 points).
• Ranks first among open-source models on 14 of 28 benchmarks and in the top two on 24 of 28; outperforms its base model Qwen3-VL-Instruct (8B) on all 28 benchmarks.
• On general multimodal benchmarks (MME, MMStar, RealWorldQA, VideoMME, MVBench, POPE, AI2D, ChartQA, DocVQA, TextVQA, V, ScreenSpot), performance stays comparable to the Qwen3-VL-Instruct (8B) baseline (e.g., MMStar 65.60 vs 64.99, POPE F1 89.49 vs 88.40, V 87.96 vs 83.77), showing general capability is largely retained after embodied adaptation.
• Qualitative results show the post-trained model producing 16-step end-effector trajectories (via ActionPiece decoding) that follow reference motion direction/shape on held-out episodes, including in-distribution and out-of-distribution (RoboDojo) scenes, and generating spatially coherent future RGB/depth/robot-mask predictions across diverse embodiments.

Why it matters / caveats: Demonstrates that a compact 8B model trained solely with human-interaction-video-derived embodied supervision (no teleoperated/simulated robot data at pre-training time) plus a modest SFT mixture can approach proprietary VLM performance on embodied benchmarks while unifying understanding, action generation, and future-state prediction in one autoregressive architecture. Caveats: no globally canonicalized action coordinate frame is used across embodiments (each source keeps native axes, relying on action-history context for continuation), OOD trajectory predictions show visible positional deviations, and the paper reports no closed-loop/real-robot execution success rates—only offline/qualitative trajectory and future-frame comparisons against ground truth.

Problem: The KV cache in Transformer decoding grows linearly with sequence length and dominates memory/bandwidth costs, and even efficient variants like grouped-query attention (GQA) still must store both a key and a value stream at every step.

Method: Grouped Value Attention (GVA) builds on GQA grouping (H query heads sharing G value heads) but caches only grouped values and reconstructs per-query-head content keys via a learned linear map, Kh = Vg(h)Mh, which at inference is absorbed into the query so no content-key tensor must be materialized; a small shared decoupled RoPE channel (width dr ∈ {16, 24}, following DeepSeek MLA's decoupled-RoPE design) supplies positional information via a separately cached, shared positional key. M is initialized so reconstructed keys match query RMS scale (σM = σQ/(σV√din)), optionally paired with query RMSNorm. Models are 350M-parameter decoder-only Transformers trained from scratch on a 30B-token FineWeb-Edu sample, using ZClip for gradient-spike mitigation, compared against matched GQA and DeepSeek-style MLA baselines trained with the same recipe.

Key results:

• Decoupled-RoPE GVA reduces persistent cache scalars by approximately 45–47% relative to matched GQA (47% at dr=16, 45% at dr=24), versus an idealized 50% for value-only reconstruction without positional slice.
• 16-dimensional positional variant (dr=16) reaches 44.35 average zero-shot accuracy across five tasks (HellaSwag, WinoGrande, OpenBookQA, ARC-Easy, ARC-Challenge), versus 44.36 for GQA and 43.88 for MLA (scores averaged over three seeds).
• dr=24 variant reaches 44.29 average accuracy, slightly behind dr=16.
• Scale-matched GVA with query RMSNorm is the strongest GVA row at 44.41 average accuracy, close to GQA's 44.36.
• A naive "shared KV" ablation (K=V, exactly halving GQA's cache) fails to recover GQA's training loss throughout training, motivating the dedicated-value-plus-reconstruction design.

Why it matters / caveats: GVA offers a substantially smaller persistent KV cache representation at benchmark accuracy nearly matching GQA, which could reduce memory/bandwidth bottlenecks in long-context decoding. However, the paper explicitly does not report measured latency, decode throughput, or peak serving memory — custom decoding kernels are developed but still being evaluated, with results and open-source release "planned soon"; findings are limited to a single 350M-parameter scale, one 30B-token data mix, and untested longer contexts or broader RoPE-width sweeps.

Problem: Video diffusion models are stochastic and hard to control, and combining them with agentic visual creation (references, editable 3D scenes, executable games) requires a general-purpose video model that can unify fragmented task-specific pipelines while maintaining long-horizon appearance, motion, and audio consistency.

Method: LynnReal-Omni is a 32B-parameter shared multimodal diffusion transformer (50 transformer blocks, residual width 5,376, 56 attention heads of dimension 128, feed-forward width 14,336, 24-channel video latents with 1×2×2 patches, 32-channel audio stream, 5,120-dim text conditioning) built on the MiniMax-H3 backbone, unifying T2V, image-conditioned generation, reference-guided generation, structural control, editing, restoration, and long-video generation via a native task representation (modality tags, row indices, 3D rotary positions, per-row noise times). A 27B "Flash" variant retains 42 of 50 blocks, uses frame-wise spatial token compression (stride-2 subsampling to ~1/4 tokens) plus W4A8 (INT4 weights/FP8 activations) quantization and operator fusion. Both variants are trained with flow matching (shifted logistic-normal noise schedule, separate video/audio clean-time clocks) and distilled via low-rank/full trajectory distribution matching (TDM, building on DMD2/Reward Forcing) to 4-step (Standard) and 3-step (Flash) inference; long video generation uses fixed 17-frame chunks with a shared boundary frame and a bounded temporal-context window (≤2 full-resolution latent frames). A lightweight VAE decoder is separately distilled from the 36-block teacher decoder down to 26 blocks (hidden dim 2,048, MLP ratio 4) using pixel/temporal/feature/perceptual/posterior-consistency losses. Training data comes from a custom pipeline (TransNetV2 shot detection, PP-OCR cleaning, Qwen3.5-122B-A10B scene/subject annotation, Detectron2+ViTDet pose tracking, MOSS-Transcribe-Diarize 0.9B and Qwen3-Omni-Thinking audio annotation) yielding curated multi-shot audiovisual clips (≤60s, ~0.6% of original raw footage retained).

Key results:

• On the new MSAVP benchmark (100 prompts, 20 metrics, 720p/15s outputs), LynnReal-Omni scores 77.76 overall in T2V (vs. Seedance 2.0's 79.39 and MiniMax-H3's 79.27) and 79.20 in I2V (vs. MiniMax-H3's 80.65), leading I2V Prompt Fidelity and scoring strongest in entity fidelity, world-state consistency, aesthetic and imaging quality.
• Warm generation+decoding of a 22-frame 540p video on one H100 takes 843 ms for Standard (4 NFE) and 377 ms for Flash (3 NFE); operator fusion alone cuts generation wall time by 43.6% (Standard) and 31.6% (Flash).
• Component ablation: disabling Flash's token compression raises DiT time from 263 to 453 ms; swapping the 36-block decoder for the 26-block lightweight decoder reduces decoding from 469 to 340 ms.
• At native 768p, 15-second generation takes 61.49 s (Standard) / 20.76 s (Flash) DiT+decoder time on one H100, scaling to 122.9 s / 40.4 s wall-clock generation.
• Lightweight-decoder temporal-difference MAE is nearly identical to the official decoder on a motion clip (0.006015 vs 0.006012) but slightly worse on a clay clip (0.005816 vs 0.005926).

Why it matters / caveats: The paper positions LynnReal-Omni as a step toward real-time, controllable "world model" style video generation usable inside agentic pipelines (agent-built 3D scenes/game recordings feeding video appearance), rather than a strict quality leader — it trails top offline systems (Seedance 2.0, MiniMax-H3) slightly on MSAVP while running far faster. The authors explicitly caveat that current warm 540p measurements don't establish equivalent native 768p speed or true live-interaction latency, that image/weather edits synthesize plausible detail rather than recovering ground truth, and that independent frame-wise video repair lacks explicit cross-frame consistency guarantees.

Problem: Digital agents must adapt to new environments whose interfaces, tools, and failure modes are not captured by pretrained models, and existing adaptation methods either require costly additional training or fail to distill reusable causal knowledge from experience.

Method: RSIAgent is a training-free multi-agent framework with three roles—a curriculum agent (proposes exploration tasks), a code-as-policy actor agent (executes actions and maintains an evolvable persistent memory), and an independent verifier agent (grounds outcomes in environment feedback)—that runs a two-stage broad-then-deep exploration strategy: Broad Recursive Self-exploration (BRS) generates up to four tasks per iteration executed in parallel over a nominal budget of eight exploration projects to build broad environment coverage, followed by Deep Recursive Self-exploration (DRS), a sequential recursive loop that increases task difficulty to expose hidden constraints and boundary conditions until the curriculum agent judges no further useful practice remains; the resulting frozen memory is then reused at test time with the curriculum agent and memory updates disabled. In experiments, GLM-5.3 serves as the actor agent and Kimi-K3 as the verifier and curriculum agent.

Key results:

• On OSWorld 2.0 (0808 offline, 82 tasks), RSI improves partial score from 71.97 to 78.98 and binary accuracy from 37.80% to 42.68%.
• On Agents' Last Exam (Near-term, 67 tasks), partial score rises from 83.75 to 84.82 and binary accuracy from 49.25% to 50.75%.
• RSIAgent (78.98 partial on OSWorld, 84.82 on ALE) exceeds reported GPT-6 Astra scores (72.60 and 82.26) by 6.38 and 2.56 points respectively, and also surpasses Claude Opus 5 (70.19 and 79.54) on both benchmarks.
• Ablation on 4 OSWorld tasks: Full RSI (BRS+DRS) averages 74.54% partial score vs. 65.52% for BRS-only, 56.50% for DRS-only, with DRS-only falling below the no-RSI baseline on 2 of 4 tasks (T085, T089).
• On 40 sampled GameCraft-Bench tasks across four game generators, RSIAgent raises Overall quality in every setting (e.g., Kimi-K2.6 generator: 31.28 baseline → 46.37 with full RSIAgent), consistently outperforming the Play2Code baseline, which can even degrade already high-quality games from strong generators.
• Single-task RSI-round tracking on OSWorld tasks T044, T049, T065 shows partial scores reaching 100%, 80%, and 100% respectively by step 8 (from a lower baseline at step 0).

Why it matters / caveats: The method shows that agent-level, training-free self-improvement can let open-source models match or exceed frontier closed-source models on realistic computer-use and game-development tasks, narrowing the open/closed capability gap without parameter updates. The authors note limitations including substantial test-time exploration compute cost, sensitivity to exploration budgets/stopping policies, potential for verifier misjudgments to propagate into memory, and failure modes (insufficiently targeted exploration, incomplete verification, unreliable memory consolidation) that can let incorrect rules persist and affect downstream behavior.

Problem: Foundation models and scientific agents excel at solving problems within a fixed, human-supplied research structure (question, representation, objective, tools, evaluator) but lack the ability to revise that structure itself — i.e., to discover which unknowns are worth pursuing, reformulate problems, build new representations, and design interventions when the given framing is inadequate.

Method: The paper formulates Discovery Foundation Models (DFMs) as a model-system category defined by seven coupled capabilities (problem discovery, formulation, representation construction, hypothesis formation, intervention, evidence-grounded revision, and continual cross-task Discovery Skill improvement) operating over a revisable research state S_t = (P_t, R_t, H_t, E_t, X_t, B_t, M_t). It instantiates this with Zetema, a system organization combining explicit research-state dynamics, a Research World Model for experimental gating/verification (eligibility rule V_j(a) ≥ τ_j), Discovery Skill Memory (skills stored as trigger-operation-effect-validation tuples), and a Dry-Lab/Wet-Lab grounding loop. A compositional training objective L_DFM sums seven loss terms (state-conditioned action imitation, state-transition prediction, pairwise preference optimization, multi-criterion process verification, Research World Model negative log-likelihood, KL-regularized policy-gradient RL from scientific feedback, and contrastive Discovery Skill retrieval), trained via a staged offline warm-start → verifier/world-model training → preference refinement → interactive RL → validated skill consolidation pipeline.

Key results:

• No large-scale quantitative benchmark results for Zetema/DFM itself are reported; the paper is primarily a conceptual/framework contribution (definitions, formalism, training/evaluation protocols).
• Empirical grounding comes from a real case study, GALILEO (an embodied AI-scientist for therapeutic peptide discovery), reused from prior work: the LRRC8C branch (GALILEO-LRC) achieved selective LRRC8A/LRRC8C current blockade with an organoid IC50 of 18.922 μM.
• A second branch (GALILEO-SLC) showed mitochondrial localization (SLC25A1 pathway) with an organoid IC50 of 0.736 μM.
• Across five rounds of wet-lab feedback, weak motif organizations were pruned (rounds 2–3), previously abandoned motif organizations were reopened under revised hypotheses (round 4), and productive modules were consolidated (round 5) into a reusable design rule termed the Amphiphilic Balance Grammar (ABG), which was reportedly transferred to external peptide-design workflows to improve geometry/energetic profiles.

Why it matters / caveats: The paper argues discovery should be treated as a learnable, trainable, and evaluable capability rather than judged only by final-answer accuracy, but it explicitly cautions that GALILEO demonstrates only a narrow, domain-specific instance of the framework and "should not be interpreted as evidence that the full general-purpose DFM problem has already been solved" — broader cross-domain discovery transfer remains an open problem, and the core DFM/Zetema/training formalism is presented without corresponding experimental validation.

Problem: Video-understanding benchmarks rely mainly on question answering, which can be solved from answer priors or a single frame without demonstrating that a model truly tracked a scene's spatial layout and temporal dynamics.

Method: BVB (Blender-VideoBench) asks multimodal agents to reconstruct real-world egocentric indoor videos from VSI-Bench (built on ARKitScenes, ScanNet, ScanNet++; 288 test scenes, 5,130 spatiotemporal questions) as animated Blender scenes, built only from primitives (cube, plane, cylinder, cone, uv_sphere, torus) with no external asset libraries, geometry nodes, or textures. Each agent operates through a lightweight harness, Mini-BVB, with exactly two actions (bash for Blender/Python execution, frames for requesting video frames) inside a fresh Docker sandbox (Blender 4.2, FFmpeg, no network, 2 CPUs, 4GB) under a shared per-scene cost cap ($3). Reconstructions are scored on two axes: Dual VQA (a gpt-5.4-mini VLM judge answers VSI-Bench questions on 16 uniformly sampled frames from source and reconstruction, scoring retention only on source-correct questions) and Latent Similarity (frozen, non-fine-tuned V-JEPA 2.1 ViT-G embeddings compared over 64 rendered EEVEE frames vs. 64 source frames, split into Layout and Motion); the two axes are combined via a square-root mean (Overall) rather than an arithmetic mean, to penalize imbalance between axes.

Key results:

• 51 configurations across 10 model families (OpenAI GPT-5.x/GPT-6 Astra, xAI Grok, Anthropic Claude, Google Gemini, Meta Muse Spark, Zhipu GLM, Alibaba Qwen, Moonshot Kimi, MiniMax, ByteDance Seed) were evaluated; GPT-6-Astra-high ranks first at 70.07 Overall (DV 49.0/53.7% retention, LS 88.6), followed by GPT-5.6-Sol-xhigh (67.49) and Grok-4.6-xhigh (67.17); GLM-5.3-Flash-xhigh is the top open-weight configuration (rank 12, 63.96 Overall).
• Across all configurations, Overall ranges 47.50–70.07, DV ranges 38.6–53.7%, and LS ranges 57.2–88.6; the best model retains only 53.7% of source-correct spatiotemporal facts (981 of 1,827 judge-correct source questions preserved) despite reaching 88.6 LS.
• Task-level retention varies sharply: object size (63.0% mean) and route planning (58.5%) are best retained, while appearance order (16.1%) and object count (29.3%) are worst; per-task spread ranges from object count (10.5–48.5%) to relative direction (44.9–57.4%).
• A blind study with 15 human raters over 5 configurations and 9 scenes each produced a mean ranking that matches the Overall order exactly (Spearman ρ=1.00); human preference correlates strongly with Latent Similarity (scene-level ρ=0.83) but weakly with Dual VQA (ρ=0.11).
• Additional reasoning effort (none→low→medium→high→xhigh) generally raises LS but leaves DV flat or lowers it; longer runtime does not reliably predict higher Overall score.
• Mean per-scene spend ranges from $0.024 to $2.157 (about 90x); GPT-5.6-Sol-xhigh reaches 96% of the top Overall score at 62% of GPT-6-Astra's cost, and GLM-5.3-Flash-xhigh reaches 91% of the top score for $0.024/scene; evaluating one configuration on all 288 scenes costs about $360.

Why it matters / caveats: The results show current agentic coding models build reconstructions that look visually convincing (high Latent Similarity) but fail to preserve nearly half of the verifiable spatiotemporal facts, indicating a persistent gap between "looking right" and "being right" that is not closed by extra reasoning effort or spend; the benchmark is not saturated and separates models across all price tiers, and human raters' agreement with the automated Overall metric supports its validity as a proxy for video-understanding quality.

Problem: The paper tests Orthrus's claim that its intra-model consensus mechanism makes hybrid autoregressive-diffusion speculative decoding strictly lossless (i.e., token-trajectory-identical to the frozen autoregressive backbone).

Method: The authors independently reproduce Orthrus on the Qwen/Qwen3-1.7B backbone, training their own "Orthrus-1.7B-final" diffusion view via distillation: prompts from a mixture of public HuggingFace datasets were fed to Qwen3-1.7B under greedy decoding to build a 4,113,358-sample teacher-generated corpus (prompts 50-1,000 characters), then trained for 1 epoch on 8 NVIDIA H100 GPUs (learning rate 2e-4, batch size 10, cross-entropy loss, block size 8, 32 blocks, max sequence length 3,072). They compare this model and the original released Orthrus-Qwen3-1.7B checkpoint against the Qwen3-1.7B autoregressive reference using greedy decoding (do_sample=False, temperature=0.0, max_new_tokens=128) across 1,190 prompts spanning 12 domains, measuring exact trajectory match rate, Tokens Per Forward (TPF), response-conditional perplexity, and lm-eval-harness benchmark scores (GSM8K, HumanEval, IFEval), under both BF16 and FP32 precision.

Key results:

• Under BF16, exact trajectory matching occurred in only 45% ± 0.03 of cases for the authors' checkpoint and 43% ± 0.03 for the independently trained model (diverging trajectory rates of 0.55 and 0.57 respectively), out of 1,190 prompts.
• Domain-level match rates varied widely under BF16, from 0.11-0.14 (poetry-en/poetry-ru) up to 0.88 (gec-en) for both models.
• Logistic regression showed a strong negative association between response-conditional perplexity and exact matching: β1 = -8.10 (95% CI [-10.50, -5.71], p=3×10⁻¹¹) for the authors' checkpoint and β1 = -10.92 (95% CI [-13.60, -8.24], p=1.3×10⁻¹⁵) for the independent model; mean PPL was ~1.10-1.11 for matching trajectories vs. ~1.28 for diverging ones.
• The independently trained model achieved higher TPF than the released checkpoint in 10 of 12 domains (e.g., gec-ru: 3.23 vs. 2.48; math-ru: 4.35 vs. 4.04), while the authors' checkpoint was better in 2 domains (e.g., math: 8.08 vs. 4.99).
• Under FP32, both Orthrus variants achieved exact trajectory matching on all 1,190 prompts (100%, 0% divergence), versus substantial divergence in BF16.
• On lm-eval-harness, both Orthrus models had point estimates matching or exceeding the Qwen3-1.7B baseline (e.g., Orthrus-1.7B-final GSM8K exact match 0.4146 vs. Qwen3 baseline 0.4003; HumanEval pass@1 0.2181; IFEval prompt-level strict accuracy 0.1830 vs. 0.1682), with no systematic degradation despite BF16 trajectory divergence.

Why it matters / caveats: The results show that "losslessness" in speculative decoding is not an inherent algorithmic property but depends critically on numerical precision (BF16 vs. FP32), so claims of lossless acceleration should specify both the operational equivalence criterion and the numerical precision under which it is measured; the authors note that trajectory divergence does not necessarily hurt (and can even coincide with slightly higher) downstream benchmark scores, so benchmark-level equivalence alone cannot establish exact inference equivalence, and differences reported are not claimed to be statistically significant improvements.

Problem: Interactive video world models face a trade-off between preserving broad off-screen scene context under camera motion and synthesizing high-fidelity, low-latency perspective video, since perspective-only models must store off-screen content via memory mechanisms while full-sphere or explicit-3D approaches waste computation rendering unseen directions at display quality.

Method: AlayaVista expands a single input image into a 360° ERP panorama with the pretrained HY-World 2.0 panorama expansion model, then evolves it as a camera-conditioned "panoramic state" using an ERP-aware diffusion transformer initialized from Wan2.2-TI2V-5B (48-channel WanVideoVAE latents), adapted with SpheRoPE-style spherical rotary positional encoding, Unified Camera Positional Encoding (UCPE) for panoramic camera conditioning, and chunk-causal attention (4 latent slices/chunk, ~16 RGB frames at 16 FPS) with KV caching. A learned latent viewport renderer (factorized video transformer + local resampling adapter) maps the panoramic latent to low-resolution perspective latents (960×480 ERP → 512×288 perspective, 30×60→18×32 latent grid) without full RGB decoding, and a perspective video refiner (LTX-2-inspired deterministic latent upsampler doubling resolution to 1024×576, plus a Wan2.2-TI2V-5B-initialized carrier-conditioned generative refiner) restores detail. The full pipeline uses staged training: bidirectional panoramic adaptation → chunk-autoregressive training → few-step distillation via consistency distillation plus Self-Forcing++ and distribution matching distillation (DMD), separately trained render module, and a three-substep refiner training, with a deployed four-step causal inference schedule. Training data comes from the newly constructed MUGEN dataset (1,318 hours of ≥4K one-minute real-world panoramic clips from 6,446 YouTube source videos, annotated via ViPE for camera trajectories/depth/instance masks, plus hierarchical AlayaWorld-style captions) and its 300-hour curated MUGEN-HQ subset, combined with the panoramic subset of Sekai2.

Key results:

• On 200 MUGEN-HQ evaluation cases (81 frames, 1024×576), AlayaVista achieves best SSIM (0.4616), LPIPS (0.5321), PSNR (14.10), VBench++ Consistency (0.9240) and Quality (0.5579) versus MoVerse and HY-World 2.0 baselines.
• Lowest rotation error (RotErr 2.132) among the three methods (MoVerse 2.887, HY-World 2.0 3.169), indicating more accurate camera-orientation tracking.
• Translation error (TransErr 0.03312) is better than HY-World 2.0 (0.03885) but worse than MoVerse (0.02746), attributed to MoVerse's explicit 3D Gaussian scaffold providing stronger geometric guidance.
• Lower Dynamic score (0.9200 vs. MoVerse's 1.0000 and HY-World 2.0's 0.9850), suggesting attenuated local motion from latent rendering/refinement — a possible motion-vs-consistency trade-off.
• MUGEN dataset itself: filtered down from 9,544 candidate YouTube videos → 2,893 hours raw footage → 137,209 one-minute clips (~2,287 hours) → 1,318 hours after quality/trajectory filtering.

Why it matters / caveats: The results support treating panoramic video latents as an internal "panoramic state" rather than a final output, letting high-fidelity synthesis be concentrated only on the queried viewport rather than the full sphere or an explicit 3D reconstruction — a middle ground between perspective-only and explicit-3D world models. The authors caveat that a camera-centered panoramic state does not guarantee persistent spatial memory under large camera translations or strict geometric consistency in highly dynamic scenes, and that errors from the initial panorama expansion can propagate through later generation stages; the pipeline is also not trained end-to-end (stages are trained separately with frozen upstream components).

Problem: Streaming audio-visual models can lock in an early, visually-suggested interpretation as fact before the confirming or contradicting audio evidence has finished arriving, a failure the paper calls "premature cross-modal commitment."

Method: OST augments a frozen Qwen3-Omni-30B-A3B-Instruct backbone with a lightweight LoRA policy plus a forecaster, verifier, and answer gate that operate on a six-field "Omni-State" (visual_evidence, audio_state, audio_evidence, conflict, forecast, sufficiency), processing perception every 1s in 4s decision chunks; each unresolved interpretation is stored as a claim with a verifying modality, a future evidence window, and dependency links in an acyclic provenance graph, so that when evidence arrives the modality-specific verifier (CONFIRMED/REFUTED/UNRESOLVED with a contradiction margin) can propagate a refutation through reliability scores to attenuate descendant claims and trigger verdict-conditioned logit-guided rewriting. Memory uses separate audio/visual token budgets merged into a four-way pyramid (4s → 16s → 64s → long-term root), and training proceeds in stages: cross-entropy plus preference training (DPO-style) for the forecaster on GEMINI-3.6-FLASH-annotated fact-table data, LoRA SFT on corrected Omni-States/answers with paired clean/mute/swap/mix audio examples, and finally on-policy RL (a clipped PPO-style objective with KL penalty) jointly optimizing the policy and gate for answer accuracy, response timing, and output format.

Key results:

• On SOVBench-O, average content accuracy rises from StreamOV's 81.6 to 87.8 (audio-visual context) and from 83.8 to 88.4 (with QA context); Recall improves from 73.2 to 82.5; response-trigger F1 (SOVBench-T) rises from 90.5 to 92.4.
• OST beats the strongest open baseline on four more benchmarks (StreamingBench, Video-Holmes, Daily-Omni, OmniVideoBench), described as >10% relative improvement on average across five streaming/audio-visual benchmarks.
• On the new OST-DiagBench, OST reaches d′ = 2.95 (vs. at most 1.38 for open baselines), with 95.49% CLEAN source recall and only 10.39% MUTE visual-hallucination rate (vs. 73.73% for the raw Qwen3-Omni backbone and 81.96% under naive streaming thinking).
• OST leads SWAP faithful-attribution (81.76%) and CLASH accuracy on the new spoken fact (46.47%), versus at most 4.90% for open baselines (naive-streaming baselines that score 94-96% on audio-only CLASH controls collapse to 0-5% when a conflicting stale subtitle is visible).
• Ablations show removing separated audio/visual retention drops SOVBench-O Avg. to 84.0 and d′ to 2.49; removing lineage propagation drops d′ to 2.84 and TCI to 47.6; removing the Omni-State structured representation (free-form scratchpad) drops Avg. to 84.6 and d′ to 2.34.

Why it matters / caveats: The claim-verify-retract mechanism with lineage-aware retraction gives a concrete, testable framework for correcting streaming models' memory when late-arriving audio contradicts an early visual guess, and OST-DiagBench isolates visual-bias/hallucination behavior that aggregate benchmarks hide; results are reported only for one backbone (Qwen3-Omni-30B-A3B-Instruct) with lightweight adaptation, and the training data relies on a proprietary annotator (GEMINI-3.6-FLASH) to construct claim/verification supervision.

Problem: Native single-image 3D generators like TRELLIS.2 output one fused mesh, but downstream tasks (editing, rigging, simulation) need each object part as a separate, self-contained mesh, and existing segment-then-regenerate or mask/box-based part pipelines are either slow, capped in part count, or bounded by segmentation accuracy.

Method: KaiNinja extends TRELLIS.2's O-Voxel sparse-voxel/dual-contouring representation into a dual-volume form (two streams A/B) by two-coloring a part contact graph (contracting odd cycles greedily when non-bipartite) so touching parts never share a voxel; parts are then read off as connected components with no segmenter. The two-stage TRELLIS.2 rectified-flow cascade is adapted per stage: Stage 1 (layout flow, 16³ latent → 64³ occupancy) uses two full per-stream copies of the pretrained 30-block, width-1536, 12-head transformer with rotary position encoding, joined by zero-initialized shared cross-volume attention blocks after depths {6,12,18,24,29}; Stage 2 (refinement flow) keeps the pretrained backbone weights frozen and separates streams only via attention scope (20 of 30 blocks intra-volume, 10 blocks global, with a zero-initialized learned volume embedding). Training uses a flow-matching objective in a fit→merge→warm-up→joint-fine-tune schedule for Stage 1 (with a disjointness penalty on decoded occupancy overlap) and a warm-up→fine-tune schedule for Stage 2, conditioned by a frozen DINOv3 ViT-L/16 encoder at 512×512 with classifier-free guidance. Training corpus: 19,132 objects from articraft (Articraft-10K, LLM-agent-authored, 8,968), partnext (6,358), trellis (1,931), and fusion360 (CAD, 1,875).

Key results:

• On 986 held-out test objects, KaiNinja is best on all 7 metrics, beating the strongest baseline (Hunyuan3D-2.1 + X-Part) by +0.10 F1^0.05_W and +0.09 F1^0.05_P, with 40% lower whole-object Chamfer distance.
• Whole-object quality: KaiNinja reaches F1^0.05_W = 0.919 vs. TRELLIS.2@512 zero-shot 0.781 and the same backbone fine-tuned on the same corpus at 0.830 (a 38% CD reduction over the fine-tuned baseline), with only 0.7% failure rate vs. 1.8–6.8% for references.
• Cost: ~24 seconds per object at 512 resolution on one H100; costs 40% more than PartPacker (cheapest baseline) while gaining +0.20 F1^0.05_P; AutoPartGen costs 3× KaiNinja's budget; the generate-then-segment cascade (1024 export) is an order of magnitude slower (62.4s, of which 51.2s is mesh export).
• Generalizes on 95 out-of-corpus Sketchfab/GitHub objects (leads whole-object F1^0.05_W by 0.075) and on the external HY3D-Bench (200 objects), where it leads all 3 whole-object metrics by 2.6 points F1^0.05_W but ranks 4th of 6 on part mIoU due to finer part granularity than the benchmark's labels.
• Ablations: three-volume packing slightly improves part F1^0.05_P (+1.6 points) but fails outright on 13/1000 objects (vs. 0 for two volumes); the disjointness penalty lowers median cross-volume occupancy overlap from 0.229 to 0.184 at Stage 1; post-processing relabeling cuts predicted component count from 14.06 to 5.43 vs. 5.85 ground-truth parts.

Why it matters / caveats: Shows a representation-level fix (dual-volume packing directly on a native generator's own voxel grid) can add part-level structure without any mask/segmenter while also improving whole-object fidelity. Limitations include reliance on the two-volume/bipartite contact-graph assumption (dense interlocking parts get merged), stochastic seed-dependent decomposition, and three recurring failure modes (undersegmentation, single-volume collapse, duplicate-volume generation).

Problem: It is unclear whether diffusion large language models (dLLMs) can be extended into capable multimodal GUI agents that repeatedly perceive screens and emit structured, spatially grounded actions while preserving their parallel decoding advantage.

Method: LLaDA-UI is a 16.7B-parameter MoE, block-wise diffusion vision-language GUI agent built by connecting a native dynamic-resolution SigLIP-initialized ViT (with 2D RoPE) to the LLaDA2.0-mini-base 16B-parameter MoE diffusion language backbone (architecture similar to Ling2.0), via a Qwen2.5-VL-style projector that groups 4 adjacent image features and projects them with a two-layer MLP. Training is a two-stage pipeline: a three-phase multimodal pre-training curriculum (vision-language alignment, perception enhancement, multi-task pre-training, totaling ~145B tokens over 16K sequence length using dFactory/VeOmni), using a Block Diffusion Language Model cross-entropy loss, auxiliary-loss-free MoE load balancing, mask-token reweighting, and complementary masking; followed by GUI-Agent supervised fine-tuning on over 6M samples (100+ Chinese and 70+ English mobile apps plus desktop, web, and grounding data from the UI-Venus project) for 3 epochs.

Key results:

• On GUI-agent benchmarks, LLaDA-UI scores SS-V2 90.7, SS-Pro 52.9, AndroidWorld 53.5, MobileWorld 29.4, OSWorld-Verified 25.6, and WebVoyager 56.9, exceeding Qwen2.5-VL-7B on every reported benchmark and surpassing Qwen3-VL-8B on 4 of 6 (SS-Pro, AndroidWorld, MobileWorld, WebVoyager), with OSWorld-Verified remaining the main gap.
• Before GUI SFT, the multimodal foundation trained on only 145B tokens is competitive with Qwen2.5-VL (4.1T tokens) and Qwen3-VL (2.2T tokens) and sets a new state of the art among diffusion MLLM baselines, beating SDAR-VL-8B by 12.8%/13.6%/31.1% on MathVista/MathVision/MathVerse and by 2.5%/8.6%/17.8% on ChartQA/CharXiv-DQ/OCRBench.
• Paired non-cached API latency vs. Qwen3-VL-8B on 4 H100s: LLaDA-UI is 3.579x-8.951x faster by mean latency (median speedups 3.428x web, 6.778x OSWorld, 8.814x MobileWorld), though Qwen3-VL-8B has an exact-replay cache-hit mode that the evaluated LLaDA-UI stack lacks.
• Ablations on an intermediate checkpoint: disabling EOS early-stopping raises AndroidWorld success from 42.7% to 52.6% (+9.9pp); increasing block size from 32 to 64 while cutting denoising steps from 32 to 16 drops success from 42.7% to 33.0%.
• Structured-action diagnostics on a 116-task, 1,849-step AndroidWorld run: 98.65% response parse rate, 100% coordinate-valid actions, task success 51.72% (60/116); exact-repetition rate rises from 5.41% in successful trajectories to 26.70% in failed ones; success falls from 62.96% on tasks with ≤5 optimal actions to 14.29% on tasks with 20+ actions.

Why it matters / caveats: The results establish block-wise diffusion as a practical generative paradigm for multimodal GUI agents, offering an open-source diffusion-based agent with lower non-cached inference latency than a comparable autoregressive model. Stated limitations include a tendency to repeat actions and stall on long-horizon tasks, degraded grounding/perception on large screenshots with small targets (notably on OSWorld), and sensitivity of interactive performance to block size and denoising-step choices.

Problem: Existing guard models are built for classifying static prompts/responses and existing executable agent-safety platforms only produce evaluation verdicts, so neither provides the normalized, execution-grounded supervision needed to train a runtime guard that judges what a computer-use agent actually does (versus what it merely observes) across heterogeneous agent frameworks.

Method: HazardAuditor combines (1) an executable safety infrastructure that runs Claude Code, Codex, Hermes, and OpenClaw agents in controlled environments and normalizes their native logs via framework-specific adapters into a canonical event schema (user messages, agent responses with optional reasoning, tool calls with arguments, environment observations) with binary safe/unsafe trace labels; and (2) Guard Policy Optimization (GuardPO), a post-training method built on Qwen3Guard-Gen-8B. The pipeline is: full-parameter rationale-supervised SFT for 10 epochs (16K-token input budget, upweighting the final verdict tokens) as cold start, then GuardPO reinforcement-style training that assigns deterministic sequence-level rewards (+1 correct, -1 incorrect, malformed penalty) turned into batch-normalized advantages, applies CISPO-style clipped importance-weighted token loss, and separately normalizes the rationale-region and verdict-region loss per response before averaging, so response length cannot dominate the gradient (proved as a length-invariance proposition).

Key results:

• On the balanced cross-agent CUA-EXEC diagnostic (200 trajectories/framework), HazardAuditor beats the strongest prior guard (BraveGuard-Qwen3-Guard-8B) by 12.5, 4.0, 9.5, and 16.5 accuracy points on Claude Code, Codex, Hermes, and OpenClaw respectively (Macro-F1 gains of 13.0, 4.0, 10.2, 18.7 points).
• GuardPO over the SFT-only initialization raises accuracy from 82.0→94.0 (Claude Code), 91.0→95.5 (Codex), 75.0→86.5 (Hermes), 74.0→87.5 (OpenClaw).
• On AgentHazard (external foundation-model backends), HazardAuditor improves F1 over its own SFT stage on all four backends, e.g., 82.24→84.31 (GPT-5.5) and 93.28→95.07 (Gemini 3.1 Pro).
• On three untouched external benchmarks, HazardAuditor gets best accuracy/F1 on ASSE-Safety (91.5%) and best accuracy on ATBench (88.4%), and holds the highest worst-case F1 across benchmarks (88.3%) versus 86.2% (SFT-only) and 80.7% (best prior guard baseline).
• On a balanced NSFA-Query-Multilingual subset (6,400 queries) HazardAuditor reaches 88.89% accuracy, 96.01% unsafe precision, 81.28% unsafe recall, yielding 88.04% unsafe-class F1 (+3.37 points over AgentDoG1.5-FG).

Why it matters / caveats: The results support training runtime guards directly on execution evidence and optimizing at the level of the safety decision rather than token-level imitation, since HazardAuditor generalizes across four structurally different agent frameworks and transfers to benchmarks outside its own data distribution. Caveats noted by the authors: gains are not uniform everywhere (e.g., on GPT-5.5 backend BraveGuard retains higher recall/F1; on R-Judge the plain SFT model edges out the GuardPO model), and recall remains weak in some risk categories (e.g., 42.95% on "resource abuse" queries).

Problem: It is unclear whether LLM agents' adaptive test-time strategies (revising, using tools, backtracking, deciding when to stop) convert additional inference compute into performance faster or slower than simple repeated sampling, and existing single pass/fail benchmarks discard the trajectory data needed to measure this.

Method: The authors propose Elo-per-token analysis: they track each session's best-so-far score at every token budget, form pairwise within-task comparisons across systems/sessions/budgets, and fit a Bradley–Terry model (MM algorithm) to produce Elo ratings anchored at 1000, yielding self-Elo (within-system) and joint-Elo (cross-system) curves plotted against log token budget. They prove independent (best-of-n) sampling yields an Elo curve that is exactly linear at 400 Elo per decade of compute, giving a distribution-free reference line, and derive a "scaling inflection point" (the last budget where the marginal slope exceeds 400 Elo/decade) to guide splitting a fixed budget into K parallel sessions. They evaluate four general-purpose agents — Kimi Code with Kimi K2.7, Codex with GPT-5.5, Claude Code with Opus 4.8, and Gemini CLI with Gemini 3.5 Flash — each run for 5 independent sessions up to 100M cache-inclusive tokens per task, on 14 tasks across FrontierCS, ALE-Bench, MLS-Bench, and FlashInfer-Bench, plus a human comparison using historical AtCoder Heuristic Contest submission logs, and controlled interventions with AdaEvolve, GEPA, and TTT-Discover.

Key results:

• Independent sampling provably gains exactly 400 Elo per 10x increase in token budget; all four agents initially exceed this slope but their self-Elo curves become concave and fall below 400 Elo/decade by the largest budgets (up to 100M tokens), across all four benchmarks.
• On AHC014, agent (GPT-5.6-Sol, Opus 4.8) joint-Elo curves flatten within 72 hours, while human top-10 and top-50 cohorts keep improving superlinearly over multiple days and the top-10 cohort overtakes both agents; the same qualitative pattern holds across AHC038, AHC040, AHC031, and pooled over 7 contests.
• AdaEvolve and GEPA (test-time evolving) and TTT-Discover (test-time training) all show an early burst above the 400-Elo/decade reference followed by decline toward or below it; the three methods converge to within ~20 Elo by ~1M tokens.
• On FrontierCS Polyomino Packing with Kimi K2.7, the measured inflection point is 38M tokens, predicting K=3 sessions for a 100M-token budget; this 3-session allocation beats one 100M-token session by +264 joint-Elo and beats ten 10M-token sessions by +355 joint-Elo.
• A theoretical "sticky-basin" model shows that under a basin-then-search process, a c-fold increase in a session's compute budget wins against a shorter session only with probability approaching 1/2 as budgets grow, offering a candidate explanation for the observed diminishing returns.

Why it matters / caveats: The results give quantitative evidence that current coding/research agents lack the continual-learning ability that lets human contest experts keep improving over multi-day horizons, and they motivate reallocating a fixed compute budget into multiple shorter parallel sessions once a task's inflection point is known. A key open caveat is that the inflection point is task-specific and predicting it without first profiling the full task-level scaling curve remains unsolved.

Problem: In online RL post-training of multimodal LLMs, all training prompts receive equal rollout budget even though many are already saturated or too difficult to yield useful learning signal, wasting compute and slowing policy improvement.

Method: The authors define the Exploration Potential Score (EPS), a rollout-based proxy derived from KL-regularized policy improvement theory that estimates a soft improvement gap between the current policy and a locally-improved (Boltzmann-reweighted) policy, computed directly from the N=8 on-policy rollouts already collected during GRPO, with no extra rollouts. Prompts scoring below threshold τ=0 are routed to a teacher model (Qwen-VL-Max) that rewrites them into "scaffolded" variants conditioned on the student's rollouts and rewards, while high-EPS prompts are kept for direct GRPO updates; rewritten prompts are asynchronously reinserted into a dynamic prompt pool so training data adapts continuously as the policy evolves. Experiments post-train Qwen3-VL-2B and Qwen3-VL-4B (initialized after SFT on the 500K-example OmniThoughtV4 dataset) with GRPO for 3,000 RL steps on Geometry3K and MMK12, using MathRuler for verifiable rewards.

Key results:

• On MMK12 training, average OOD accuracy rises from 39.50% to 42.83% (Qwen3-VL-2B) and from 50.87% to 52.67% (Qwen3-VL-4B) versus GRPO.
• In-domain gains up to 9.7% relative improvement; MathVision improves by 11.5% and MMMU-Pro by 11.1% (headline OOD numbers), e.g., MMK12-trained 2B MathVision goes from 28.62% to 31.91% and MMMU-Pro from 36.59% to 40.64%.
• On Geometry3K (2B backbone), in-domain accuracy improves from 55.41% (GRPO) to 59.07% (Ours); MMK12 in-domain (2B) improves from 51.40% to 56.40%.
• Ablation on MMK12 (first 1,000 steps, 2B model): filtering to EPS>0 vs. the unfiltered pool yields a 4.10-point accuracy gap; training on EPS≥0.5 prompts alone reaches 44.85% vs. 39.55% for 0<EPS<0.5, while combining all EPS>0 prompts reaches the best 46.00%.
• Validation accuracy on MMK12 (2B) shows a step-change improvement immediately after the first scaffolded-prompt-pool refresh and stays above the GRPO baseline through 2,000 training steps.

Why it matters / caveats: The method needs no extra rollouts (EPS reuses existing GRPO statistics) and gives consistent gains across two datasets, two model scales, and multiple OOD benchmarks. Caveats stated by the authors: EPS is a noisy finite-sample proxy rather than a calibrated learnability measure; the scaffolding teacher is answer-aware (given the reference answer, though told not to reveal it), so results reflect a teacher-assisted setting; and experiments are limited to verifiable-reward math/visual reasoning tasks.

Problem: Existing agentic robot systems either pre-generate programs that cannot flexibly react to uncertain observations or use agents merely to orchestrate pre-trained motion policies, limiting adaptation when physical manipulation requires jointly reasoning about scene, attempted motion, and outcome.

Method: The paper introduces Agent as Policy (AGP), which uses an unmodified general-purpose coding agent (GPT-6 Astra at high thinking effort via Codex, by default; also tested with GPT-5.6 Sol/Terra/Luna and Claude Code with Claude Opus 5/Claude Fable 5.1) directly as the robot control policy, with model weights fixed and no task-specific training. A preparation agent first authors a reusable task definition (goal, constraints, completion criteria) from video/image/language instructions; at runtime an execution agent writes and runs Python programs against a robot bridge on an I2RT YAM 6-DOF arm with parallel gripper, exposing seven commands (state, status, help, frames, move_ee, move_joints, gripper), using Mink for inverse kinematics, a wrist-mounted Intel RealSense D405 and overhead Logitech BRIO camera. The agent iteratively interprets images/depth, computes grasp/insertion geometry, issues motion requests, and revises estimates from motion feedback and new observations within a persistent workspace.

Key results:

• Four-pair assembly (from AutoMate dataset human video): 8/10 trials succeeded, mean 37.2 min, 13.02M tokens.
• Block construction from goal images: 29/30 across three configurations (pyramid 10/10, two towers 10/10, six-block tower 9/10).
• Dice flipping (language instruction): 10/10 trials; targeted throwing: 2/2; sequential towel folding: 5/5 (but 50.8 min, $24.14 avg — among highest cost); simultaneous towel folding: only 3/5.
• Model/agent comparison on two-pair assembly: GPT-6 Astra 5/5 at low/medium/high thinking effort; GPT-5.6 Sol 5/5; GPT-5.6 Terra 1/5; GPT-5.6 Luna 0/5; Claude Code with Claude Opus 5 5/5; with Claude Fable 5.1 3/5.
• Experience accumulation over 5 repeated trials of two-pair assembly reduced task execution time by 29.3% (first→fifth run); strong-to-weak experience transfer (Astra→Terra) raised Terra's success from 1/5 to 4/5, cutting mean completion time by 34.3% and token usage by 11.4% on successful trials.

Why it matters / caveats: The results support that a fixed-weight, general-purpose MLLM agent can serve directly as a zero-shot robot policy across precision assembly, deformable-object folding, and dynamic throwing without any robot-specific training, and that saved/transferred "experience" files can substantially cut inference cost and boost weaker models' success. However, execution remains slow and expensive (tens of minutes and up to ~$50 USD per successful trial), and reliability drops sharply for coordinated deformable-object manipulation (simultaneous towel folding at 3/5).

Problem: Standard backdoor-attack evaluations fix the trigger, target behavior, and number of poisoned examples but sample the poison set at random, which the authors show can severely underestimate worst-case attack vulnerability since held-out attack success can range from 3% to 80% depending only on which poison set is chosen.

Method: The paper formalizes poison selection as oracle-budgeted set optimization and proposes SAILS (Set-level Audit-Informed Iterative Learned Selection), a propose-score-audit-refine loop: a DistilBERT text encoder with a regression head is trained on canonicalized poison-set texts to predict triggered loss from ~500 initial randomly oracle-labeled sets, then each round scores 500K candidate sets, audits a shortlist of 10 via ε-greedy selection with real finetune-and-evaluate oracle queries, and retrains on the newly audited labels. It is evaluated against pointwise influence baselines (TRAK, TRAK+representer, bilevel influence functions, gradient dot product/cosine, MMR diversity regularization) and oracle-greedy/oracle-guided GRPO RL baselines, primarily on three LLaMA-3-8B-Instruct LoRA-finetuned backdoor settings built from Alpaca and StrongReject data.

Key results:

• At B=1500 oracle queries, SAILS reaches 72%/92%/67% ASR on REFUSAL/COMMAND/COMPLIANCE, beating the best B=10 influence baseline by +30pp on average.
• On SmolLM-360M, SAILS reaches 68% ASR at B≈370 versus random best-of-B plateauing at ~44-45%, and attains ~92% of the best oracle-guided GRPO RL result at 1/18th the oracle cost.
• A scorer trained only on mini-scale oracle labels (~1500 evaluations) transfers to full-scale finetuning, reaching 80%/69%/58% ASR versus 48%/43%/56% for TRAK-greedy.
• Extends beyond primary benchmarks: 67% ASR (vs. 47% random, 28% TRAK) on a Qwen3-4B code-generation backdoor; 91% ASR (vs. 84% random) on a WebShop agentic backdoor; 72% ASR (vs. 46% random best-of-B) on API-only finetuning of Kimi-K2.5 via the Tinker API.
• Pool expansion illustrates a Goodhart effect: growing the SmolLM pool from 900 to 50K examples raises TRAK's proxy score but drops its oracle-best ASR from 36% to 16%, while SAILS improves from 60% to 68%; false-trigger rate on clean inputs stays below 5% across settings.

Why it matters / caveats: The results indicate that random-sampling-based poisoning evaluations can substantially underestimate worst-case LLM backdoor risk, and that pointwise influence-style defenses/attacks miss set-level interaction effects between poison examples. The authors note sensitivity to training dynamics (mini-batch SGD vs. full-batch results vary) and frame SAILS as an oracle-budgeted attacker/auditor tool for stress-testing model vulnerability to data poisoning.

Problem: In cluttered, occluded manipulation scenes, sparse 3D point clouds cannot cleanly separate target objects from visually similar distractors, causing standard 3D diffusion policies (e.g., DP3) to lose track of the language-specified target as clutter increases.

Method: Attention-DP3 keeps the DP3 conditional U-Net diffusion backbone unchanged and adds an Attn-Enhanced Module: a frozen Grounding DINO + SAM2 pipeline predicts a text-conditioned 2D mask on RGB, which is deterministically lifted to 3D points via calibrated camera projection to build three per-point fields (Targetness, Intra-target saliency via mask distance-transform weighting, and Backgroundness). These fields are encoded by a lightweight field encoder (point-wise MLP + symmetric pooling) into an attention feature, concatenated with the DP3 point-cloud and state features as FiLM-style conditioning for the noise-prediction denoiser, trained with the standard DDPM objective.

Key results:

• MetaWorld overall success rate 0.726 vs. DP3's 0.669 and VITA's 0.683; large per-task gains on Push-Wall and Pick-Place (0.60 vs 0.35).
• Adroit average success 0.78 vs DP3 0.68; DexArt average 0.56 vs DP3 0.52.
• Real-world SO101 (3 tasks, 20 rollouts each): average success improves from 0.52 (DP3) to 0.73 (Attention-DP3), with Push Cube improving from 0.30 to 0.65.
• Clutter robustness: under real-world progressive distractors, Attention-DP3 stays at 0.73/0.72/0.65/0.45 vs DP3's 0.43/0.52/0.38/0.13 — up to +31% gain under extreme distraction; on Adroit Hammer with 4-6 distractor nails DP3 collapses while Attention-DP3 stays saturated.
• Overhead: adds only 3.8M parameters, 0.01GB peak memory, +0.001s policy-side latency per step versus DP3; mean effective control-step latency 0.198s vs DP3's 0.122s (mostly from the frozen perception branch, reducible to 0.044s with a Swin-T variant).
• Robustness checks: with incorrect segmentation Attention-DP3 ≈ DP3, but with correct segmentation it strongly outperforms (233/366 vs 155/366 successes); mask dropout at p=0.9 still beats DP3 (0.456 vs 0.370).

Why it matters / caveats: The approach adds robust object-level semantic grounding to 3D diffusion policies with negligible parameter/compute overhead and without touching the diffusion backbone, showing strong zero-shot robustness to unseen clutter in both simulation and real-world tests. Caveats: perception latency is dominated by the frozen Grounding DINO+SAM2 branch, some task failures are attributable to Grounding DINO detection misses (e.g., 8/10 failures on Coffee-Push), and gains on some MetaWorld tasks are smaller or mixed.

Problem: On-policy RLVR keeps training data close to the current policy but limits learning to trajectories the policy can already discover under finite sampling, while fully off-policy methods (e.g., SFT on teacher trajectories) expand knowledge but suffer from large distribution shift.

Method: MInTRL uses a judge–intervention policy that periodically reviews the current policy's chunk-by-chunk rollout, flags the earliest erroneous step, and injects a short corrective continuation (up to 64 tokens) before immediately returning control to the policy. Training uses a sequence-level advantage-regression objective (KL-regularized closed-form optimal policy fit, avoiding importance sampling), with two variants—MInTRL-Proxy (anchors intervention tokens to policy log-probs) and MInTRL-Const (anchors them to a constant)—plus Monte Carlo control rollouts for the value baseline and an early-stopping schedule that disables intervention after an initial training phase. Experiments use Qwen3-1.7B and Qwen3-4B as policies and Qwen3-4B-Instruct-2507 as the judge–intervention model, trained on AceReason-Nemotron (math) and DeepCoder-Preview (code) prompts, compared against GRPO, OPD, SFT+GRPO, and MENTOR baselines.

Key results:

• On Qwen3-1.7B, MInTRL-Const reaches 35.45 avg on math (AIME25/AIME26/HMMT25) and 61.95 avg on code (LiveCodeBench/HumanEval+/MBPP+), gains of +13.61pp and +14.12pp over the stronger of GRPO/OPD.
• On Qwen3-4B, MInTRL-Const reaches 55.73 math avg and 72.63 code avg, +3.02pp and +6.80pp over the best baseline.
• Overall improvements up to 9.44pp over the strongest competitor across benchmarks.
• Off-policy intensity ablation shows a non-monotonic (inverted-U) trend, peaking at ~2–4% off-policy token fraction; excessive intervention underperforms the pure on-policy baseline.
• Robustness check swapping the judge to DeepSeek-V4-Flash still outperforms GRPO/OPD across scales and domains, though a stronger judge doesn't consistently improve results further.
• MInTRL maintains higher training reward and policy entropy than GRPO/OPD and improves Pass@k up to k=32.

Why it matters / caveats: The paper demonstrates that sparse, minimal off-policy corrections can expand the exploration frontier of on-policy RL without the instability of full off-policy distillation, formalized via a coverage–learnability trade-off showing N corrections can expand visible support exponentially while remaining bounded by a learnability threshold. Caveats: performance is sensitive to intervention intensity (too much hurts), the judge is imperfect and only used early in training, and gains vary depending on which judge/anchor variant is paired with which base policy strength.

Problem: Kiefer SA needed to ship Sophea, a commercial bilingual Greek-English ASR system, that simultaneously meets nine independently measured production gates (four Greek and three English WER ceilings, a 95% language-ID accuracy floor, and zero hallucination on non-speech audio) across noisy telephone and meeting-room conditions with mid-utterance code-switching.

Method: The team trained two model lines across 23 iterations: a compact 1.7B-parameter bilingual model (Qwen-Audio-family-derived) and a larger Whisper-based model, plus a "turbo" tier built on a four-decoder-layer Whisper variant. Data passed through a six-stage quality pipeline (UTMOS audio-quality scoring recalibrated against in-domain anchors, WPM plausibility filtering, transcription-confidence filtering, multi-teacher cross-checks, CTC-based forced-alignment filtering, and language-parity assembly), paired with a Greek-aware text normalizer extending Whisper's normalization. For inference-time gains they used a three-model ROVER confusion-network ensemble (their bilingual model, a Greek fine-tune of NVIDIA Canary, and a LoRA-adapted Whisper large-v3) and a separate two-model system, Sophea ASR K1, combining a far-field LoRA-adapted Qwen variant with the Canary fine-tune via a gradient-boosted per-clip arbiter classifier.

Key results:

• Measured an unclosable trade-off frontier at this scale: the Greek noisy-environment gate (WER ≤25.25) needs ≥1,500 training steps of dense noisy-environment exposure, while the English LID floor (≥95%) tolerates only ≤250 steps under baseline mix — a ~6x gap, leaving the joint feasible point ~1 WER point outside the frontier.
• UTMOS recalibration against in-domain anchors (dropping the discard threshold from 3.0 to 1.30) cut discarded Greek training audio from 98.7% to 10.6%.
• The three-model ROVER ensemble raised gate coverage from 4-7/9 (individual models) to 9/9 and cut overlapping-speech WER from 53.35% to 37.87% (-29% relative, 18 AMI meetings).
• Sophea ASR K1 scored 4.26% average WER on the Open ASR Leaderboard's eight public English sets (ranked 11th as of 11 Sept 2026) and, in live production, hit 25.88% WER on Greek noisy-environment traffic (95% CI 24.44-27.19, n=1,325) — the first single served model under the 26% gate; on English noisy-environment audio it reached 14.21% WER versus 17.72% for a prior compact checkpoint.
• Across the program, five internal measurement bugs produced plausible-but-wrong numbers before a second instrument caught them, and seven substantial efforts (RL-based length correction, text-only and audio-conditioned error correction, spectrogram-as-image transcription, direct meeting fine-tuning, turbo-tier fine-tuning, new English data) were measured and not shipped.

Why it matters / caveats: The paper argues that when two gates can't jointly be satisfied across a wide range of data mixes, teams should recognize a capacity/objective trade-off frontier rather than keep searching for a better data mix, and should calibrate automatic quality scorers against in-domain anchors before trusting textbook thresholds. Caveats: the impossibility result is measured at one model scale/configuration with no repeated seeds; most benchmarks are proprietary and non-reproducible; the overlapping-speech ensemble gain is English-only; no model weights, training data, or code are released.

Problem: In RL post-training of Mixture-of-Experts LLMs, standard deterministic top-K routing means the same prompt prefix always activates the same experts, leaving the expert-routing space unexplored and limiting rollout diversity for group-relative RL methods like GRPO.

Method: The authors propose Expert-Space Exploration RL (ESRL), which perturbs router logits with Gaussian noise during rollout but keeps a set of Kanchor high-confidence experts fixed via standard Top-K while restricting stochastic perturbation to an exploratory candidate pool of Mexplore experts (aggregation weights still computed from the original, unperturbed logits); the noise scale is adapted per-token/layer via normalized router entropy; and Rollout Routing Replay (R3) records the exact expert paths used at rollout and replays them (bypassing Top-K recomputation) during GRPO policy optimization. It is evaluated on Qwen3-30B-A3B-Base (128 routed experts, top-8), Sigma-20B-A0.5B (top-1), and Moonlight-16B-A3B (64 experts, top-6), trained with GRPO on the MATH dataset, compared against GRPO, GSPO, GRPO-R3, Aux-Loss, N-Sampling, and RO-GRPO baselines.

Key results:

• On Qwen3-30B-A3B-Base (OlympiadBench, AIME, AMC, MinervaMath), ESRL improves average Pass@1 by 3.2 points (38.9→42.1) and Pass@8 by 4.5 points (59.7→64.2) over GRPO, beating GSPO and RO-GRPO too.
• On Sigma-20B-A0.5B and Moonlight-16B-A3B, ESRL raises average Pass@8 over GRPO by 2.7 and 3.5 points respectively.
• On science/code tasks (Qwen3-30B-A3B), ESRL improves average Pass@1 from 53.2→55.9 and Pass@8 from 64.9→77.0 over GRPO, with especially large Pass@8 gains on GPQA (+23.3), MMLU-Pro (+15.1), and MMLU-Redux (+8.2).
• ESRL is more robust to sampling temperature and more sample-efficient (ESRL with 64 rollout samples surpasses GRPO-R3 with 128; ESRL with 128 exceeds GRPO-R3 with 256).
• Ablations: best config gives peak average Pass@1 of 42.1 (~2.4 points above GRPO-R3); without anchored experts, performance collapses to ~32% at high noise, and non-adaptive (fixed) noise scaling underperforms both adaptive ESRL and GRPO-R3.

Why it matters / caveats: The paper establishes expert routing as a new, architecture-aware exploration axis for MoE RL that is orthogonal to token-level sampling and to optimization/reward changes, so it could be combined with them; however, gains depend on careful entropy-adaptive noise control and anchored sampling, since unconstrained routing perturbation degrades rollout quality, and some baselines required selecting the best checkpoint due to training collapse.

Problem: Vibe design agents that turn natural-language briefs into UI code need to help users explore meaningfully different design alternatives, but raising token-level temperature entangles aesthetic variation with syntax-sensitive code generation, making it a blunt and unreliable control.

Method: The authors propose an inference architecture that separates exploration from implementation into three stages: a proposal pre-pass (built on Verbalized Sampling) elicits K=3 structured design specifications with self-assessed typicality scores (labeled Safe, Premium, Experimental), an external selector normalizes scores into weights and applies temperature-scaled selection to sample one candidate, and a downstream generator realizes the selected specification under fixed decoding settings. They instantiate this separately for UI theme specifications and visual-asset image-generation prompts, using Gemini 3 Flash for candidate proposal/generation, Nano Banana 2 for in-page images, and Gemini 3.1 Pro as the pairwise LLM judge, with temperatures τ ∈ {0.5, 1, 1.5, 2, 5} and reported production defaults of 1.5 (themes) and 2.0 (assets).

Key results:

• Offline evaluation spans 168 prompts with 1,255 paired comparisons per temperature per intervention.
• Theme candidate selection raises reported selection coverage from a baseline mean of 1.00 option to 2.10–2.94 options; at τ≥1.5 every prompt shows more than one observed option.
• Screenshot cosine similarity for themes drops from 0.6560 (τ=0.5) to 0.5438 (τ=2.0) vs. baseline 0.6765; judge preference peaks at τ=2.0 with a 1.10 win/loss ratio but reverses at τ=5.0.
• Visual-asset intervention shows much smaller screenshot-similarity shifts while judge win/loss ratio peaks at τ=1.0 with 1.32.
• Online A/B test on 309,870 tasks: negative feedback events fall from 73 to 50 (−31.51%); correction interactions rise from 38.8% to 41.6% of conversations (+7.08%); within-60-second task completion falls 49.9%→48.2% (−3.47%) and task success falls 97.95%→97.80% (−0.15%).

Why it matters / caveats: The work demonstrates a concrete, model-agnostic control point for broadening design exploration without touching downstream decoding settings, useful for products like Lovable, v0, Bolt, Figma Make, and Google Stitch. Caveats: results don't isolate typicality weighting from mere multi-candidate proposal, best temperatures vary by prompt suite, LLM-judge preferences are not blinded human/professional evaluations, and the online export-increase result is statistically inconclusive.

Problem: Vision-language-action (VLA) policies need to connect task language, visual outcome/dynamics prediction, and continuous control, but existing architectures typically couple a VLM or video generator to a separate action expert rather than learning these complementary objectives within one shared model.

Method: Dynin-Robotics extends Dynin-Omni, an omnimodal masked-diffusion Transformer backbone (shared bidirectional Transformer, shared token embeddings, unified categorical prediction head) that tokenizes text, images/video (MAGViT-v2), and speech, by adding a quantized robot-action token space (deterministic per-dimension uniform binning, 256 bins, 7-DoF interface) and an optional reserved sensor-token interface. An objective token selects visible context and masked target spans to realize four conditional tasks—Policy, World Modeling, Goal-State Prediction, and Task Understanding—trained with a target-only masked-diffusion cross-entropy loss plus a Policy-only auxiliary. Stage 1 continually pretrains on 1,332,985 trajectories / 65,217,081 transitions from 48 Open X-Embodiment datasets; Stage 2 performs domain-specific SFT (and an optional PPO-based online RL stage training only a remasking controller) on LIBERO, VLABench, and real-Franka data. A block-parallel decoder built on dInfer accelerates action-chunk generation.

Key results:

• LIBERO: 98.1% macro-average success, roughly matching X-VLA.
• Zero-shot LIBERO-Plus (7 perturbation families, no extra training): 73.0% macro-average, above OpenVLA-OFT/RIPT-VLA but below ABot-M0 (81.6%).
• Real-world Franka Research 3 (4 tasks): 78.4% average success, highest among compared methods.
• Stage-1 OXE pretraining lifts VLABench (70k-step Stage-2) ID/OOD success from 3.26%/0.70% (no pretraining) to 49.61%/47.28%.
• Full 4-objective Stage-2 mixture vs. Policy-only: OOD success 47.28% vs. 33.88% (+13.4 pts).
• Block-parallel dInfer decoding: BL35 gives 29.15× speedup (268.834 TPS) with token accuracy 99.46%; on LIBERO-Goal rollouts, this cuts query latency from 3,795.7ms to 130.2ms at a cost of only 0.6 point success drop.

Why it matters / caveats: The work shows a single masked-diffusion backbone can share policy, world-model, goal-prediction, and language-understanding objectives, and that composing these auxiliary predictions at inference time improves out-of-distribution instruction success while enabling large decoding speedups. Caveats: whole-image World Modeling metrics still trail simple last-frame copying, terminal Goal-State Prediction pixel fidelity trails a dedicated image-generation model, Task Understanding is only evaluated qualitatively, and physical evaluation is limited to one robot platform.

Problem: Because a radiology report can already answer a clinical question on its own, it is hard to tell whether a report-conditioned vision-language model is actually using the image or just reading the text.

Method: ModaLens is a paired image-swap audit run on MedGemma-27B (built on Gemma 3) over 3,199 paired MIMIC-CXR test-split cases from 293 patients, asking all 14 questions per case (13 CheXpert finding-specific questions plus one composite acute-cardiopulmonary question) with the case's own image (concordant) or a substituted image from another study (discordant) while holding the report and question text fixed. Sensitivity is read via a lowercase first-token yes/no readout, validated against token-family and generated-answer readouts under an explicit "answer Yes or No" instruction; mechanistic follow-ups use logit-lens layer projections and cumulative attention knockout of report-token positions. The direction of the effect is checked for replication in MedGemma-4B, Qwen3.5-9B/27B, and LLaVA-NeXT on Mistral-7B.

Key results:

• Under the explicit answer instruction, MedGemma-27B's generated answer changes with the image on 4.26% of trials with the report present vs. 20.94% without it (paired difference +16.7 points, 95% CI [15.6, 17.7], 44,786 trials).
• Attention knockout of report-token positions restores image-swap flip rate from 1.50% to 7.75% when blocking starts at layer 0 (vs. 12.00% with no report at all), with the report-specific effect confined to layers 0–20 (boundary near layer 24 of 62).
• Report-presence effect replicates across model families under the answer instruction: +13.3 points (Qwen3.5-9B), +19.60 points (Qwen3.5-27B), +12.75 points (LLaVA-NeXT/Mistral-7B).
• Report alone reaches pooled balanced accuracy 0.770 against report-derived labels; adding the image lowers this to 0.717, showing a negative image×report interaction (pooled −0.218).
• On the label-conditioned one-question design, no tested model reads the substituted image above chance once the report is removed, indicating the generalizing behavior is "report anchoring," not image competence.

Why it matters / caveats: The audit demonstrates that report availability substantially suppresses measured image sensitivity in a clinically deployed VLM, a form of silent modality shortcutting relevant to trust in report-conditioned medical AI; however, the authors caution that labels are derived from the reports themselves (not independent image ground truth), so the study cannot establish that the model's image-blind answers are visually wrong, and results come from a single institution's frontal chest radiographs in English.