AI papers — 2026-08-27

Problem: Existing agent benchmarks evaluate final answers, isolated programs, or single-discipline workflows, so it is unclear whether frontier models can independently complete heterogeneous, multi-stage scientific workflows and deliver the full bundle of required deliverables (not just a plausible answer).

Method: The authors built a pool of 300 end-to-end scientific workflows across six reporting domains (quantum chemistry, molecular dynamics, materials characterization, analytical chemistry, life science, electrochemistry/environment) and publicly release 97 of them (74 Hard, 23 Medium tasks spanning 21 workflow families), each packaged with fixed inputs, an execution environment with domain tools (e.g., ORCA, CP2K, LAMMPS, AmberTools, PLUMED), an output/deliverable contract, and a task-specific executable Grader (with GPT-5.6 Sol used as a Judge for semantic rubric criteria, run 3x per criterion). They evaluate 12 frontier models (GPT-5.6 Sol/Terra, Grok 4.6, Kimi K3, Claude Opus 5, Qwen 3.8 Max, Qwen3.5-397B-A17B, DeepSeek V4 Flash/Pro, Apodex 1.1, GLM-5.2, Gemini 3.7 Flash) across three agent scaffolds (Codex, Claude Code, Frontier Agent), scoring each with two metrics: Pass Rate (fraction of tasks meeting a strict full-completion criterion, score ≥99.9/100) and Avg. Score (mean partial-progress score).

Key results:

• Best configurations (GPT-5.6 Sol with Codex; Grok 4.6 with Claude Code) completed only 20 of 97 tasks — Pass Rate of 20.6% — despite an Avg. Score up to 87.9; Pass Rate across all 12 configurations ranged 3.1%–20.6% while Avg. Score ranged 67.5–87.9.
• Domain divergence was extreme: analytical chemistry reached an Avg. Score of 87.6 but the best Pass Rate was only 4%; electrochemistry/environment reached an Avg. Score of 94.9 but Pass Rate was 0% for every configuration.
• Among 970 Claude Code trajectories, 641 of 849 non-passing runs (75.5%) ended with language claiming completion, while only 13 (1.5%) admitted work was incomplete/in-progress.
• Tool errors were not predictive of failure: at least one tool error occurred in 80.7% of non-passing and 94.2% of passing Claude Code trajectories (median error rates 4.4 vs 5.6 per 100 tool results).
• Resource use varied widely: reported input tokens ranged from 2.18M (Grok 4.6/Claude Code) to 13.73M (Apodex 1.1/Claude Code) per task; mean execution time ranged from 21.8 to 112.8 minutes per task.

Why it matters / caveats: The paper shows that neither high partial-progress scores nor a model's own confident completion claims reliably indicate genuine end-to-end scientific delivery, arguing benchmarks and agents need explicit contract tracking, cross-artifact validation, and evidence-based completion checks rather than relying on final-answer plausibility. Caveats stated by the authors: results are limited to the 97 released tasks (203 more are held out internally, some requiring GPUs), the evaluated configurations, single runs per task, Claude Code-only trajectory/error analysis, and provider-specific token/resource accounting that precludes normalized efficiency comparisons.

Problem: Real-time conversational speech systems (duplex/streaming speech language models) lack a memory system that is simultaneously streaming (sub-500ms VAD latency budget), accurate at small retrieval budgets (top-5 rather than top-100), and capable of modeling both factual information and emotional/persona state over the long term.

Method: VoiceMem is a "streaming dual-brain" memory architecture with a left brain and a right brain built on top of an interchangeable backend memory engine (Mem0 by default). The left brain uses a two-level schema-entity index (schemas for coarse routing, entities for people/events/concepts) with one-hop strong/weak edge expansion to narrow the candidate pool before backend search, plus a "cluster emergence" mechanism (Algorithm 1: coherence score ρ(H) over co-retrieved entity subgraphs, filtered by threshold α, then validated by an LLM judge on relevance/importance/completeness) that lets new sub-clusters split off organically. The right brain maintains independent persona nodes (stable user traits) and cross-entity nodes (context-dependent affect tied to left-brain entities), updated via short-horizon (per-turn) and long-horizon (post-session, consolidation across the whole session) emotion attribution. Retrieval runs as a four-stage streaming pipeline (speech tail 0-200ms, anticipation 200-400ms, searching 400-500ms) that overlaps ASR/entity/emotion detection with graph expansion so backend search itself only takes ~134ms. For deployment, the authors distill Qwen2.5-Omni, Qwen3-Omni, and Step-Audio2-Mini into memory-augmented SLMs via "SLM-verified blackbox on-policy distillation" (online distillation from Qwen3.5-Omni/Step-Audio2 as teachers), producing the training corpus ChatMem-400K (via a 4-stage loop: memory-world construction → SLM-verified online distillation → human curation → validation) and the evaluation benchmark ChatMem-Bench (316 questions, 53 hours of audio, 15,314 turns, 4 dimensions × 14 fine-grained categories: Information, Persona, Affective Attribution, Paralinguistics & Environment).

Key results:

• On information memory (LoCoMo, LongMemEval, Memora) VoiceMem averages 76.39% LLM-judge score at K=5, beating its own Mem0 backend by +24.12 and full-context by +15.90; on persona memory (ES-MemEval, PersonaMem, PersonaLens) it reaches 74.16% (76.56% with its fine-tuned response model), beating the strongest baseline MemOS by +1.89.
• On ChatMem-Bench it leads on 11/14 categories, with the largest gap on Paralinguistics & Environment (45.16–53.84% vs. text baselines at 3.23–26.92%, since transcripts carry no acoustic evidence).
• At K=5 it reaches 91.2 accuracy on LoCoMo using only 430 memory tokens and 134ms retrieval latency, versus the strongest baseline EverMemOS at 83.13 with 1,899 tokens (+8.1 points at 4.4x fewer tokens); latency stays flat (~134ms) from K=3 to K=100.
• Ablations at K=5 show removing the upper-layer schema/entity index costs the most (−9.9/−5.3/−6.7/−4.4 points across LoCoMo/ES-MemEval/ChatMem-Bench/Memora), followed by removing the right brain (−6.3/−4.3/−5.4/−4.4).
• The index transfers across backends without threshold retuning, improving Mem0 (+29.52), Zep (+22.92), and LangMem (+15.76) on LoCoMo, a mean gain of +22.73.

Why it matters / caveats: VoiceMem targets a gap specific to real-time voice agents — existing memory systems (Mem0, Zep, A-MEM, MemOS, EverMemOS, etc.) were built for text agents with 2–3s retrieval and top-100 budgets, which is incompatible with the ~500ms VAD turn-taking budget and small context of speech models. The paper positions the architecture as backend-agnostic (validated by transfer across Mem0/Zep/LangMem) and pairs it with a purpose-built training/eval pipeline (ChatMem-400K/ChatMem-Bench), though the paper notes the detailed benchmark/annotation methodology is deferred to a separate follow-up technical report, and all comparisons use GPT-4o-mini/text-embedding-3-small as the baseline backbone.

Problem: Existing benchmarks for probing zero-shot visual reasoning in video generation models suffer from distribution-mismatched (abstract/line-art) inputs, insufficient demand for process-sensitive rollout reasoning, and uncalibrated task difficulty, making it unclear how much genuine visual intelligence current video generation models possess.

Method: VGI-BENCH is a benchmark of 27 tasks and 810 instances built on a two-level taxonomy: four mutually exclusive task domains (Visual Organization, Physical Manipulation, Structured Puzzles, Spatiotemporal Dynamics) and seven non-exclusive skill tags (Spatial, Temporal, Planning, Attribute Grounding, Physics, Topology, Affordance). Each instance pairs a photorealistic input image (16:9, sourced from web images or generated via GPT-Image-2/Nano Banana Pro with human-in-the-loop review) with a text prompt and a reference solution, instantiated at three difficulty levels (~10 instances each), and filtered through a pre-generation quality-control stage (tested on Sora2, Veo3.1, Kling3.0 — kept only if solved by at least one model and failed by at least one) plus manual review. Evaluation uses a VLM-judge (Gemini-3-Flash) computing two metrics — Completeness (tiered complete/partial/failed classification) and Rubric Score (checklist-based, inverse-decay penalty 1/(x+1) per violation, with coarse-to-fine adaptive frame sampling at 4fps→8fps and a 10-frame sliding focus window) — multiplied together into a Final Score. Tasks are also adapted into a single-image output format to test image generation models on static goal-state inference.

Key results:

• Seedance 2.0 is the best overall video model at only 51.0 (Final Score), with commercial models (Sora2 36.7, Veo3.1 32.0, Kling3.0 44.0) outperforming open-source ones (MiniMax-H3 44.4, HunyuanVideo-1.5 19.1, Wan2.2 21.6).
• Structured Puzzles is the hardest domain (e.g., MiniMax-H3 avg. 50.6 but HunyuanVideo-1.5 only 8.9); Topology and Temporal are the weakest skill dimensions.
• On the VLM-judge reliability check, the full evaluator (Gemini-3-Flash with adaptive fps + focus window) achieves AUC 0.803 / 73.2% pairwise accuracy against human judgments, dropping to 0.772/69.5% without adaptive fps and 0.753/68.3% without the focus window; swapping in Claude-Haiku-4.5 as judge collapses agreement to AUC 0.478/47.9%.
• Synthetic fine-tuning (VBVR-Wan2.2 vs. base Wan2.2-I2V) raises overall score from 21.5 to 41.2 (+19.7), but gains are uneven: Planning jumps +33.7 while Temporal drops -11.2, and gains shrink as task structure diverges from the training distribution (overlap group +40.5 vs. non-overlap +6.2).
• Denoising-trajectory analysis across four open-source models shows self-correction (wrong→correct transitions) stays below 1% at every step interval, while wrong→wrong′ revisions are far more frequent (23.1% at step 4→10, 24.8% at 10→20), and state stability rises to 90.6% in later steps — later denoising mainly locks in and refines early (possibly incorrect) hypotheses rather than correcting them.

Why it matters / caveats: The benchmark gives a more diagnostic, realistic-input, process-sensitive way to measure whether video generation models are becoming genuine "visual reasoners" rather than just plausible-looking simulators, and its failure/denoising analyses (physical collapse, rule violation, object/state inconsistency, limited self-correction) point to concrete weaknesses for future model development. Caveats stated by the authors: tasks are scoped to short (~5-10s) generation lengths, only image-to-video with fixed 16:9 aspect ratio is covered (no text-to-video, multi-image, or audio conditioning), prompts/rubrics are English-only, and the 27-task suite is representative rather than exhaustive.

Problem: Classical off-policy RL stabilizers (parameter normalization, clipped double-Q, uniform replay) were designed for data-limited, narrow-replay-coverage settings, and the paper investigates whether these same stabilizers still help — or instead become restrictive — when massively parallel simulation provides abundant, diverse replay data.

Method: Built on the FlashSAC backbone (Kim et al., 2026), WarpSAC varies three axes: (A) replay weighting via Sample Weight Decay (SWD), an age-biased sampler that assigns weight wt(i) = max(wmin, 1 − At(i)/Tdecay) to favor recent, policy-relevant transitions while a floor wmin preserves coverage; (B) parameter projection normalization, i.e., FlashSAC's column-wise Frobenius-norm renormalization of linear weights after each optimizer step (Norm ON/OFF); and (C) critic multiplicity, clipped double-Q (two critics, min-Q target) versus a single critic (Single-Q). SWD is applied as a regime-agnostic component in all variants, while normalization and critic count are matched to the data regime: WarpSAC-L (SWD, Norm ON, clipped double-Q) for CPU-scale/data-limited training, and WarpSAC-A (SWD, Norm OFF, single-Q) for GPU-parallel/data-abundant training; WarpSAC w/ Norm OFF is used as an intermediate ablation.

Key results:

• WarpSAC improves normalized score–step AUC over FlashSAC by 4.5% across nine CPU-scale environments and by 23.1% across fourteen GPU-parallel environments.
• On UnitreeG1TransportBox-v1, WarpSAC-A lifts success rate from 19.8% to 96.4%.
• On MuJoCo Playground, WarpSAC gains 19.1% in mean normalized wall-time AUC.
• Sim-to-real: WarpSAC reaches target Unitree G1 locomotion performance in ~35 minutes end-to-end on a single A800 GPU vs. ~55 minutes for FlashSAC, a 36.4% wall-clock reduction.
• Capacity ablations: with a single residual block, SWD raises return on humanoid-run from 209.93 to 467.39 (>2x), ~47% on humanoid-walk (627.07→924.39), ~21% on h1-hurdle-v0 (83.80→101.09), and ~17% on h1-reach-v0 (3018.97→3529.44); disabling normalization at 1-block capacity markedly improves G1 Flat and T1 Rough performance in MuJoCo Playground.

Why it matters / caveats: The paper reframes scalable off-policy RL as a "regime-matching" problem rather than stacking ever more conservative stabilizers — gains often come from removing components (dropping normalization or the second critic) rather than adding them, which also reduces compute. Caveats acknowledged by the authors: the choice between WarpSAC-L and WarpSAC-A is currently made offline per fixed regime rather than adapted online across a training run that spans regimes (e.g., pretraining then parallel fine-tuning), and the analysis is grounded only in the FlashSAC backbone and three specific axes, leaving other stabilizers (entropy weighting, target-network delay, gradient clipping, replay-ratio schedules) unexamined for the same regime-dependence.

Problem: Agent harness design (memory management, planning, action protocol, tool/skill orchestration) is currently manual, task-specific, and treated as a durable "ahead-of-time" artifact, so it cannot adapt instance-by-instance to the heterogeneous structure of individual tasks.

Method: JIT-Agent is a trained meta-agent (JIT-Agent-27B, built on Qwen3.6-27B) that generates an executable, task-conditioned harness on the fly for any frozen off-the-shelf agentic LLM, factoring every harness into four composable modules — memory (M), planning (P), action (A), and capability orchestration (F) — under a fixed protocol Π, with a supporting "HarnessFactory" codebase re-implementing 13 representative scaffolds (ReAct, Plan-and-Execute, ReSum, Flash-Searcher, GAM, MemoBrain, AggAgent, OAgent, AgentFold, HiAgent, DeepAgent, ROMA, AOrchestra) as a seed bank. Training is a three-stage pipeline: Stage I distills task-conditioned harness customization from a stronger teacher model via SFT plus a preference objective over reward/latency/cost; Stage II converts failed harness generations (compiler errors, interface mismatches, runtime exceptions) into bounded (≤2-round) repair trajectories for reliability; Stage III applies Evolutionary Group-Decoupled Policy Optimization (Evo-GDPO), a PPO-style, reward/latency/cost-decoupled RL objective that trains the model to propose harnesses that beat the current archive frontier, with an evolving harness bank retained across rounds. At inference, JIT-Agent supports static mode (parallel harness generation, pick one) and streaming mode (retrieves/updates a harness bank across a task sequence without updating model weights).

Key results:

• On 18 matched backbone–benchmark pairs, JIT-generated harnesses improve every case: GLM-5.2's 9-benchmark average rises 74.1→81.8 (+7.7), DeepSeek-V4-Flash's rises 66.7→75.5 (+8.8); largest single gains are DeepSeek-V4-Flash on DeepPlanning-Shopping (59.1→83.9, +24.8) and GLM-5.2 on DeepPlanning-Travel (62.8→83.0, +20.2).
• DeepSeek-V4-Flash + JIT-Agent surpasses GPT-5.6 on DeepSearchQA (+9.1), PinchBench (+8.7), and OdysseyBench (+4.3); GLM-5.2 + JIT-Agent tops 7 of 9 benchmarks (e.g., 93.9 on DeepSearchQA, 93.3 on PinchBench).
• In controlled harness comparisons (fixed backbone), JIT-Agent beats fixed harnesses (Claude Code, Codex, OpenCode, Hermes, NanoBot) in 4/6 backbone-benchmark settings while using the fewest tokens and lowest API cost in all 6 settings, cutting per-case cost 14.9–54.1% (avg. 36.0%) versus the cheapest fixed harness.
• Across 24 backbone-benchmark comparisons spanning DeepSeek V4, Qwen3.6, and Mimo-V2.5 variants, JIT-generated harnesses beat plain ReAct by an average of 7.6 points (10.2 for DeepSeek V4, 4.0 for Qwen 3.6, 8.6 for Mimo 2.5), showing transfer across model families.
• Streaming JIT (harness bank evolves across a task stream) finishes with higher cumulative accuracy than Static JIT on DeepPlanning-Shopping, DeepPlanning-Travel, and OfficeBench.

Why it matters / caveats: The paper argues harness intelligence is a trainable, transferable capability orthogonal to model scale — open-weight backbones with a JIT-generated harness beat frontier closed models (GPT-5.6, Gemini) on several benchmarks at lower cost. Caveats stated by the authors: the four-module protocol is deliberately more compact than production runtimes like Claude Code/Codex/DeepSeek Harness; JIT-Agent trails fixed harnesses in a couple of controlled settings (e.g., Claude Code by 3.1 pts on DeepSeek-V4-Flash AgentIF, NanoBot by 3.9 pts on Qwen3.6-Flash DeepSearchQA) despite using far fewer tokens; and DeepPlanning-Travel is the one benchmark column not led by a JIT-equipped model.

Problem: Native visual reasoning—where models solve problems by generating and updating images/video as the reasoning medium itself, rather than as inputs or final outputs—lacks scalable trainable tasks, reliable/reproducible evaluation, and controlled comparisons across generative substrates (image vs. video vs. interleaved).

Method: VBVR-Pro is a closed-loop suite built from 300 procedurally generated task generators (150 revised from prior work VBVR, 150 newly designed) spanning five cognitive faculties (perception, spatiality, transformation, abstraction, knowledge); each generator samples randomized parameters and a solver computes ground-truth supervision, with outputs rendered into aligned video, image (Last-Frame/Key-Frame/Multi-Frame regimes), and interleaved text-image modalities. For evaluation/reward, it implements deterministic, task-specific verifiable reward scorers (using classical CV: HSV color segmentation, contour detection, OCR, trajectory tracking) for 100 held-out tasks, replacing unreliable VLM-as-a-judge scoring. For RL, it fine-tunes models (e.g., Wan2.2, SenseNova-U1, ThinkMorph, FLUX.2, BAGEL, Qwen-Image-Edit) via LoRA/full fine-tuning and applies Coefficients-Preserving Sampling (CPS) within a GRPO-style group-relative policy optimization to enable semantic exploration in denoising trajectories, comparing RL with verifiable rewards (RLVR) against RL with VLM rewards (RLVLM) and SFT baselines.

Key results:

• Verifiable scorers reach ~0.60 per-vote agreement with human preferences (vs. GPT-5.5 at 0.54 and Gemini-3.1-Pro at 0.52), reaching ~78% of the human agreement ceiling of 0.77, while being the cheapest evaluator and fully reproducible (0% score change on repeat runs vs. 55–93% for VLM judges).
• Training on VBVR-Pro-Dataset improves all nine tested open-source models (image, interleaved, video) with an average overall gain of 0.290; ID gains average +0.401 and OOD gains average +0.179.
• The best fine-tuned model (VBVR-Pro-Wan2.2-I2V-A14B) shows consistent transfer gains of up to ~20 percentage points across seven external benchmarks (RISE-Video, V-ReasonBench, RULER-Bench, MME-CoF-Pro, VideoThinkBench, BabyVision-Gen, IntelligentVBench).
• In the RL experiments, RLVR reaches an overall score of 0.548 vs. 0.508 for RLVLM and 0.503 for SFT (OOD: 0.377 for RLVR vs. 0.345 RLVLM vs. 0.328 SFT), and RLVLM training stagnates/destabilizes (a drop at steps 400–500) while RLVR improves steadily.
• Ablations show removing intermediate visual states drops performance by 0.024–0.111, while removing/replacing intermediate text has a much smaller effect, and input-image removal in counterfactual tests collapses performance to 0.064 (from 0.638), indicating visual trajectories—not linguistic chains of thought—are the primary reasoning substrate.

Why it matters / caveats: The paper argues visual generation should be treated as a first-class reasoning substrate rather than just an output format, and provides infrastructure (data, verifiable scorers, RL recipe) to make this trainable and measurable at scale; it also documents concrete VLM-as-judge failure modes (imprecise perception, missed decisive errors, task misunderstanding) that undermine prior benchmarks. Caveat: even the strongest trained models remain well below human-level performance, and the tasks are procedurally generated/abstract, though transfer to real-world benchmarks (e.g., robotic pick-and-place, embodied reasoning) is demonstrated via nearest-neighbor analysis showing it isn't simple memorization.

Problem: In multi-teacher on-policy distillation (MOPD), the per-domain data mixture is fixed before training even though different domains converge at very different rates, so a static mixture over-trains fast-converging domains and under-trains slow-converging ones, wasting compute.

Method: D3-MOPD adds two components to a vanilla MOPD loop: an off-process "watcher" and a stratified data source, without touching the core training loop or loss. The watcher periodically (every n=10 rollout steps) turns each domain's reverse-KL history into a composite signal sk = remaining-gap (KL normalized against a seeded initial value, Eq. 2) × descent velocity (negative average relative KL change over R=3 non-overlapping windows of length W=10, clipped at zero, Eq. 4); this product is max-normalized and mapped to a mixture via a temperature-controlled softmax with a per-domain floor ε (Eq. 6) so no domain is fully starved. The stratified data source applies this mixture with largest-remainder rounding plus a batch-level jitter (η=0.30, uniform perturbation) to restore batch-to-batch variance since the mixture only updates every n steps. Validated on a Qwen3.6-35B-A3B student distilled from four GRPO-finetuned domain-expert teachers (Math, Code, Instruction Following, Tool-use) using the slime framework.

Key results:

• Closes 97% of the average student-to-teacher performance gap (normalized score 0.97) versus 63% for vanilla MOPD.
• Reaches vanilla MOPD's optimal average accuracy (61.4, hit at step 143) by step 47 — roughly 3× fewer rollout steps — and attains a higher peak of 62.3 at step 95.
• Per-benchmark gains at peak range from +0.2 on AIME 2025 (74.1 vs 73.9) to +2.8 on IFBench (48.9 vs 46.1); surpasses the specialist teacher on 3 of 7 benchmarks (HMMT November 2025, IFEval, OJBench C++).
• Ablations: removing velocity gives 61.41 (peaks early, step 127), removing gap gives 61.46 (peaks late, step 255), removing jitter gives 61.63 (−0.71 vs full method, worst on code benchmarks), removing smoothing (R=1) gives 62.17 — full D3-MOPD (composite signal + jitter + R=3 smoothing) reaches 62.34, the best overall.
• Domain sampling ratios track convergence: Code is downsampled from 0.25 to ~0.15 as it plateaus fastest, budget shifts to Math (up to ~0.50 during steps 60–127) then to Instruction Following (~0.55) and Tool-use (~0.50) after step 150, forming an implicit curriculum.

Why it matters / caveats: The method is framed as "zero-overhead" since it only modifies the data loader/scheduler (running as a detached async process) and repurposes a signal (reverse-KL) already computed by the training loss, making it compatible with existing MOPD loss and teacher-training variants. Results are from a single model family/domain set (K=4, Qwen3.6-35B-A3B); the paper argues benefits should grow with more domains but this scaling claim is not empirically tested beyond K=4 in the provided text.

Problem: It is unclear whether the reported gains of next-chunk reasoning RL (which trains models on no-CoT data such as worked solutions and textbook derivations by rewarding prediction of the next token/sentence) over SFT actually come from the RL formulation itself, since prior work only compared it against a weak no-CoT-only SFT baseline rather than one that also preserves long-CoT behavior.

Method: The authors compare, from the same Qwen3-30B-A3B-Base checkpoint, five strategies for leveraging no-CoT data (421K AoPS solutions, ~0.53B tokens) alongside long-CoT data (152K DeepSeek-V3.2-generated trajectories, ~1.95B tokens): (1) Reasoning SFT (long-CoT only baseline), (2) Sequential SFT (no-CoT SFT stage then long-CoT SFT stage), (3) Mixed SFT (a single SFT stage jointly trained on no-CoT and long-CoT data — the paper's proposed missing baseline), (4) Next-Token Reasoning (NTR, instantiated as RPT) which uses GRPO with prefix-matching rewards on the top-20% highest-entropy tokens, and (5) Next-Sentence Reasoning (NSR, instantiated as RLPT) which uses GRPO with a gpt-oss-120b generative reward model judging sentence-level semantic match. All five are followed by an identical RLVR stage (GRPO, rule-based exact-match rewards on DAPO-Math-17K).

Key results:

• Mixed SFT reaches the highest post-RLVR average of 67.4 across six in-domain benchmarks (AIME 24/25/26, HMMT 25/26, IMO-Answer), vs. 64.2 for NTR and 63.6 for NSR, and also leads on OOD benchmarks HLE (9.24), GPQA-Diamond (60.98), and MMLU-Pro (75.84).
• NTR and NSR require over 60× more GPU-hours than SFT on the same no-CoT data (4608.1h and 4283.7h vs. 65.6h), so they are neither more accurate nor cheaper.
• Mixed SFT starts from the lowest pre-RLVR accuracy (27.5 avg, ~20 points below other methods) but ends with the highest post-RLVR accuracy (61.1), a 33.7-point pre-to-post gain, over 3× larger than any other method (others rise only 3.3–10.3 points).
• Mechanistic analysis: for NTR, reasoning accuracy on high-entropy tokens climbs from 0.29 to 0.55 while token entropy stays flat, and ~0.48 no-reasoning accuracy shows entropy filtering doesn't select genuinely reasoning-hard tokens; NTR/NSR traces collapse into template-like local completion, and suppressing this collapse via entropy-preserving interventions still yields a slightly lower ceiling than vanilla NTR (e.g., AIME25 84.4 vs 83.7).
• Inserting NTR or NSR after Mixed SFT (before RLVR) adds no gain over Mixed SFT + RLVR directly (e.g., AIME24 87.50 unchanged vs 86.35/87.21). A no-CoT retention probe shows Mixed SFT+RLVR scores 68.63 vs. Sequential SFT+RLVR's 59.19, indicating Sequential SFT's second (long-CoT) stage overwrites/forgets no-CoT knowledge from its first stage.

Why it matters / caveats: The paper argues next-chunk reasoning RL's benefits over plain no-CoT SFT are largely an artifact of comparing against an inadequate baseline; a simple single-stage Mixed SFT is simpler, cheaper, and reaches a higher post-RLVR ceiling, and pre-RLVR accuracy is a misleading proxy since Mixed SFT's low intermediate score is a transient format-mismatch artifact (explicit <think> markers from long-CoT vs. unstructured no-CoT solutions) that RLVR repairs. Caveats stated by the authors: they use a single fixed no-CoT/long-CoT mixing ratio (no sweep), and both the training corpus and benchmarks are restricted to mathematics, so generalization to code, science, or multilingual domains is untested.

Problem: Existing video generation models are built around fixed temporal windows, so they forget character/voice identity across shots, drift when conditioned on their own generated history, and cannot translate heterogeneous navigation inputs into consistent, controllable long-horizon motion.

Method: The paper presents JoyAI-Echo-1.5, a unified audio-visual system with two variants built on an LTX-2.3-based bidirectional diffusion backbone. The long-video variant uses composable cross-shot memory: visual memory sampled as single frames per prior shot plus speaker cues from speech-filtered full-shot audio (via an MSST speech-separation operator), injected through separated RoPE coordinate regions and trained jointly across T2AV/I2AV/MT2AV/MTI2AV conditioning. The world-model variant converts heterogeneous navigation/action inputs into calibrated metric 6-DoF camera trajectories injected via Unified Camera Positional Encoding (UCPE), trained through a 3-stage curriculum (AV continued pretraining, action-only SFT of the UCPE pathway, then joint fine-tuning). Both variants are converted from bidirectional multi-step diffusion into causal few-step (e.g., 8-step or 4-step) autoregressive generators via audio-visual teacher forcing followed by short- and long-horizon Self-Gradient Forcing (SGF) combined with distribution matching distillation (DMD), using asymmetric optimization (full fine-tune for video, LoRA for audio/cross-modal), task-adaptive audio loss weights, RMS energy and adversarial audio losses, and a sink-plus-FIFO causal KV cache with a lightweight state-space "causal memory" module for beyond-window persistence. A separate Director Agent handles shot-wise story planning, prompt enhancement, memory retrieval/admission, and review; a MeanFlow-distilled arbitrary-step super-resolution stage upsamples final output.

Key results:

• On a 100-story/3,000-shot long-video benchmark, JoyAI-Echo-1.5 beats JoyAI-Echo-1.0 and other baselines (JavisDiT++, LTX-2.3/2.5, ShotStream+MMAudio, StoryMem+MMAudio, HappyOyster) on 6 of 7 metrics, including ViCLIP 0.8264, Self-CIDS 0.7937, Voice 0.8524, Imaging 0.7467, CLIP 0.2868, and speech Recall 0.9674.
• In a human GSB study vs. HappyOyster, JoyAI-Echo-1.5 was preferred most heavily on audio-visual synchronization (48.4% vs. 20.3%) and story-instruction following (38.6% vs. 17.7%).
• The world-model variant ranks first on the 158-case WBench Navigation leaderboard with an Average score of 81.7 (Consistency 89.8), and its distilled 4-step causal variant ranks second overall (81.0) while achieving the top Interaction score of 87.9.
• On SANA-WM-Bench, JoyAI-Echo-1.5 achieves the highest VBench scores (83.91 Simple / 83.96 Hard, short-horizon) and, under the official 961-frame (60s) long-horizon protocol, the lowest translation/CMC errors and highest revisit PSNR (15.10 dB) on the Simple split, with ∆IQ near zero (0.02) indicating minimal quality degradation over time.

Why it matters / caveats: The results suggest that persistent cross-shot memory, geometry-aware trajectory control, and rollout-aware (self-generated-history) training can jointly address identity drift and control degradation in long-horizon generation without sacrificing per-shot quality or inference efficiency, offering a practical path toward extended narrative video and explorable interactive world models. The evaluation relies substantially on the authors' own curated benchmarks and baselines (some, like HappyOyster, evaluated via an external interface), and rotation-error accuracy on the Hard-Trajectory split still trails SANA-WM in one setting.

Problem: In hint-based reinforcement learning for long-horizon LLM agents, existing methods treat the "guidance depth" (how much of an expert trajectory prefix to retain before rollout) as a single deterministic scalar per task, which either ignores per-task heterogeneity (schedule-based methods) or requires costly extra probe rollouts (per-sample search methods).

Method: The authors first show diagnostically (on Qwen2.5-1.5B-Instruct/ALFWorld) that informative guidance depths form a band around an optimal point whose training-signal profile (Bernoulli variance of success rate) is well fit by a Gaussian (σ=0.22, R²=0.92), rather than concentrating at one point. Based on this, they propose Agent-G², which models each task's guidance ratio as a draw from a per-task Gaussian N(µᵢ, σᵢ²) whose center and spread come from a global-local decomposition: a global baseline µ_global tracks overall policy progress (updated via a sign-based step using batch accuracy vs. a target of 0.5), while per-cluster (tasks clustered offline by expert-trajectory length) EMA statistics Aₖ (success level) and Vₖ (variance) adjust the center and widen the spread. One depth is sampled per task, converted into a prefix length, and the same GRPO rollouts used for policy optimization also refresh the schedule statistics — requiring no probe rollouts or learned depth predictor. Training combines the GRPO loss with a teacher-forced auxiliary SFT loss on the sampled expert prefix (L = L_GRPO + η·L_aux).

Key results:

• On ALFWorld, Agent-G² reaches 95.3% overall success at 1.5B and 98.4% at 7B, beating the strongest hint-based baseline (Target-acc) by 1.5/2.3 points, the strongest Aux-RL baseline (RLVMR) by 7.4/6.6 points, and the strongest probe-based baseline (Enumeration) by 9.3/2.3 points.
• On WebShop, Agent-G² achieves a 92.3 reward score at both scales with 78.9% (1.5B) and 84.4% (7B) final-purchase success, the best among non-probing methods.
• Achieves this at under one-third the rollout cost of per-sample probing (88s/step vs. 285–425s/step for Binary Search/Enumeration, i.e., 3.24–4.83× cheaper) and reaches scheduled-baseline accuracy in roughly half the gradient steps.
• Ablations: replacing the Gaussian sample with the deterministic mean drops success from 95.3% to 89.8%; using a variance-matched uniform distribution instead of Gaussian drops it to 88.3%; collapsing all clusters into one (K=1) drops it to 89.1% (Long tasks fall 29.3 points); removing the auxiliary SFT loss drops it 8.6 points; removing the GRPO loss entirely (leaving only prefix imitation) collapses performance to 26.6%.

Why it matters / caveats: The approach reframes guidance-depth selection as covering a neighborhood/distribution rather than pinpointing a single value, achieving per-task adaptivity without the rollout overhead of probing methods, and notably lets the 1.5B model with Agent-G² surpass all 7B non-probing baselines. Stated limitations: it requires one expert trajectory per training task (does not extend directly to settings without such demonstrations), the Gaussian parametric family was validated only on the two benchmarks tested (ALFWorld, WebShop) and may not suit multimodal/skewed depth profiles, and the difficulty clusters are defined offline by trajectory length and do not adapt online as the policy improves.

Problem: In multi-teacher on-policy distillation (M-OPD), where domain-specialized RL teachers jointly supervise one student via dense token-level rewards, naive combination fails to integrate all teacher capabilities into a single student even when routing is oracle-perfect, and the underlying cause was previously not understood.

Method: The authors build a controlled M-OPD pipeline on SmolLM3-3B-Base (mixed-domain SFT on math/code/IF data, then three domain RL teachers via GRPO-style PPO on DAPO-Math-17k, DeepScaler-24k, and Nemotron-IF-RL-46k, then multi-teacher on-policy distillation with hard oracle routing and a dense top-k (k=16) token-level teacher–student log-prob-difference reward placed in PPO's advantage slot). They diagnose the integration gap as a token-level optimization-budget misallocation (not teacher disagreement) and propose Open-MOPD, which adds three mechanisms: (1) token-share balancing, which reweights each domain's loss by gd⋆/s_d^tok to equalize gradient-token share across domains regardless of response length; (2) gap-following allocation, which multiplies the weight by a clamped factor (m_d/m_ref)^α (α=1) to route more optimization budget toward domains with larger remaining teacher–student gap; and (3) student reward refresh, which recomputes the student-dependent term of the reward before each of K inner PPO updates on a shared rollout batch (reusing cached teacher log-probs) to eliminate staleness, following an idea from AsyncOPD.

Key results:

• Naive M-OPD recovers only 35.6% of the improvement from mixed-SFT to RouteRL (total score 28.05 vs. RouteOPD 31.55 vs. RouteRL 32.35); instruction-following (IF) falls 6.16 points below its RouteOPD reference, 3.3× the math gap (1.89 points).
• Diagnosed cause: IF makes up 20.3% of prompts but only 0.99% of gradient tokens (avg response length ~409 tokens for IF vs. ~10,500 for math/code, a >25× disparity); early per-token reward magnitude differs 4.9× across domains (0.019 math, 0.063 code, 0.091 IF).
• Teacher disagreement is ruled out as the dominant bottleneck: mean teacher disagreement c_t = 0.126 nats (well below the 1-nat conflict threshold), only 0.62% of tokens exceed it, and masking/consensus interventions on high-conflict tokens reduced total score by 0.52–0.83 points rather than helping.
• Cumulative ablation (Table 4): token-share balancing alone +1.17 points (mostly IF); adding gap-following allocation +1.89 total; switching to K=4 throughput setting and adding token-share+gap +2.38 vs. control; full Open-MOPD (share+gap+refresh) reaches 31.24 total, +3.19 over the matched K=4 baseline.
• Open-MOPD raises recovery rate from 35.6% to 83.4% of the mixed-SFT→RouteRL headroom, narrowing the integration gap from 3.50 to 0.31 points, while reward refresh adds negligible runtime overhead (dense-reward computation 27.3s vs. 27.8s of a 1298s/1313s outer step at K=4).

Why it matters / caveats: The paper reframes multi-teacher capability-integration failure as a budget-allocation problem (sequence-length disparity, uneven convergence rates, reward staleness under batch reuse) rather than gradient conflict, and gives three lightweight, separately-validated fixes; it is a fully open, reproducible academic-scale (8×A100-80GB) recipe with released code/checkpoints/data, but results are demonstrated on one 3B model with three domains and oracle (not learned) routing, and Open-MOPD's 83.4% recovery still falls short of RouteOPD/RouteRL's full deployment-time performance.

Problem: State-of-the-art Vision-Language-Action (VLA) models like π0.5 operate on a single observation frame at a time, which prevents them from retaining past observations and limits precise spatial perception needed for tasks requiring memory or fine-grained geometric reasoning.

Method: StreamPI treats each (visual observation, language instruction) pair as an atomic temporal unit, applying bidirectional attention within each pair for cross-modal fusion and causal attention across pairs (via a KV-cache) to preserve autoregressive streaming inference, so the instruction acts as a persistent semantic anchor and is never diluted by accumulating visual tokens. It requires no new parameters, instead restructuring the attention mask over the pretrained π0.5 backbone and relying on the LLM's length-extrapolation ability to extend from single-frame to multi-frame inference. Training uses a random-interval streaming strategy (base interval δ̄ perturbed by ε ~ U(−Δ, +Δ), clipped to [δmin, δmax]=[3,7]) plus temporal masking (randomly masking the earliest k of T frames) to match asynchronous real-robot deployment; models are fully fine-tuned from π0.5 with T=3/5 streaming frames on 8 H100 GPUs (batch size 256, 30k iterations on LIBERO; batch size 128, 50k iterations on real-robot tasks).

Key results:

• Real-robot tasks: StreamPI beats π0.5 by +33.3% (Shell Game, 80.0% vs 46.7%), +36.6% (Rolling Object Grasping, 63.3% vs 26.7%), +26.7% (Pen Insertion into Narrow Bottle, 66.7% vs 40.0%), and +32.0% (Cup Insertion into Cup Sleeve, 92.0% vs 60.0%).
• LIBERO benchmark: StreamPI (T=5) reaches 98.3% average success rate vs. π0.5's 96.9% (+1.4%), with the largest gain on LIBERO-Long (+2.6%) and no improvement on LIBERO-Spatial.
• CALVIN benchmark: StreamPI (T=5) achieves an average sequence length of 4.547 vs. 4.313 (π0.5) and 4.090 (MemoryVLA), with 85.0% success at the 5th task position vs. 79.5% (π0.5) and 69.4% (MemoryVLA).
• Ablations: replacing intra-pair bidirectional attention with causal attention drops LIBERO-Long by up to −5.6% (T=5); random-interval training improves average success rate from 96.4→97.5 (T=3) and 97.0→98.3 (T=5) over fixed-interval (δ=1) training.
• Inference efficiency: extending from 1 to 5 streaming frames adds only 9.2 ms of latency (94.4±3.4 ms → 103.6±6.3 ms on an RTX 4090), rising to 117.9±16.5 ms at 10 frames.

Why it matters / caveats: The method adds temporal/streaming reasoning to a strong single-frame VLA foundation model with zero new parameters and near-constant inference cost via KV-caching, making it a practical drop-in upgrade path; gains are most pronounced on memory-dependent and long-horizon tasks, while LIBERO is largely saturated (baseline already >95%) so improvements there are modest and absent on purely spatial (single-frame-sufficient) tasks.

Problem: Existing video-understanding benchmarks measure whether MLLMs get the right answer but not whether they faithfully follow the diverse, often multi-constraint and conditional instructions that accompany real-world video queries.

Method: The authors build a taxonomy of four instruction templates—Single, Multi, Selection, and Nested—spanning 32 fine-grained video task types and 39 manually curated constraints (22 semantic, 17 format), applied to 700+ curated videos (~49 hours total, 10s–10min each, 10 domains). Data is built via a semi-automatic pipeline: an MLLM extracts a global description and timestamped fact list per video (processed in 1-minute segments with a shared entity memory for long videos), facts are transformed (edit/negation/combined) to construct true/false branch conditions for Selection/Nested instructions, and constraints are sampled to generate Single/Multi instructions—yielding 1.5K human-verified samples. Evaluation uses a hybrid checklist protocol: task-level coverage (did the model address the "active" instruction/branch) gates two metrics—TCSR (average constraint satisfaction rate) and TISR (all checklist items satisfied)—judged via LLM-as-Judge (Qwen3.5-397B-A17B-Instruct as main judge) or deterministic programmatic verifiers.

Key results:

• Gemini-3-Pro is the best overall model: 76.5 TCSR / 54.5 TISR; best open-source model Qwen3.5-397B-A17B-Think reaches 69.6 TCSR / 46.1 TISR, trailing by 6.9/8.4 points.
• Nested instructions are hardest: even Gemini-3-Pro scores only 53.7 TCSR/46.0 TISR, and the best open-source model gets just 33.0 TCSR/28.2 TISR.
• TISR is consistently lower than TCSR across all >20 evaluated models, showing models satisfy some but not all constraints simultaneously.
• Weaker models (e.g., GPT-5.4) collapse sharply on conditional instructions: 21.1 TCSR/16.9 TISR on Selection and 12.1/7.6 on Nested, versus 72.8/34.7 on Single.
• Models perform substantially worse on semantic constraints (e.g., Transition Boundary, Temporal Anchor, Temporal Scope, Action-Relative Selection) than on format constraints.

Why it matters / caveats: Strong video-understanding accuracy does not translate into faithful instruction adherence—models particularly struggle with many constraints, semantic (video-grounded) constraints, and picking the correct conditional branch/path, arguing instruction following should be a first-class evaluation axis for video MLLMs. Judge-model choice was checked for robustness (a smaller Qwen3.5-35B-A3B judge gave consistent trends, per Appendix A.1).

Problem: Vision-language models can produce fluent but visually unfaithful answers, and scalar outcome rewards used in RL post-training cannot identify which visual facts are grounded, which reasoning steps are valid, or which instruction constraints are missed — a credit-assignment failure.

Method: The authors introduce Visual Rubrics-Based Reinforcement Learning, which decomposes reference responses into atomic propositions labeled along three dimensions — Visual Faithfulness (VF), Reasoning Consistency (RC), and Instruction Following (IF) — each tagged Essential/Important/Optional/Pitfall with a numeric importance weight. Starting from an SFT checkpoint (Qwen3-VL-8B-Instruct fine-tuned on the public OpenMMReasoner-SFT-874K corpus using OpenMMReasoner's cold-start recipe), they build V-Rubrics 50K (50,248 examples from 17 visually grounded sources, difficulty-stratified via rejection-sampling into 18,121 hard/25,306 medium/6,821 simple examples) with every example annotated by Gemini-3-Pro under a structured prompt. Training uses GRPO where a blended reward combines a final-answer term and an importance-weighted rubric term (α-weighted), with component-wise, prefix-localized advantages: each rubric item's advantage is standardized separately and applied only to the response tokens up to the aligned supporting-evidence span (via a prefix mask), rather than broadcasting one scalar sequence-level reward. The LLM judge for training rewards is Qwen3-VL-235B-A22B.

Key results:

• On general/knowledge benchmarks, rubric-based GRPO improves Overall Avg. by 1.79 points over answer-only GRPO (66.25→68.04, ~2.7% relative), with knowledge average rising from 59.35 to 61.88.
• On visual math/chart/logic benchmarks, rubric-based GRPO improves Overall Avg. by 4.00 points over SFT (~6.8% relative), with strongest gains on MathVision, DynaMath, WeMath, and LogicVista.
• Ablation (Table 3): answer-only sequence-level = 66.25; answer+rubrics sequence-level = 67.74 (+1.49); answer+rubrics component-wise prefix-localized = 68.04 (+1.79), confirming the combined design beats scalar rubric aggregation.
• Rubric-trained model reaches MMMU Val 70.56 / MMMU-Pro 58.15 vs. answer-only GRPO's 68.00 / 55.72.

Why it matters / caveats: Rubrics turn visual grounding from a post-hoc diagnostic into structured training supervision, giving fine-grained partial credit rather than one scalar signal, with gains concentrated on tasks requiring grounded intermediate reasoning (not a uniform benchmark lift — scalar GRPO still wins on MathVerse V/O and CharXiv reasoning). Authors note limitations: rubric quality depends on automatic generation/judge-model verification, prefix-credit localization relies on fuzzy sentence alignment (approximate, not exact token-level supervision), and judge-model family bias may arise since Qwen-family judges score Qwen-family policies.

Problem: Existing GUI agent benchmarks evaluate Android agents under stable, clean conditions and lack systematic evaluation of agent robustness against dynamic runtime anomalies (e.g., pop-ups, rendering glitches, reasoning hallucinations, grounding errors, execution loops) that occur in real-world deployment.

Method: The authors build AnTrap on top of AndroidWorld, extending it to 236 tasks with stochastic parameters, and introduce a taxonomy (STAR) of runtime anomalies organized into four layers—State, Thinking, Action, Round—with ten fine-grained subcategories (e.g., External Interruption, Visual Obscuration, Temporal Conflict, Visual Hallucination, Grounding Error, Type Mismatch, Intent Deviation, State Deadlock, Context Disruption, Loop). A runtime injection pipeline intercepts the agent's ⟨State, Thinking, Action⟩ execution loop during live dynamic execution and injects traps via a "trap toolbox" (image-level UI edits, broadcasted APK pop-ups, ADB hooks, MLLM-generated content, OpenCV-based screen manipulation) while enforcing stochastic injection timing/frequency and preserving task solvability. Agents are evaluated with rule-based task success rate under Pass@3, and the team also runs online GRPO training (UI-TARS-1.5-7B and GUI-Owl-7B) in both the original (clean) and AnTrap (adversarial) environments to test whether adversarial RL can teach robustness.

Key results:

• 16 agentic models from 7 organizations were evaluated; every model's average success rate under trapped conditions fell below its clean-environment baseline (universal vulnerability).
• Top proprietary model Claude-Sonnet-4.6 dropped from 74.2% (original) to 66.5% average under traps; GUI-Owl-1.5-32B-Think dropped from 69.5% to 62.4%.
• Human annotators scored 93.4% average across subcategories, far above all evaluated models.
• Reasoning/thinking models did not show better robustness than instruct counterparts: Qwen3-VL-8B-Thinking dropped 6.1 points (62.7%→56.6%) versus its Instruct version's 5.8-point drop (52.1%→46.3%); GUI-Owl-1.5-32B-Think lost 7.1 points versus 5.8 for the Instruct 32B version.
• GRPO trained in the original (clean) environment gave negligible robustness gains against traps (S-layer +1.2–1.7%, T/R-layer under +1.0%), while GRPO trained directly in AnTrap gave much larger gains for single-step traps (S-layer +8.1–11.0%, A-layer up to +8.5%) but only modest gains for T-layer (+4.2–5.1%) and near-zero gains for R-layer, especially Loop traps (under +1.0%).
• Human validation on all ten subcategories found 91% of tasks satisfied all three criteria (original solvability, preserved solvability after injection, trap realism); failing tasks were revised before inclusion.

Why it matters / caveats: The results show single-step traps at the state and action layers are largely "environment-learnable" via adversarial RL, but deep multi-step contextual traps (state deadlock, loops, context disruption) reflect intrinsic reasoning-bottlenecked limitations that adversarial training alone does not fix, pointing to a need for better long-horizon/meta-cognitive self-monitoring in agents. The authors note a limitation: due to the cost of annotating and validating live task initialization/evaluation, AnTrap covers only 236 base tasks, which, while diverse, may not fully represent the space of real-world anomalies.

Problem: When a coding agent switches models mid-task (escalating to a stronger, costlier model or downshifting to a cheaper one), the receiving model must continue a "non-native" trajectory it did not produce, and it is unclear how this handoff affects quality and cost.

Method: The authors extend the mini-SWE-agent scaffold with a wrapper containing a prefix model and a suffix model sharing one agent loop and Docker environment, and evaluate on all 500 SWE-bench Verified instances using two model pairs: Claude Haiku 4.5 (LC) / Opus 4.7 (HC) and GPT-5.6 Luna (LC) / Sol (HC). They vary handoff direction (escalation LC→HC, downshift HC→LC), switch timing (seven difficulty-calibrated percentiles: 5,10,15,25,35,45,50), and handoff interface — Raw (full trajectory transfer), Compact_pre (prefix-model summary), Compact_suf (suffix-model summary), and Traj-drop (no trajectory, only working-tree state) — while always preserving the working tree. They also test two restart controls (Abort+HC fresh, LC-full+HC-full) and extend the study beyond coding to LiC (incremental requirements) and BrowseComp (progressive search evidence) under Raw handoff only.

Key results:

• Scale: 58 configurations per model family, 58,000 agent runs, 2 million LLM API calls, 36 billion tokens processed.
• Raw escalation recovers less than half of HC's quality advantage (QRec = 47% for Claude, 36% for GPT) while costing ~4.0x (Claude) and ~6.1x (GPT) more than LC-only; for Claude, Raw ($1.61) even costs more than restarting HC from scratch after aborting LC ($0.90).
• Raw downshift offers a favorable trade-off: for Claude, pass rate rises from 54.6% to 65.6% while cost rises only from $0.41 to $0.51 (retaining 80% of LC's cost advantage); for GPT, Raw retains 79% of HC's quality advantage but only 14% of LC's cost advantage.
• Interface effects are direction-dependent: for escalation, Traj-drop raises QRec from 47%→64% (Claude) and 36%→84% (GPT); for downshift, Traj-drop is the worst interface, recovering only 28% (Claude) or 53% (GPT) of the LC–HC quality gap versus 50%/79% for Raw.
• On hard SWE-bench tasks (Claude), reduced-context escalation interfaces become cheaper than HC-only (retaining 12–42% of LC's cost advantage) while recovering 65–74% of the quality gap, whereas Raw never becomes cost-effective.
• On LiC (late-arriving requirements), escalation recovers 86% of HC's quality advantage vs. 31% for downshift, reversing the coding-benchmark pattern; on BrowseComp, GPT escalation nearly closes the quality gap (QRec=95.8%) but has negative cost savings (CSRet=−30.0%).

Why it matters / caveats: The findings suggest model handoffs should be treated as a distinct inference-time design problem (what trajectory information to transfer) rather than just an extension of model routing (which model acts next). Caveats stated by the authors: only two model pairs and primarily one benchmark (SWE-bench Verified) are studied; interface findings (Compact/Traj-drop) are established mainly in the coding setting since the LiC/BrowseComp extensions use Raw handoff only; hard-difficulty results have small sample sizes (N≈24-27 per cell) and are called exploratory; single episodes per task/configuration mean no variance estimates across repeated runs; and dollar-cost conclusions depend on current provider pricing.

Problem: Test-time self-evolution for UI-to-code generation is unstable because of "visual repair coupling," where a local code edit meant to fix one visual mismatch can propagate through layout, style, and component dependencies and degrade previously-faithful regions.

Method: The authors propose RubSE (Rubric-guided Self-Evolution), which represents visual feedback as structured, typed rubrics (title, type, description) drawn from a five-aspect taxonomy (LAYOUT_GEOMETRY, SPACING_DENSITY, TYPOGRAPHY_TEXT, STYLING_VISUAL, COMPLETENESS) rather than free-form critique. Each refinement round runs three atomic operations: EVOLVE (a VLM call generating K typed candidate rubrics describing possible visual repairs, excluding issues already in history), SELECT (a VLM call choosing one prioritized rubric as the localized repair target), and HISTORY (appending the selected rubric to an append-only per-instance history used as an avoid-list for future EVOLVE calls). The chosen rubric conditions the code generator's next revision (ct = Gθ(x, ct−1, rt−1, λ*t)); evaluation uses a frontier VLM judge (GPT-5.2) producing an overall 0–100 score and a 1–7 Likert aspect-mean score, averaged over three judge runs.

Key results:

• Across 6 VLMs (GPT-5.4, GPT-5.2, Claude-Sonnet-4.5, Qwen3-VL-32B-Instruct, Qwen3.5-9B, Qwen3.6-35B-A3B) and 3 benchmarks (Design2Code, Design2Code-HARD, UI2Code-Real), RubSE beats naïve self-evolution in 15/18 final-round settings, with average gains of +1.20 overall score and +0.11 aspect-mean score at round 10.
• At best-round, RubSE wins in 14/18 settings with an average gain of +1.13 overall points; frontier models show the largest final-round effect (+1.90 judge, +0.16 aspect).
• Trajectory collapse (≥8-point overall drop plus ≥0.35 aspect-mean drop) falls from 18.9% to 12.8% on average for frontier VLMs, with recovery rate rising from 20.7% to 32.8% for two of three; for Qwen models collapse rose slightly (14.8%→18.1%) but recovery improved (23.5%→30.2%).
• A pairwise human evaluation on 60 UI2Code-Real samples preferred RubSE's round-10 outputs over naïve self-evolution for both GPT-5.2 and GPT-5.4 (p < 0.01).
• RubSE costs 1.60× the API cost of naïve self-evolution with GPT-5.4, and only 2.5% higher inference latency with Qwen3.5-9B under vLLM.
• GPT-5.4-generated rubrics (more global-structure/action-oriented: 89–91% global-structure cues vs. 68–71% for Qwen self-rubrics) transfer to and improve weaker Qwen code improvers' self-evolution.

Why it matters / caveats: RubSE offers a lightweight, training-free way to stabilize test-time self-refinement for UI-to-code generation by decoupling "what's wrong" from "what to fix now," directly addressing the visual repair coupling failure mode. Caveats stated by the authors: evaluated only on 3 frontier and 3 open-source models plus HTML/CSS webpage generation (other model families/UI languages untested); RubSE does not guarantee code correctness and may introduce syntax/runtime errors; VLM-based judging is not perfectly stable and can diverge from human judgment on subtle visual differences in later rounds.

Problem: Existing benchmarks evaluate whole-repository migrations with behavioural test suites alone, which cannot distinguish a genuine migration from an agent that simply hands back (or copies) the original implementation to make tests pass ("Blindness").

Method: The authors build SWE Refactor Bench, 20 whole-repository migration tasks drawn from real open-source infrastructure (e.g., SQLite, zlib, libsodium, GraphHopper, cmark), spanning 4 debt classes — language (7 tasks), framework (7), platform (3), and build toolchain (3) — with 6–30 hour agent time budgets and 867,062 total source LoC. Each submission is scored by a three-stage protocol: Stage I "Migration Audit" (an LLM judge, 3 samples with majority vote, answers prompt-written criteria about whether the old stack is actually gone; any failed criterion vetoes the run), Stage II "Behavioural Tests" (a fixed suite of 130,118 checks recorded from the original repository's execution, requiring a 100% pass rate), and Stage III "Agentic Verification" (6 independent coding agents, one hour each, generate executable differential tests against the original vs. migrated codebases; a submission is rejected only by a counterexample that passes on the original and fails on the migration, reproducible 3 times). The composite score formula multiplies a Stage I/II gate (0.4 weight) by a linear Stage III term (0.6 weight, based on how many of 6 verifiers found no counterexample).

Key results:

• Across 520 runs from 8 frontier models / 26 model-effort configurations, only 28/520 (5.4%) pass all three stages, and 13 of 20 tasks receive no accepted solution.
• Best configuration is claude-opus-5 at xhigh effort, scoring 47.0/100 (5 acceptances out of 20 runs); next best are gpt-5.6-sol (28.5) and kimi-k3 (19.5).
• Of 340 runs passing Stage I, 58% reach 99% of fixed checks but only 26% reach 100%; among the 88 runs passing every fixed check, 60 (68.2%) are still defeated by at least one of the 6 agentic verifiers.
• Migration completeness and behavioural correctness are distinct failure modes: 30 runs preserved behaviour by skipping the migration (stopped at Stage I), while 252 runs completed the migration but broke behaviour (stopped at Stage II).
• Capability varies sharply by category: mean score 31.4 on build-toolchain rewrites vs. only 5.6 on language rewrites; three models (gpt-5.6-luna, dsv4-flash, glm-5.2) achieved zero accepted solutions despite producing some runs that passed every fixed check.

Why it matters / caveats: The paper demonstrates that behaviour-only evaluation systematically overrates coding agents on migration tasks (fixed-suite "perfect scores" can mask untouched or merely-wrapped code), and shows current frontier agents are far from reliably completing whole-repository stack migrations. The authors validate their own instrument via human annotation (89.7% agreement, κ=0.795, with judge errors skewed toward being too strict rather than too lenient) and note results establish a capability gap on these 20 specific tasks rather than ranking migration difficulty in general.

Problem: Video-based world models learn dynamics only from visual observations, which show outcomes but not the underlying knowledge, rules, and mechanisms governing world evolution, making it hard to maintain persistent consequences and support coherent, open-ended world evolution.

Method: Code World Model decomposes world state into an executable state and a visual state: a coding agent (GPT-5.6 Sol at inference) governs world evolution by writing/revising code that performs high-frequency deterministic updates (positions, collisions, rules) while the agent itself handles sparse high-level reasoning; this executable state is compiled by a lightweight deterministic compiler into a "proxy" — a coarse spatiotemporal representation (entity positions, poses, trajectories, camera motion) rendered as a low-resolution proxy video — which, together with structured text, conditions a video model (MiniMax-H3 Ref2VA backbone) to generate high-fidelity RGB observations. The video model is fine-tuned with rank-128 LoRA (~596M trainable parameters) across all 50 transformer blocks on paired proxy–RGB gameplay data.

Key results:

• Trained on 157 GTA V gameplay takes (~5.6 hours of source video), sampled into 9,420 five-second clips (124 frames, 1344×768, 24 FPS) with aligned 336×192 proxy sequences.
• Training used 8×H800 GPUs, AdamW, batch size 8, 3 epochs / 3,534 optimizer steps, LR 2e-5 → 1e-6 cosine decay.
• The proxy uses 1/4 resolution per spatial dimension (1/16 the tokens) of the target video, adding negligible inference overhead.
• Qualitative results show that after LoRA fine-tuning on this small dataset, the video model generalizes to diverse characters, environments, motions, and camera trajectories not in the training data while closely following proxy-specified spatiotemporal structure.
• Long-video inference uses overlapping 124-frame windows with 34-frame overlap (90 new frames per window) to extend generation length while preserving identity via a reused GPT Image 2 appearance anchor.

Why it matters / caveats: The approach offers a new decomposition — code for persistent, rule-consistent world logic and video models for flexible high-fidelity visual realization — as a path toward open-ended world models, with a real-world data pipeline demonstrated on KITTI-360 requiring no action or camera labels. Authors note two limitations: compute-limited training scale (small data, no autoregressive real-time generation) and that current coding agents still struggle to build complex game mechanisms fully from scratch, so the prototype uses existing AAA game code as templates rather than demonstrating fully autonomous world construction.

Problem: Modern dynamically-composed software (plugin systems, self-evolving agent harnesses) lacks formal foundations for safely adding/removing components at runtime, since existing effect and coeffect systems only handle compile-time, lexically-scoped composition.

Method: The paper lifts effect systems and coeffect systems from static type theory to runtime mechanisms via two constructs: "revertible effects," where each context transformation Γ→Γ is paired with an explicit inverse the runtime holds (enabling temporal composability — full reversal of a component's side effects on unload), and "reactive coeffects," where every context change is classified against a component's declared coeffect specification as activating/deactivating/neutral (enabling spatial composability — dependency-driven activation). These are unified into a single context type mediating all effects/coeffects (the "context paradigm"), inducing an observational equivalence that lets independently-authored components interleave without interference; this is formalized as a calculus of dynamic composition (components/fibers) with metatheory (preservation, temporal/spatial composability, progress, confluence). The authors implement this as Cordis, a TypeScript meta-framework with a core library (ctx.effect, ctx.get/set, ctx.isolate/intercept) plus a declarative component loader supporting configuration reconciliation and hot module replacement.

Key results:

• Motivating survey of VSCode's top 100 extensions by install count: 87 contain executable code (thus require a full host restart to unload/disable, since VSCode provides no live-unload mechanism), and only 7 declare extensionDependencies on non-built-in extensions (data retrieved June 9, 2026).
• Case study: Koishi, an open-source chatbot framework built on Cordis over four years, has accumulated over 4000 community-contributed plugins (IM adapters, database drivers, admin consoles, end-user features).
• In Koishi, disabling a plugin from the console reverts its effects in place with no author-written uninstall path required, and the HMR engine re-applies edited plugins on save while preserving cache state and live connections elsewhere.
• Reconfiguring a provider at runtime (e.g., switching storage backend or reconnecting an adapter) reactivates only the dependents whose resolved dependency changed; a plugin with an unavailable dependency stays inactive without erroring.
• Cordis's context model is also reused unmodified in a second, independent application (Koishi's browser-based web console), demonstrating domain/runtime generality of the same primitives.

Why it matters / caveats: The authors position self-evolving AI agent harnesses that continuously replace their own components as a key future application, since such systems need the temporal (complete recovery) and spatial (dependency coordination under frequent topology change) guarantees the paradigm provides. The authors explicitly flag the Koishi evaluation as a threat to validity: it is a single ecosystem in a single host language (TypeScript), observational rather than a controlled comparison, and thus an "existence-and-adoption" result rather than a quantitative one — measuring overhead and developer-productivity impact against a baseline is left as future work.

Problem: Scaling transformer language models forces a tradeoff between expressivity (unique weights per layer, which preserve functional specialization but cost memory) and depth-sharing (which saves memory but collapses representational diversity across layers).

Method: The Gated Recurrent Transformer (GRT) brackets a single shared "core" block (applied recurrently R times) between fixed-depth prelude and coda blocks, denoted npre+nrec×R+ncoda. At each recurrence step, the current hidden state is projected together with the fixed prelude output via a learned projection Wproj, with injected additive noise ϵx; the shared blocks Bshared transform this to produce a proposal output o(r); a learned elementwise gate g(r) — a 2-layer SiLU MLP conditioned on layer-normalized current state and prelude output, plus injected gate noise ϵg, with its final-layer bias initialized to +4 so g≈0.98 at training start — blends the previous state and the new proposal (h(r) = g⊙h(r-1) + (1-g)⊙o(r)). Training uses uniform depth sampling r ~ Uniform{1,...,R} at each step, enabling implicit training of every early-exit point.

Key results:

• IsoFLOPs regime: a 3-layer (1+1×10+1) GRT matches GPT-2 Small (12L, 124M params) at 3.14 val loss using only 35M params (~36-37% of baseline params across scales), and beats MoR, heavy-tail Poisson, RRT, and Ouro baselines at every scale (e.g., medium: GRT 2.89 vs. MoR 3.02, Ouro 2.93, RRT 2.95, dense baseline 2.84).
• IsoParams regime: at matched parameter count, GRT achieves 2.76 val loss vs. 2.84 for a non-recurrent (dense) counterpart at medium scale, and 2.65 vs. 2.71 at large scale; downstream lm-eval-harness accuracy improves by +2.10 points average (up to +8.29 on LAMBADA-Standard) over GPT-2 Large.
• At large scale, GRT achieves 62% fewer parameters and 59% less peak decoding memory for only +10% compiled generation latency (measured under torch.compile, batch size 4).
• Early-exit: running only half the recurrence steps retains ~92% accuracy, emergent without any auxiliary training losses.
• Component ablation (small scale) shows the elementwise gate is the single largest contributor, reducing val loss by 0.048 nats; naive recurrence alone (no gate/prelude/coda/noise) raises loss by 0.107 nats.

Why it matters / caveats: The gating mechanism lets a single shared weight tensor behave as multiple functionally-specialized layers, decoupling depth from parameter count more effectively than prior recurrent-depth approaches (MoR, Ouro, RRT, ALBERT-style tying), and yields a continuous compute-quality "dial" at inference. Authors note three limitations: recurrence depth R is fixed at inference (no per-token halting), gate bias/noise hyperparameters may need re-tuning outside the GPT-2 family, and the optimal sharing fraction across scales is not yet systematically characterized. All experiments are on GPT-2-scale models (up to 774M/36L) trained from scratch on ~9.8B tokens per run — no results at larger LLM scale are reported.

Problem: Most existing multi-arm vision-language-action (VLA) models treat language as a single global instruction with no explicit mechanism for assigning and composing arm-specific behaviors, which makes them brittle when test-time collaboration patterns differ from those seen in training.

Method: MA-VLA has two parts: a VLM-based Planner (using GPT-4.1) that decomposes a high-level instruction into a temporally ordered sequence of mid-level "atomic prompts" assigned per arm, and a VLA Executor (a flow-matching model built on Pi0, initialized from the pi0_base checkpoint) that concatenates all arms' atomic prompts into a unified instruction string and jointly predicts all arms' actions in a single forward pass via a multi-head projection layer. Training uses two stochastic regularizers applied only at training time: Arm Shuffle, which randomly permutes the correspondence between each arm's state, view, prompt, and action (probability pshuffle) to prevent binding behaviors to fixed arm identities, and View Dropout, which randomly masks a subset of camera views (probability pdrop) to encourage redundant multi-view perception. The model is trained with a standard per-arm behavioral-cloning/flow-matching loss.

Key results:

• On RoboFactory in-domain tasks, MA-VLA outperforms Pi0 on average across two-arm (83.5% vs 80.3%), three/four-arm (83.3% vs 76.5%) tasks, with the largest gains as arm count increases (e.g., Deliver task 97.0% vs 82.0%).
• On RoboTwin 2.0 (Hard), MA-VLA reaches 49.0% average success vs 41.1% for Pi0 and 27.0% for Pi0-FAST.
• On out-of-domain compositional generalization (unseen collaboration orders), DP, Pi0-FAST, and Pi0 all score 0.0% average, while MA-VLA achieves 13.0% average (up to 28.0% on the GBR stacking-order task).
• On real-world dual-arm SO101 tasks, MA-VLA achieves non-zero OOD (role-reversed) success where Pi0 gets 0/20 across all four tasks (e.g., Stack Bowls 10/20 vs 0/20, Place Cubes 8/20 vs 0/20).
• Ablations show atomic actions alone give 0.0% OOD; adding Arm Shuffle alone still gives 0.0%; Arm Shuffle+View Dropout combination (with atomic actions) reaches 15.3% OOD vs 53.0% in-domain, and increasing shuffle rate from 0% to 100% raises OOD success from 0.0% to ~15.3% while in-domain success stays roughly stable (58%→52%).
• A "separate model per arm" baseline (3x VLA models) still fails at OOD generalization (0.0%) despite matching or exceeding in-domain performance (61.0%), showing per-arm independence does not enable compositional generalization.

Why it matters / caveats: The paper argues that explicit per-arm atomic-action decomposition plus identity-randomizing training (Arm Shuffle) is a practical route to compositional generalization in multi-arm systems, since prior SOTA VLAs (Pi0, Pi0-FAST, DP) collapse to 0% success under unseen collaboration structures despite good in-domain performance. Caveats: absolute OOD success rates remain low (9-28% in sim, 2-12/20 real-world), and the planner (GPT-4.1) is not fine-tuned and treated as a fixed external component, so overall system quality partly depends on an off-the-shelf VLM's task decomposition.

Problem: Document retrieval pipelines vary along modality (text vs. multimodal) and architecture (dense vs. late-interaction), and no single static pipeline is simultaneously accurate and fast across queries, forcing practitioners into a fixed accuracy-latency trade-off.

Method: RetrievalRouter is a lightweight query-aware router built from a frozen Qwen3-0.6B-Base encoder (with LoRA adapters, rank 16, on attention/feedforward projections, ~4M trainable params) that mean-pools query representations into a 1024-dim vector and passes them through a single linear decision head producing logits over five routing arms (BM25, Text-Dense, Text-Rerank, Multimodal-Dense, Multimodal-Rerank). It is trained via KL divergence against soft targets derived from a per-query reward vector combining nDCG@5 and normalized latency (reward = (1−λ)·accuracy + λ·(1−latency), softmax with temperature τ=0.1), so a single tunable λ traces the full accuracy-latency Pareto frontier at inference without running any retrieval pipeline itself (only ~15ms overhead).

Key results:

• Against the strongest static baseline (ML, 0.737 nDCG@5 at 8.283s), RetrievalRouter is 2.5% more accurate and 12.4× faster; at λ=0.1 it reaches 0.755 nDCG@5 at 0.666s, dominating all static pipelines.
• Router overhead is ~15ms/query (3.8% of Text-Dense's ~400ms, <0.2% of Multimodal-Late's ~8s latency).
• Vs. Arabzadeh et al. (2021) adaptive baseline: significantly higher nDCG@5 in accuracy-oriented settings (all p<0.001), and at λ=0.7 numerically better on both nDCG (0.630 vs. 0.624) and latency (0.148s vs. 0.171s).
• The 7-pipeline per-query Oracle reaches 0.90 nDCG@5, leaving ~14 nDCG points of headroom over the deployable router.
• Multimodal-Late index storage is ~39GB, over 13× larger than the ~3GB Text-Dense index; running all pipelines simultaneously requires ~40GB VRAM.

Why it matters / caveats: Shows the accuracy-latency trade-off in document retrieval is fundamentally a per-query routing problem rather than an architectural one, and releases per-query oracle labels across 80,000+ queries from 11 benchmarks (financial, scientific, open-domain) to support further adaptive-retrieval research. Caveats stated by the authors: it relies on query text alone, so semantically ambiguous queries (e.g., "summarize the table on page 5") cannot be resolved without document-level cues; evaluation uses in-domain (intra-dataset) splits rather than cross-domain generalization; and the approach trades higher storage/VRAM cost (multiple maintained indices) for lower latency, making it best suited to latency-critical rather than storage-constrained deployments.

Problem: Non-invasive neural speech decoding lacks the shared, standardized large-scale MEG datasets and evaluation infrastructure needed to reliably measure progress, unlike invasive BCI approaches or fields like computer vision that benefited from ImageNet-scale benchmarks.

Method: The authors collected LibriBrain100, over 104 hours of 306-sensor MEG (MEGIN TRIUX Neo, 102 magnetometers + 204 gradiometers) from 33 English-proficient subjects: ~80.5 hours from a single "subject 0" listening to the complete Sherlock Holmes canon plus TIMIT, MOCHA-TIMIT, and 30 The Moth podcasts, and ~23.7 hours (~40 minutes each) from 32 additional subjects listening to two Sherlock chapters, with standard train/val/test splits (e.g., held-out chapters 11/12, TIMIT's 24-speaker core test set) and data released in raw BIDS/FIF and preprocessed HDF5 formats via a Python library (pnpl). For baselines, they fine-tuned the pre-trained MEG-XL model (Jayalath and Parker Jones, 2026, pre-trained on ~300 hours from 800 subjects) on a 50-word top-10 balanced-accuracy word-classification task, both within-subject (subject 0) and cross-subject (subjects 1–32).

Key results:

• Fine-tuning MEG-XL jointly with subjects 1–32 data improved subject 0's held-out performance on TIMIT, MOCHA-TIMIT, and podcasts (e.g., TIMIT accuracy rose from 0.393 to 0.519), though training on Sherlock-only data alone gave the best Sherlock-test result (0.585 vs. 0.501).
• Including subject 0's ~80 hours in fine-tuning improved cross-subject generalization on subjects 1–32 by about 15 percentage points (0.478 vs. 0.329 balanced top-10 accuracy), consistently across all 32 subjects.
• Reducing subjects 1–32 fine-tuning data to 25% (~10 minutes per subject) caused minimal degradation (0.482 vs. 0.492 at 100%), with no statistically significant differences across data-size conditions.
• LibriBrain100's deep component (~80 hours from one subject) is ~8x larger than the next deepest comparable dataset (Armeni et al., 10 hours) and ~80x larger than others (e.g., MOUS, MEG-MASC, Le Petit Prince, all under 2 hours/subject).

Why it matters / caveats: The dataset and its open ML competition/leaderboard aim to provide ImageNet-style shared infrastructure for non-invasive brain-to-text research toward BCIs for people with severe paralysis; the authors explicitly note remaining limitations — all data comes from passive listening (not speech production/imagined speech, though inner-speech datasets are planned) and no brain-to-text baseline was included, as the authors judged the field not yet stable enough for a standardized benchmark.

Problem: Existing text-to-video reward models rely on holistic judges with fixed rubrics or open-ended reasoning, causing incomplete inspection, unfaithful justification, and entangled attribution across evaluation dimensions.

Method: FIRM-Video is a checklist-driven data construction framework built on a "check-before-score" principle across three dimensions: Instruction Following (a Qwen3-32B text planner decomposes prompts into importance-weighted atomic yes/no requirements, verified by a multimodal evaluator against video frames), World Coherence (Qwen3-VL-235B-A22B-Instruct grounds entities/actions in the video without seeing the prompt, Qwen3-32B builds target-specific verification questions, and a multimodal evaluator checks for violations), and Perceptual Quality (a multimodal evaluator applies a generic human-curated defect taxonomy). Verified checklist results are aggregated via importance-weighted formulas into 5-point scores and converted to natural-language rationales, forming FIRM-Video-90K (88,044 instances, 29,348 videos, 3,012 prompts). FIRM-Video-8B is then fully fine-tuned end-to-end from Qwen3-VL-8B or InternVL3-8B on this data (8 uniformly sampled frames, batch size 2 × 32 grad-accum steps, lr 5e-6, cosine decay, 2 epochs, LLaMA-Factory) to directly predict rationale+score in one forward pass without running the checklist pipeline at inference.

Key results:

• FIRM-Video-8B (Qwen3-VL-8B) achieves the best overall MAE of 0.78 on FIRM-Video-Bench (vs. 1.33 for base Qwen3-VL-8B), beating GPT-5, Gemini-3.1-Pro, and Doubao-Seed-2.0-Lite.
• In Best-of-8 sampling across LaVie-Base, CogVideoX-2B, and Wan2.1-T2V-1.3B, FIRM-Video-8B gets the highest VBench Total, Quality, and Semantic Scores, improving Total Score by 0.27–1.01 and Semantic Score by 1.24–2.11 points over the strongest competing selector.
• Importance-weighted score aggregation beats uniform-mean aggregation, cutting World Coherence MAE from 0.86 to 0.80 (ablation).
• On MJ-Bench-Video (out-of-domain), FIRM-Video-8B (InternVL3-8B) achieves best Alignment (31.93) and C&C (35.35) scores among all compared models.
• Best-of-N scaling on VBench (LaVie-Base) shows FIRM-Video-8B's score rising from 80.36 to 80.97 as N goes 4→16, surpassing random sampling by 1.03 and Qwen3-VL-8B by 0.33 points at N=16.

Why it matters / caveats: Demonstrates that decomposing reward supervision into verifiable checklists (rather than open-ended rubric judging) yields more reliable, interpretable T2V reward models at practical inference cost (single forward pass, no runtime checklist pipeline). The authors note this work has not yet been used to directly optimize T2V generators via RL/preference optimization — that is left to future work.

Problem: Streaming autoregressive diffusion video models accumulate geometric drift over long rollouts, and existing 3D Gaussian-Splatting-based reward critics used to fix this (e.g., World-R1, VideoGPA) mistakenly penalize genuine object motion as reconstruction error, causing the video to freeze into static or unnatural motion.

Method: Stream4D is a reinforcement-learning recipe built on Astrolabe's forward-process DiffusionNFT update for distilled AR video models, replacing the static 3D-GS critic with a feed-forward 4D-GS reconstruction reward using MoVieS (conditioned on cameras estimated by StreamVGGT) that explicitly models scene dynamics via a canonical Gaussian point cloud plus per-frame deformation/appearance parameters. The reward combines three z-normalized, additively-summed axes: a reconstruction term (Rrecon, clipped 1-LPIPS between MoVieS re-renders and original frames), a gated motion term (Rmot = g(m)·smooth·rigid, a Gaussian gate peaking at natural motion magnitude mnat=0.020 combined with temporal-smoothness and spatial-rigidity quality factors computed from MoVieS's per-pixel 3D motion field), and a lightweight HPSv2 perceptual anchor. Training uses a LoRA adapter (r=α=256) over frozen 4-step distilled bases with AdamW (lr=1e-5), group size G=24, rolling window L=21, frame-sink S=3, for 150 RL steps (~57,600 scored rollouts) on prompts sampled from VidProM.

Key results:

• 4D-PSNR improved from base 16.88→20.34 dB (Self-Forcing), 15.44→20.97 dB (Causal-Forcing), and 17.44→24.20 dB (LongLive), gains up to +6.76 dB, outperforming World-R1 and VideoGPA on all three backbones.
• Under an independent reconstructor (4DGT), Stream4D still leads World-R1 by +0.7/+1.1/+2.5 dB PSNR across the three backbones, confirming gains aren't MoVieS-specific.
• LLM-judge motion-preservation scores of 0.833/0.765/0.706 (SF/CF/LL) were highest among methods, and VideoReward-Overall win rates vs. base reached 66.2%/76.0%/84.4%, beating World-R1's 61.8%/74.8%/78.2%.
• In a blinded human study on LongLive (150 forced-choice comparisons, 5 raters), Stream4D was preferred overall 76% vs. World-R1 and 80% vs. VideoGPA.
• Ablations show each reward axis is necessary on at least one backbone (e.g., dropping the motion term collapses motion on all three backbones), and the deployed peaked Gaussian gate shape outperforms linear or ungated motion-term variants.

Why it matters / caveats: The method shows that framing world-model consistency rewards around 4D (dynamic) rather than 3D (static) reconstruction avoids a reward-hacking shortcut where models freeze motion to score well, and the recipe transfers across three distinct AR backbones with only reward-axis weights varying per backbone. The paper notes a caveat that good 4D-reconstruction reward does not by itself certify metric-accurate geometry, and lists future work on a streaming 4D reconstructor to match longer native horizons and grading against explicit action/camera inputs.

Problem: Existing co-speech gesture generation methods are studied offline (synthesizing gestures from complete speech segments), which is unsuitable for real-time interactive digital humans that must generate speech-synchronous gestures online from only currently available response audio under strict latency constraints.

Method: The framework couples a streaming speech response module (Qwen-Omni streaming model producing token-level agent audio) with a causal multimodal autoregressive online gesture generator built on compositional motion tokenization — the body is split into four parts (lower body, upper body, hands, head/face), each tokenized by a separate VQ-VAE, then jointly modeled via cross-modal autoregressive factorization with a causal, audio-conditioned cross-attention (masked so motion tokens only attend to past/current speech). Training data comes from an offline interactive data synthesis pipeline that uses topic- and emotion-aware subject corpora to prompt an LLM for diverse human-agent dialogues, converts responses to speech via voice cloning/TTS, and synthesizes paired co-speech motion, supplemented by a cold-start motion-capture dataset (JIYI, ~6 hours) from professional actors; a closed-loop self-evolution mechanism feeds user-preference-aware online interaction data back into this pipeline for continual retraining.

Key results:

• On BEATv2: Super Star (base) achieves FGD 10.519, BC 8.389, Diversity 10.505, and latency 1.623ms, versus the next-best baseline LOM (FGD 15.681, BC 7.446, latency 22.902ms).
• On JIYI: Super Star (base) achieves FGD 2.795, BC 7.354, Diversity 11.520 at 1.623ms latency, beating all baselines including LOM (FGD 3.240, latency 22.902ms) and Semantic Gesticulator (latency +∞, i.e., non-causal/offline).
• Self-evolution improves results progressively: FGD drops from 2.795 (base) to 2.419 (1 round) to 2.231 (2 rounds) on JIYI, with BC rising to 7.738 and Diversity to 12.509 after 2 rounds.
• Ablations show removing the causal audio attention mask worsens FGD to 3.037/BC 7.027, and replacing cross-attention with prefix-conditioning worsens FGD to 3.745/BC 6.844, confirming both design choices matter.
• A 20-participant blind pairwise user study shows Super Star preferred over Omni+SynTalker, Omni+LOM, and Omni+EMAGE on naturalness, synchronization, and overall preference, with self-evolution (2 rounds) further preferred over the base model.

Why it matters / caveats: The paper targets a practically important but underexplored setting (real-time virtual companions) and demonstrates large latency reductions (~1.6ms vs. 3.3–22.9ms or infinite for offline baselines) alongside quality gains. The authors note limitations including long-horizon planning under strict online constraints, generalization without seed data, fine-grained preference modeling, and limited embodiment scope.

Problem: Existing turn-taking research lacks naturalistic multimodal conversational corpora for Turkish, making it hard to model when a speaker is about to yield the floor in synchronous dialog systems.

Method: The authors built a 4.23-hour (253.6 min) corpus of 11 unscripted dyadic Turkish conversations with per-speaker 48kHz WebM audio, 1920x1080/16fps MP4 video, and time-aligned VTT transcripts (5,383 segments, 35,728 words), semi-automatically labeling 1,750 turn-change events (excluding backchannels) against 3,500 sampled negatives using a rule requiring speaker change, ≥0.5s duration, non-filler content, and text length >3 characters. They extract 28 features per 2-second pre-transition window (9 visual via MediaPipe Face Mesh + Py-Feat, 12 acoustic eGeMAPSv02 via openSMILE, 7 linguistic from transcripts) and use a Genetic Algorithm (DEAP, population 500, 900 generations) to evolve interpretable hybrid AND-OR decision rules optimized for F1 under 5-fold, conversation-level cross-validation.

Key results:

• Final GA rule achieves F1 = 57.0% (precision 46.1%, recall 74.6%), a 7.0-point F1 improvement over the always-predict-turn-change baseline (F1 = 50.0%).
• Outperforms all silence-threshold baselines (e.g., 1.0s threshold: F1 = 16.7%; 2.0s: F1 = 25.8%; 3.0s: F1 = 14.4%).
• The final interpretable rule uses only 5 of 28 features (word duration, energy rate, gaze changes, f0 mean, is filler, word duration again), combining word duration ≥0.60s AND energy rate ≥1.00, OR gaze changes ≥0.35 AND f0 mean ≥120Hz, OR is filler AND word duration ≥0.80s.
• Corpus stats: 81.4% of annotated transitions contain speech overlap; 12.4% of total duration is non-speech; two "hub" speakers (user 01, user 03) account for 60.8% of words across the 11 conversations.

Why it matters / caveats: The paper explicitly frames the F1 margin over baseline as modest and not statistically significant given only 11 conversations, and notes speaker-specific leakage remains uneliminated (every conversation includes one of two recurring hub speakers), so reported figures are described as an upper bound on generalization to unseen speakers; future work proposes a balanced non-hub recording design and comparison against Random Forest/XGBoost/transformer baselines.

Problem: Vision-language models remain near chance level at verifying spatial relations (e.g., left/right, above/below) between anatomical structures in CT scans, which threatens the reliability of report-oriented medical image understanding.

Method: The authors build a modular, LangChain-orchestrated agent that decomposes binary spatial-relation verification into four explicit stages: (1) tuple extraction, converting a natural-language question into a structured (entity, relation, entity) tuple via a lightweight parser with VLM fallback; (2) ontology matching of extracted entities to canonical detector classes (with a controlled invalid-result path on failure); (3) localization, querying a YOLO-based detector (trained on 421,023 instances across 61 anatomical classes, using segmentation-derived boxes plus AMOS and BTCV data) and keeping only the highest-confidence box per class; (4) deterministic geometric verification, comparing detected object centroids' horizontal/vertical ordering rather than having a neural model predict the truth value directly. A VLM controller (MedGemma 4b or Qwen2-VL 7b) handles prompt routing while receiving the same external prompt as end-to-end baselines.

Key results:

• Best hybrid configuration (Qwen2-VL + hybrid agent) reaches 94.1% accuracy and 94.2% F1 on the held-out MIRP RQ1 test set (938 image-question pairs), vs. 51.6% accuracy for direct Qwen2-VL prompting — a 42.5 percentage point gain.
• MedGemma + hybrid agent reaches 91.6% accuracy vs. 51.8% for direct MedGemma prompting.
• No invalid binary outputs were observed for the hybrid agent.
• Stage-wise failure attribution on the 55 remaining incorrect cases (best config): imprecise YOLO localization caused 28 cases (50.9%), parsing/query-extraction errors caused 15 cases (27.3%), missing detections caused 12 cases (21.8%); zero errors attributed to question extraction, routing, ontology matching, geometry ambiguity, or formatting/runtime failures.

Why it matters / caveats: By replacing end-to-end spatial prediction with deterministic geometric verification over detected object centroids, the system both boosts accuracy dramatically and makes every failure traceable to a specific pipeline stage, unlike opaque VLM outputs. Limitations stated by the authors: it only evaluates pairwise 2D spatial relations in axial slices, not full 3D/volumetric reasoning, distance-sensitive relations, containment, overlap, or multi-structure consistency, and remaining errors are bounded by the underlying YOLO detector's precision.