AI papers — 2026-07-17

Problem: GRPO-style RL post-training must score and backpropagate through multiple responses conditioned on the same long shared prompt, so quadratic attention state and long-lived backward graphs make GPU memory the binding constraint on extending training context length under a fixed accelerator count.

Method: LongStraw evaluates the shared prompt once under no-grad (autograd disabled), retains only architecture-specific durable state needed by future tokens (recurrent state and physical KV pages for Qwen; CPU-resident MLA latent pages and DSA indexer-key pages for GLM), then serially replays and backpropagates one response branch at a time under whole-layer activation checkpointing, accumulating gradients before a single optimizer call per worker. It is instantiated on two architectures: Qwen3.6-27B (64 layers, hidden 5,120, 48 GDN/Gated-DeltaNet recurrent layers + 16 GQA full-attention layers, NF4 QLoRA with 116,727,808 trainable parameters, CP8 on 8 H20 GPUs) and GLM-5.2 (78 layers, hidden 6,144, MLA+DSA sparse attention with 21 index-computing + 57 IndexShare layers, 256 routed top-8+1-shared MoE experts, TP1/CP32/EP32 on 32 H20 GPUs).

Key results:

• Qwen path completes grouped scoring/backward at 2,097,152 (~2.1M) context positions with group sizes 2 and 8 on 8 H20 GPUs; increasing group size 2→8 adds only 0.21 GB peak allocated memory (97.503 GB at G=2, 5,198.78s; 97.711 GB at G=8, 6,785.23s).
• A stress test extends the Qwen envelope to 4,456,448 (~4.25M/4.46M) positions on 8 H20s, peaking at 82.960 GB (resident replay) / 83.894 GB (prefix-frozen, 8 optimizer steps).
• GLM-5.2 end-to-end path validated for a 2,097,152-token prompt across all 78 layers on 32 H20 GPUs, with a capture-window peak allocation of 112.571–145.148 GB per rank (a 32.577 GB rank spread).
• Each additional 1M global context positions adds ~8.192 GB of KV storage per rank for Qwen's 16 full-attention layers (given 4 KV heads, dim 256, BF16, CP8).

Why it matters / caveats: By trading replay time for memory, LongStraw lowers the hardware barrier to long-context RL training, letting smaller teams explore >2M-token training without large GPU fleets. The authors explicitly caveat that this is an execution-capacity result, not proof of training correctness: prompt-state gradients are detached (only the response-conditional gradient term is computed), Qwen's dK/dV adapter gradients aren't fully synchronized across context-parallel ranks, and GLM's custom path skips Megatron's finalize_model_grads, so distributed-update consistency and full-gradient parity remain unverified.

Problem: Existing open-source video MLLMs are narrowly specialized (poor transfer between short/long/streaming settings), computationally expensive due to token-inefficient video encoding, and only partially open (missing training code/data), which blocks reproducible progress in generalist video understanding.

Method: VideoChat3 (4B parameters) pairs an Inflated 3D Vision Transformer (I3D-ViT) — inflated from pretrained image tokenizer MoonViT by extending 2D spatial self-attention into chunk-wise spatiotemporal self-attention with learned temporal positional encodings and temporal pooling (T=4 default, combined with 2×2 pixel-shuffle spatial downsampling for a 16× overall compression) — with an Adaptive Frame Resolution controller for streaming that switches per-frame pixel quota between Blow=224² and Bhigh=448² based on a 3-state (Silence/Standby/Response) token policy. Training uses a 4-stage curriculum (visual-tokenizer pretraining, video-language alignment, video instruction tuning, long/streaming instruction tuning) over three newly built datasets: VideoChat3-Academic2M (2.27M evidence-grounded, Qwen3-VL-235B-A22B-rewritten and consistency-filtered academic annotations), VideoChat3-LV116K (116.2K long-video samples via boundary-aware segmentation and evidence-ledger synthesis), and VideoChat3-OL617K (617,183 streaming instances with explicit silence/standby/response supervision), with a masked state-transition loss (Lstate) that balances transition vs. continuation positions at an effective 2:2:1 Silence:Standby:Response ratio.

Key results:

• VideoChat3-4B scores 61.7 on MotionBench and 75.6 on TempCompass, the best among fully open models, and improves over Qwen3-VL-4B on 18 of 19 directly comparable general-understanding metrics (e.g., +5.9 MMVU, +15.0/+20.6 on VUE-TR v1/v2).
• Versus VideoChat-Flash-7B it gains +16.4/+29.8/+34.3 on TimeLens temporal-grounding splits and +18.7 on MomentSeeker.
• On streaming benchmarks, VideoChat3 reaches 72.3 on ODVBench (+12.4 over StreamForest) and +27.4 over Qwen3-VL-4B on OVO-Timing.
• Efficiency: at 512 frames, VideoChat3 cuts FLOPs from 1.341×10¹⁵ to 0.864×10¹⁵ and GPU memory from 32.92 GB to 26.68 GB versus Qwen3-VL; at 2048 frames, total latency drops from 44.449s to 20.412s while producing half the visual tokens per frame (100,352 vs. 200,704).
• Training uses roughly 50B tokens in Stage-2 (10.33M samples, 23.62M QAs) and ~10B tokens in Stage-3 (3.41M samples, 10.39M QAs).

Why it matters / caveats: The model, training code, training strategy, and all three datasets are fully released, aiming to close the reproducibility gap in open video MLLMs; the paper notes VideoChat3 underperforms on the open-ended split of VideoEval-Pro and trails the specialized MMDuet-2 model on some ProactiveVQA subsets.

Problem: Outcome-based agentic RL provides only sparse, trajectory-level rewards, leaving a supervision gap that gives no guidance on which intermediate observations, actions, or tool calls should be reinforced or corrected in long-horizon tasks.

Method: SEED runs in two stages: (1) Hindsight-Skill SFT, where a base policy generates offline trajectories (M=180 tasks × K0=8 rollouts = 1,440 trajectories), an external analyzer (GLM-5.2) annotates each with a natural-language hindsight skill, and the policy is fine-tuned via NLL loss to produce these skills itself; (2) Self-Evolving On-Policy Distillation, where the current frozen policy πθold both samples N=8 trajectories per task and serves as the analyzer extracting skills from them, then the trainable policy re-scores the same sampled action tokens under ordinary vs. skill-augmented context, converts the resulting log-probability shift into a confidence gate g=σ(βopd·Δ) (following SDAR), and optimizes a gate-weighted token-level distillation loss (Lopd) jointly with a GRPO-style clipped RL loss (Lrl) plus KL penalty, total LSEED = Lrl + λopd·Lopd. Backbones tested: Qwen2.5-3B/7B-Instruct and Qwen3-1.7B-Instruct, trained for 150 policy updates.

Key results:

• On ALFWorld (Qwen2.5-3B), SEED reaches 91.8% average success vs. 75.0% for GRPO and 84.4% for the strongest static-distillation baseline (SDAR).
• With Qwen3-1.7B, SEED achieves 92.0% ALFWorld average vs. 46.1% for GRPO (a 45.9-point gain) and 53.9% for SDAR.
• On WebShop (Qwen2.5-3B), SEED gets 88.5 task-completion score / 78.9% success rate vs. GRPO's 79.8/63.3.
• Sample efficiency: SEED with 60% of training data (80.7% success) exceeds full-data GRPO (75.0%); with 40% of data (58.9%) it nearly matches GRPO at 80% of data (58.6%).
• Cross-domain generalization on ALFWorld unseen split rises from 70.9% (GRPO) to 86.2% (SEED), a +15.3-point gain (+35.0 on Heat, +18.3 on Look).
• Ablations: removing Hindsight-Skill SFT drops ALFWorld average to 86.0% (−5.8pp); removing self-evolving OPD drops it to 87.0% (−4.8pp); replacing on-policy skills with a static offline library drops it to 84.4% (−7.4pp, the largest degradation).

Why it matters / caveats: SEED requires no external memory or inference-time skill prompts (skills are training-only, distilled into policy weights), and the ablations show the self-evolving/on-policy property of skill generation is the most load-bearing component. Results are reported only on ALFWorld, WebShop, and Search-based QA using Qwen backbones up to 7B; generalization to larger models or other agent domains is not evaluated in the shown text.

Problem: Long-horizon information-seeking agents lose track of task progress as interaction histories grow, causing repetitive search loops, duplicated or idle multi-agent work, and degraded final answers because plans, evidence, and failures are treated as transient conversation content rather than persistent system state.

Method: SearchOS formulates open-domain information seeking as relational schema completion with grounded citations (tables of entities/attributes plus a citation matrix mapping each value to a source URL and anchored excerpt), and introduces Search-Oriented Context Management (SOCM) that externalizes state into four structures: Frontier Task (a dependency-aware task DAG), Evidence Graph (atomic findings with SUPPORT/CONFLICT/REFINE links), Coverage Map (per-cell fill status), and Failure Memory (recurring failure signatures). An orchestrator–worker architecture (explore/search/writer agents) uses pipeline-parallel continuous dispatch (refilling released execution slots immediately rather than synchronized batches), governed by a Search Tool Middleware Harness (Context, Evidence Extraction, and Sensor middleware) that intercepts model/tool calls to inject context, ground evidence, and detect stalls via a windowed no-progress signal and budget-pressure ratio. A hierarchical skill system with 280 pre-built skills (orchestrator, strategy, access) supplies reusable search/extraction knowledge. Backbone: GLM-5 for agent roles, Qwen3.5-35B-A3B for evidence extraction; evaluated Max@3 over 3 runs.

Key results:

• On WideSearch, SearchOS achieves 80.3 Item-level F1 (vs. 76.0 for best baseline A-MapReduce, +4.3) and 56.5 Row-level F1 (+2.0 over Web2BigTable).
• On GISA, SearchOS reaches 76.5 Set F1, a +13.4-point improvement over the strongest baseline (63.1); it also leads Table Item F1 (76.9), Table Row F1 (59.7), and List F1 (68.1).
• Continuous (pipeline-parallel) scheduling vs. batch scheduling reduces average end-to-end time by 24.3% (629.13s→476.34s), raises slot utilization from 34.6% to 41.7%, and improves Item F1 from 79.66 to 86.75 while using fewer LLM calls (341.4→296.6).
• Search-time schema planning (dynamic single/multi-table choice) beats even an oracle fixed-schema selection by 8.2 Item-F1 and 7.7 Row-F1 points on a 40-case subset.
• Hierarchical skills raise Item F1 by 2.0 and Row F1 by 3.4 points while cutting session time by 36.6%, search calls by 39.1%, and page-open calls by 42.7% on the same 100 WideSearch questions.

Why it matters / caveats: The results indicate that externalizing search state (rather than relying on conversational memory) and adaptive schema planning are what drive completeness gains on recall-sensitive long-horizon search tasks. The paper notes SearchOS-V1's scope is limited to system-level infrastructure and pre-built skills; large-scale automatic skill synthesis from data/trajectories is left to follow-up work.

Problem: World-action models (WAMs) couple action generation with future-world prediction under the assumption that imagined futures make behavior safer/checkable, but it is untested whether an adversary can desynchronize a WAM's executed action from its (still-plausible) imagined future to cause silent task failure.

Method: BadWAM is a black-box, query-based attack framework that perturbs visual observations (õt = clip(ot+δt), ‖δt‖∞≤ε) at each closed-loop replanning step using zeroth-order finite-difference optimization (simultaneous perturbation, m sampled directions, no gradients or model weights needed). It instantiates two objectives: an action-only adversarial attack that maximizes action-chunk deviation Dact, and an imagination-preserving adversarial attack that solves a Lagrangian relaxation maximizing Dact − λ·Dimg (future-prediction drift measured via frame-level or latent distance), trading attack strength for stealth via coefficient λ. Evaluated closed-loop on three WAM variants (action-only WAM, joint WAM predicting future+action jointly, and IDM WAM that decodes actions from an imagined-future representation) on LIBERO and RoboTwin manipulation benchmarks, ε=0.06, 8 optimization iterations per replan (17 WAM queries per attacked replan).

Key results:

• Action-only attack reduces the action-only WAM's LIBERO success from 96.5% to 43.1%, and RoboTwin success from 92.1% to 84.4%.
• On the joint WAM, action-only attacks cut LIBERO success from 98.1% to 61.5%, and imagination-preserving attacks cut it to 63.0% while still constraining future drift.
• Under matched attack strength, the imagination-preserving objective reduces average predicted-future distance from 14.01 to 13.04 (lower on 39 of 40 LIBERO tasks) while keeping under-attack success comparable (61.5% vs. 65.9%).
• Random ℓ∞-bounded noise only drops joint/IDM WAM success to 71.0%/75.2%, far weaker than BadWAM's 61.5–68.1%; a white-box gradient reference pushes success down further to 49.2–52.8%.
• Per-suite breakdown: action-only WAM's Spatial-suite success falls from 96.5% to 16.0%, Long-horizon from 92.5% to 23.5%, while Object-suite success stays robust at 93.0%; 42.5% of tasks fall into the 0–25% success bin under attack.
• pass@k across 1–20 trials shows the attacked action-only WAM stays around 0.40–0.43 with no recovery as trials accumulate, confirming systematic (not lucky-seed) failure.

Why it matters / caveats: The paper demonstrates that coupling actions with future prediction does not automatically confer robustness or a reliable safety signal, since imagination-preserving attacks can hijack execution while keeping the "dream" visually plausible — undermining imagine-then-check safety monitors. The authors explicitly scope out training-time poisoning, model extraction, reward hacking, prompt injection, and physical environment tampering as non-goals.

Problem: No existing benchmark measures whether video generation models faithfully reproduce an entire ordered sequence of keyframes (correct appearance, order, and timing) rather than just single-image conditioning or generic video quality.

Method: The authors build KeyFrame-Compass, a 386-sample benchmark spanning three domains (daily capture, product visualization, cinematic narrative), two video structures (one-take vs. multi-shot), two prompt granularities, two conditioning formats (multi-image list vs. storyboard grid), and four keyframe densities (3/6/9/12). Evaluation uses a staged matching pipeline where Gemini 3.1 Pro recovers the actual shot structure of a generated video and locates each input keyframe within an expected temporal window using DINOv3 semantic similarity plus PSNR/SSIM pixel fidelity; six "keyframe response" metrics (Hit Rate, Keyframe Similarity, Order Consistency, Position Accuracy, Persistence, Response Uniqueness) are combined with checklist-based MLLM/perception-model "general quality" metrics (video quality via DOVER/MUSIQ, attribute consistency via SAM 3.1 tracking + DINOv3/ElasticFace/InceptionNeXt embeddings, audio via CLAP).

Key results:

• Benchmark: 386 curated cases, 15 metrics, keyframe counts of 3/6/9/12, built from GPT-Image-2 and Nano Banana Pro generated/verified keyframes.
• Nine representative video generation systems evaluated; every system shows a trade-off between keyframe fidelity and natural video synthesis (none excels at both).
• The strongest open-source model trails the leading proprietary system by 0.153 in overall score.
• Instruction adherence declines as keyframe count increases, and most open-source models fail to interpret storyboard-grid inputs as ordered keyframe sequences.

Why it matters / caveats: Provides the first diagnostic separation of "did the model execute the keyframe plan" vs. "is the output a good video," exposing failure modes (omission, misplacement, wrong order, implausible transitions) hidden by aggregate scores; the paper notes controllability degrades further as constraints (keyframe density) increase.

Problem: Existing benchmarks evaluate text-to-audio-video or single-reference-to-video generation but do not assess whether models can jointly interpret multiple references (same-identity multi-view, or distinct entities) and bind/compose them correctly into coherent audio-video output.

Method: MultiRef-Compass contains 350 samples (300 across three main boards B1–B3 plus 50 in an extended challenge board B4) built via a taxonomy-driven asset-composition pipeline over curated subject/object/scene/video/voice packs, with GPT-5.5-generated structured prompts. Evaluation uses a hybrid dual-level framework — automatic metrics (DOVER++ for visual quality, Audiobox for audio quality, SigLIP/YOLO-World/ElasticFace/InceptionNeXt for entity fidelity, SpeechBrain ECAPA-TDNN for timbre, LatentSync for lip-sync) plus a rejudging-enhanced MLLM-as-a-Judge (Gemini 3.1 Pro) across four dimensions: Basic Quality, Reference Consistency, Audio-Visual Consistency, Instruction Following (14 sub-metrics total), with a paste-naturalness coefficient Ppaste(r) that discounts entity-fidelity scores inflated by copy-paste artifacts.

Key results:

• 8 models evaluated (6 closed-source: Seedance 2.0, Kling 3.0, HappyHouse 1.1, Gemini-Omni, Wan 2.7, Vidu Q3-Mix; 2 open-source: Wan2.1-VACE, SkyReels-V3).
• Seedance 2.0 ranks first overall on the shared subset; Kling 3.0 achieves highest Entity Fidelity (EF=0.6160).
• SkyReels-V3's Entity Fidelity drops from EFbase=0.6460 to EFfinal=0.5168 after applying the Ppaste correction (Ppaste=0.80), dropping its rank from 5th to 8th due to copy-paste artifacts.
• Human-alignment Pearson correlation of benchmark win rates is 0.8979–0.9644 across the four dimensions.
• Open-source models lag substantially in Reference Consistency and Instruction Following (e.g., Wan2.1-VACE BC=3.8582 vs. Seedance 2.0's 4.6360).

Why it matters / caveats: Reveals that raw embedding-similarity metrics can be gamed by copy-paste rather than genuine synthesis, and that no model performs consistently well across all four dimensions; the authors note MLLM-based judging adds cost and potential model-specific bias, and proprietary APIs may change over time affecting reproducibility.

Problem: Interactive video-generation "game engines" lack a unifying framework connecting player action representation, game state modeling, long-horizon persistence, and real-time generation, and there is a scarcity of gameplay data with explicit, temporally aligned game-state annotations needed to study state-aware modeling.

Method: This is a position/survey paper organizing existing interactive world-model approaches around the action-state-observation loop of conventional game engines, along four dimensions: player action control (geometric trajectories, motor signals, or semantic events), game state dynamics (state entangled in pixels, learned latents, or explicit symbolic/textual descriptions), state-observation persistence (memory as stored observations vs. memory as estimates of the present), and real-time interactive generation (reducing generation latency vs. conditioning latency). Complementing the survey, the authors build a data engine for Black Myth: Wukong using a custom ReShade/OBS Studio split-screen recording setup plus engine-exported JSON action/state logs, annotated with slot-structured captions and Qwen3-VL-235B-A22B-Instruct-generated semantic captions.

Key results:

• Data engine collects over 90 hours of gameplay at 1280×720 resolution and 30 FPS.
• Data includes frame-aligned keyboard/mouse actions, engine-exported game states (health, stamina, poses, animations, equipment), RGB frames, and depth maps.
• Crowdsourced players of diverse skill levels captured boss-encounter footage lasting several minutes per encounter.
• The framework categorizes dozens of prior systems (e.g., GameNGen, Oasis, Matrix-Game 2.0/3.0, Genie 3, MineWorld) into the four-dimension taxonomy. No new trained model or quantitative benchmark accuracy is reported — the contribution is the taxonomy plus the released dataset.

Why it matters / caveats: Identifies that outcome-determination from accumulated conditions, cross-view consequence persistence, and rule-timed effect surfacing all hinge on making game state explicit, which most current models keep implicit; the paper explicitly flags integrating explicit state into the generation loop and grounding memory updates in state transitions as open challenges.

Problem: Existing masked diffusion model (MDM) samplers for joint text-image generation either decode modalities interleaved or in independent parallel branches that only share previous-step history, so cross-modal contradictions arise and, since standard MDMs cannot remask, these contradictions persist uncorrected through the rest of sampling.

Method: The paper introduces Self-Correcting Coupled Markov Jump Processes (SC-CMJP), where one modality's transition (birth/death) rates are functionals of the other modality's confidence score weighted by cross-modal attention extracted from a single frozen-model forward pass, combined with a ReMDM-style remasking jump. The resulting training-free sampler, CO2 Jump, uses asymmetric scoring: text positions scored by pure Self-Confidence (Gumbel-max sampling), image positions scored by an entropy-gated "Coupled Confidence" mixing Self-Confidence and a cross-modal Rank-normalized signal (gate λ = H̄image/(H̄image+H̄text+ε)); death (remask) and birth (unmask) quotas per step follow ReMDM-derived formulas. Trained/evaluated on three new corpora built on Lumina-DiMOO fine-tuned with 64×H100 GPUs, batch size 512, lr 2e-5: JEdit-1M (1M edit triples from ImgEdit+OmniEdit with Qwen3-VL-235B-generated scene graphs/thinking traces), JMaze-200K (DFS-perfect mazes, grids 6–20), JNono-200K (nonogram puzzles, grids 5–25).

Key results:

• On extended ImgEditBench: CO2 Jump achieves ImgEditBench score 1.93 and overall mAP@0.5:0.95 of 0.369, vs. MDM (1.78/0.354), ReMDM (1.73/0.353), MMaDA-Parallel (1.44/0.335).
• CO2 Jump beats Qwen3-VL-8B grounding on the same generated images (target mAP 0.346 vs. 0.330; overall 0.369 vs. 0.360).
• Scaling NFE from 8→512, CO2 Jump's ImgEditBench rises 1.72→1.93 and mAP rises 0.074→0.369 monotonically, while baselines plateau/regress (e.g., MMaDA-Parallel drops 1.52→1.44).
• On JMaze-Test500/JNono-Test500 joint accuracy: CO2 Jump scores 0.432/0.168 total vs. best baseline MDM 0.424 (maze) and MMaDA-Parallel 0.138 (nonogram); OOD nonogram accuracy 0.175 vs. 0.113 for the runner-up.
• Ablations: removing self-correction drops overall mAP from 0.369 to 0.337; removing shared percentile rank drops it to 0.344.

Why it matters / caveats: Demonstrates that within-step (not just across-step) cross-modal negotiation plus a remasking mechanism yields compounding gains with more denoising steps, unlike uncoupled samplers which saturate or degrade; requires a shared vocabulary MDM backbone (Lumina-DiMOO) and is validated on only three task types (editing, maze, nonogram).

Problem: Current models derive world knowledge and reasoning primarily from text, which cannot fully capture complex physical dynamics, spatial relationships, and long-horizon planning that are naturally expressed in raw visual demonstrations.

Method: UniVR initializes from Emu3.5 (34B, VQ-VAE-tokenized unified next-token-prediction model) and uses a two-stage pipeline: supervised cold-start fine-tuning on curated (query image, instruction, visual reasoning trajectory) triples, followed by VR-GRPO, a GRPO-based RL method with a format reward plus a reasoning reward Rreason = Rg − λ|Rg − Rs| combining a global reward Rg (Qwen3-VL-30B pairwise VLM judgment of overall trajectory quality) and a step-focal reward Rs that locates the highest-uncertainty reasoning sub-step via CLIP-embedding inter-trajectory variance and applies a targeted pairwise VLM comparison there. The authors also build VR-X, a benchmark of 1.5M raw samples curated from 16 sources (AgiBot, Action100M, EgoDex, VisualCoT, etc.) into 310K cold-start, 3K RL, and 1.8K evaluation samples across long-horizon planning and general reasoning tasks, scored by Qwen3.5-397B VLM score (0–100) and V-JEPA-based physical-dynamics similarity (JEPA, lower is better).

Key results:

• UniVR (34B) scores 58.2 overall on VR-X with JEPA 13.01, vs. base Emu3.5's 39.8 overall / JEPA 33.62 — a +18.4 point gain (task-level gains up to +25.2 on Guidance).
• On multimodal understanding benchmarks: MMMU improves from 0.292 (Emu3.5) to 0.337, MM-Vet from 28.0 to 35.6, MME(P) from 781.1 to 799.3.
• Ablation: combining global+step-focal+pairwise rewards yields VR-X LP=63.8/GR=55.4/JEPA=13.01, vs. global-reward-only LP=45.7/GR=46.0/JEPA=22.30 (global reward alone causes reward hacking/degradation).
• On three external benchmarks (WorldArena, Uni-MMMU, RBench), UniVR improves over Emu3.5 by up to 24.3%, e.g., Uni-MMMU 28.7→54.4.

Why it matters / caveats: Shows that a global VLM-based reward alone under-detects intermediate physical/logical errors in long multi-step visual trajectories (over-prioritizing terminal success), and that a step-focal reward targeting high-uncertainty sub-steps is necessary to prevent this reward hacking; the paper notes vanilla SFT with joint heterogeneous task training underperforms task-specific training unless VR-GRPO is applied, and on long-horizon robot manipulation UniVR still trails Gemini-3-pro (48.5 vs. 63.7).

Problem: Full-parameter RL post-training of LLMs is a black-box update that suppresses reasoning performance at high sampling budgets (premature test-time-scaling saturation) and creates cross-domain interference when consolidating multiple capabilities via multi-domain training or model merging.

Method: The paper decomposes the RL update ΔW = W_RL − W0 in the base model's SVD coordinate system (W0 = UΣVᵀ) and defines Subspace-Aligned Rewiring (SAR): project the top-k low-rank component of ΔW onto the pretrained left/right singular vectors via M = Uᵀ ΔW_k V (the "rewiring matrix"), then reconstruct W_SAR = W0 + U M Vᵀ. SAR is applied only to attention (Wq,Wk,Wv,Wo) and MLP (Wgate,Wup,Wdown) weights per transformer block, leaving embeddings, LM head, biases and norms untouched, and is tested on models from 1.5B to 32B (DeepScaleR, POLARIS, OLMo-3.1-32B-Think, OLMo-3-7B) plus used for Mix-RL purification and math/code expert merging (Task Arithmetic/TIES/DARE+TIES baselines).

Key results:

• Preserves >99% of peak Pass@1 while retaining as little as ~0.58% of total parameters (DeepScaleR 1.5B) and ~0.64% (OLMo-3.1-32B).
• Improves 6 of 7 open agentic coding benchmarks on an in-house model, e.g. +25.10% relative on TerminalBench 2.0 and +22.86% on MSWE-Bench (ClaudeCode), average +2.52%.
• On Mix-RL (OLMo-3-32B), improves LiveCodeBench v5 from 67.61%→69.09% and v6 from 64.30%→65.25%, and AIME25 Pass@16 from 88.33%→91.71%, while IFEval barely moves (92.42%→92.05%).
• In expert merging at 1.5B, SAR reaches AIME24 AVG@32 43.44% / LCB AVG@8 32.25%, beating both best single-domain experts (40.31% math, 31.80% code) simultaneously; at 14B reaches 74.38% AIME / 63.40% LCB vs. best experts 74.27%/61.00%.
• On AIME24 with 256 rollouts, SAR covers 26/30 problems vs. 25/30 for full RL.

Why it matters / caveats: Suggests RL mainly reorganizes latent base-model capability rather than injecting new knowledge, giving a training-free, post-hoc editing route to better exploration and multi-domain merging. The authors note SAR's benefit is bounded by "projection compatibility": very heavily RL-trained models or code RL without prior SFT are less compatible with spectral projection, leaving a residual gap to full RL.

Problem: Existing embodied AI models split cognition into either vision-language models (textual task reasoning without explicit visual goal imagination) or world/generative models (visual state prediction without causal/constraint reasoning), so neither alone can fully specify an executable embodied plan.

Method: RxBrain (Hy-Embodied-RxBrain, built on HY-Embodied-0.5) uses a modality-aware Mixture-of-Transformers architecture with a shared HY-ViT 2.0 vision encoder and a FLUX VAE for generation; visual understanding and generation tokens share attention projections but route to separate FFN experts (generation FFN widened from 6,144 to 12,288 dims), while text uses causal attention and vision uses hybrid causal+frame-wise bidirectional attention. Total model size is 6.2B parameters (~1.5B each for text and visual-understanding branches, ~2.4B visual-generation expert, plus a 0.45B SigLIP tower, 0.25B tied embeddings, 7M flow-matching head, external 83.8M frozen VAE). Training data is built via an automatic pipeline (Temporal Segment Annotation → Quality Verification → Segment Structuring) converting embodied videos into joint text-visual plans, yielding 50,177.2 hours / 21,506,919 trainable segments across four source types (Real-Robot, UMI, Simulation, Egocentric Human data); the model is further extended to continuous robot action generation and evaluated with the new RxBrain-Bench (EVQA, WorldPred, JointPlan tracks).

Key results:

• GenEval (text-to-image) score 82.4, on par with Bagel (82) and ahead of Cosmos-3-Nano (71.68).
• Leads CV-Bench (88.59), EmbSpatial (82.3), DA-2k (83.4); best on 3DRSBench (54.1), MMSI-Bench (35.8), MindCube (47.5), SITE-Bench-Image (54.9).
• RxBrain-Bench-EVQA overall score 72.7 (1,123 MCQs + 258 simulation-planning samples), best on Success Detection (85.1) and Simulation Planning (51.6).
• RxBrain-Bench-WorldPred: Sgen = 0.62, beating Cosmos3-Nano (0.591) and Wan2.2-TI2V-5B (0.429).
• RxBrain-Bench-JointPlan: Splan = 0.68 vs. Cosmos3-Nano agent (0.521), BAGEL-7B-MoT (0.503), Qwen-Agent (0.431).
• On real-robot action tasks: success rates of 97% (Set the Table), 95% (Fold and Store Glasses), 68% (Pick Trash), average 87%, vs. π0 (68%) and π0.5 (82%).

Why it matters / caveats: Demonstrates a single unified model can match specialized world models on future-frame prediction while outperforming modular pipelines on interleaved text-visual planning, and transfers to real-robot action without large-scale action-data pretraining. The paper notes remaining gaps: overall RxBrain-Bench-EVQA score (72.7) trails Qwen3.5-4B (78.1) and Cosmos3-Nano (76.7), and goal-image correctness/temporal plausibility remain the main bottlenecks.

Problem: Prior native-streaming interactive video models (Wan-Streamer v0.1/v0.2) treat "an agent that talks and reacts" as a single fixed training objective, without a general formulation of what underlying competence such models should learn from raw video.

Method: Wan-Streamer v0.3 reframes any video as a persistent "world" W (environment, subjects, ambient acoustics, voice, style) plus a time-localized "event stream" of records e_k = (τ_k, c_k, d_k) (interval, character association, free-form description), giving a general pretraining factorization p(e_{1:K} | W, x_{1:K}) = Π p(e_k | W, x≤k, e<k), where discrete tokens (language, behavior directives) use next-token prediction and continuous audio/video latents use conditional flow matching. This is instantiated for real-time full-duplex audio-visual interaction by conditioning on a world and letting the event stream be the agent's interleaved speech-plus-free-form-behavior response in a role-play chat format (parenthesized behavior directives), inheriting the v0.2 Thinker + Ulysses-style context-parallel performer serving topology.

Key results:

• Preserves the v0.2 operating point: 640×368 video at 25 FPS, 160 ms streaming unit, ~200 ms model-side response latency, ~550 ms total interaction latency under a 350 ms bidirectional network budget.
• Same latency/resolution numbers hold across v0.1 (192×336) → v0.2 (640×368) → v0.3 (same resolution/latency, expanded behavior channel).
• No new quantitative benchmark scores are reported beyond latency/resolution figures and qualitative behavior observations.

Why it matters / caveats: Proposes a scalable, general-purpose pretraining objective reusable across roaming, embodied manipulation, and audio-visual interaction rather than one bespoke interaction task, while adding open-vocabulary behavior expression without introducing new latency-critical paths. The paper is a technical report with only qualitative behavior evaluation for this version — no quantitative interaction-quality or user-study metrics are reported.

Problem: On-policy distillation (OPD) for LLM post-training has inconsistent empirical behavior (sometimes helps, sometimes collapses or underperforms RLVR) and its training dynamics, failure modes, and fixes are not well understood.

Method: The paper analyzes OPD as policy-gradient optimization of the per-token log-ratio advantage Δℓ_t = log π_T(y_t|y<t)/π_θ(y_t|y<t) under PPO-style clipping, using Qwen3-1.7B-Base/Qwen3-1.7B as students and Qwen3-{1.7B,4B}-GRPO / Qwen3-{4B,8B,32B}/Qwen3-4B-Instruct-2507 as teachers, trained on the Nemotron-Cascade Math dataset via the verl framework. It defines an "Informativeness" metric I = E[Δℓ|r=1] − E[Δℓ|r=0] to diagnose Student-Teacher Mismatch, and proposes two zero-overhead signal regulations replacing raw Δℓ_t: Hard Clipping (ã_t = clip(Δℓ_t, c_min, c_max)) and Soft Log-Scale Compression (ã_t = sign(Δℓ_t)·log(1+|Δℓ_t|)).

Key results:

• Pass@k experiments show OPD/GRPO students converge to the base model's ceiling by high k, confirming OPD does not expand capability.
• Prompt-diversity ablation: rollout depth n=1 (max prompt coverage) beats n=2 and n=8 under identical compute.
• Teacher-quality inversion: distilling from the strongest teacher (Qwen3-4B-GRPO) leaves AIME25 accuracy near 2% throughout training, while the weaker Qwen3-1.7B-GRPO teacher yields the highest final accuracy.
• With Qwen3-1.7B-GRPO teacher, OPD+Scale (log-compression) raises average score from OPD's 28.1 to 30.4 (MATH500 79.3, AIME25 15.6, HMMT25 7.3).
• With Qwen3-4B-GRPO teacher, Hard Clipping lifts average score from 26.7 (OPD) to 28.1.
• Regulated OPD with a 4B teacher decisively surpasses prior methods distilled from a 30B teacher (e.g., UniOPD 35.2 / GOPD 37.3 on AIME24 with a Qwen3-30B-A3B-Instruct teacher).

Why it matters / caveats: Reframes OPD as an exploration catalyst (like RL) rather than a capability-expanding distillation mechanism, and shows signal quality/regulation—not teacher scale—governs OPD success. The authors note the regulation hyperparameters require empirical tuning per teacher-student capacity gap, and the study is limited to verifiable math reasoning benchmarks.

Problem: State-of-the-art robot foundation models operate with only single-step or short-history visuomotor context, preventing capabilities like one-shot in-context imitation, on-the-fly policy improvement, and robust long-horizon multi-stage task execution.

Method: RoboTTT integrates Test-Time Training (TTT) layers into a Vision-Language-Action policy built on GR00T N1.7, adding a TTT layer after each of GR00T's 16 DiT self+cross-attention layers, where fast weights are updated by gradient descent both during training and inference to compress rollout history into weight-space while attention handles single-timestep information via N=16 register tokens, blended via a learned tanh-gate (α initialized ~0.001). Training uses a flow-matching action loss with "sequence action forcing" combined with truncated backpropagation through time (fast weights carried across segment boundaries with gradients detached) to scale context to 8K timesteps without growing GPU memory; DAgger Distillation further trains fast weights on full DAgger trajectories (masking the imitation loss to corrections only) to teach on-the-fly recovery.

Key results:

• RoboTTT-8K scales visuomotor context to 8,000 timesteps, three orders of magnitude beyond prior policies, without increasing inference latency.
• Achieves average task completion score of 79% across three assembly tasks, 87% higher than single-step-context GR00T N1.7 (42%) and 41% higher than the best baseline GDN (56%).
• Only method to achieve full successes (2/10) on the 5-minute, 10-stage Gear Bot task; no baseline ever completes it.
• One-shot imitation from in-context human video: 6/10 successful trials (65% completion score) vs. GDN's 0/10 (33%).
• Perturbation robustness: 15/20 roof-perturbation recoveries and 18/20 tire-perturbation recoveries, vs. 10/20 and 5/20 for the best short-context baseline.
• Scaling pretraining context from 1K to 8K timesteps raises closed-loop task completion from 43.9% to 71.5%, with no saturation observed.

Why it matters / caveats: Establishes context length as a new, empirically validated scaling axis for robot foundation models, unlocking behaviors—one-shot imitation, on-the-fly recovery, long-horizon robustness—not achievable with short-context or naive-history baselines. The paper notes naive history concatenation can hurt performance versus no history at all, and below ~1K context length RoboTTT's advantage shrinks because rollout horizons can exceed the trained context window.

Problem: Forward-process RL methods like DiffusionNFT operate on instantaneous velocity fields, but MeanFlow generators sample using average velocity over time intervals, so no likelihood-free RL framework existed to align MeanFlow's few-step generators with reward signals.

Method: MeanFlowNFT substitutes the MeanFlow network's average-velocity prediction into the MeanFlow identity (v = u + (t−s)·d/dt[u]) to construct an induced instantaneous-velocity predictor, then applies the DiffusionNFT implicit positive/negative parameterization and reward-weighted flow-matching loss to this induced predictor while keeping the sampler on average velocity. Practical tricks include approximating the total-derivative (JVP) term with a central finite difference in t, sharing the same derivative estimate between the trainable and EMA reference predictors, and displacing points using the model-free conditional velocity rather than the network's own velocity. Trained with LoRA (rank 32) on SD3.5-Medium (image) and Wan2.1 1.3B (video), using rewards CLIPScore/PickScore/HPSv2 (image) and HPSv3/VideoAlign (video).

Key results:

• On SD3.5-M, 4-step MeanFlowNFT scores best on 6 of 8 metrics among few-step models (ImageReward 1.45, OCR 0.65 vs. RTDMD's 0.30).
• Matches or beats the 40-step DiffusionNFT baseline with 10x fewer function evaluations (ImageReward 1.45 vs 1.41, CLIPScore 0.297 vs 0.289).
• On Wan2.1 1.3B video generation, 4-step MeanFlowNFT reaches VBench total 84.33, beating 50-step LongCat-Video RL's 82.57.
• Naively applying DiffusionNFT directly to other few-step generators (AnyFlow, DMD, CDM) causes training collapse (e.g., CDM+DiffusionNFT diverges within 400 steps), unlike MeanFlowNFT.

Why it matters / caveats: It is the first forward-process RL framework compatible with average-velocity (flow-map) generators, enabling RL-aligned few-step image/video generation at a fraction of the sampling cost of multi-step RL methods. The authors note they only tested DiffusionNFT-style objectives and only the MeanFlow instance of flow-map models, leaving other RL objectives and flow-map families to future work.

Problem: Standard residual-scaling rules like DeepNorm are derived assuming untied depth (each layer has its own parameters), but looped Transformers reuse the same physical blocks across multiple rounds, so the shared parameter update is aggregated across repeated visits and re-read by those same visits, which existing scaling analyses do not account for.

Method: The paper introduces a visit-alignment coefficient κR measuring how correlated per-round gradient/sensitivity contributions are, yielding a first-order stability bound M·κR·(β/α)² = O(1) (versus untied DeepNorm's M·(β/α)² = O(1)), which for the scaling family α=(cN)^p, β=(dN)^−p implies the exponent must grow from p=1/4 (decorrelated visits) to p=1/2 (fully aligned visits) at fixed physical depth K. DeepLoop keeps the Post-LN DeepNorm architecture but sets α=(2N)^1/2 and β=(8N)^−1/2 (N = unrolled depth = KR). The analysis is extended to hierarchical recurrent reasoners (e.g., HRM) by replacing the visit count with a gradient-visible count under one-step gradient truncation, predicting p=1/2 is also optimal there.

Key results:

• On GPT-2 small (124M) trained on FineWeb-Edu (50B tokens), DeepLoop ties the baseline at R=1 (+0.0004 nats) but improves validation loss by −0.0231 nats at R=5 and −0.0186 at R=7.
• On GPT-2 medium (350M, doubled to 24 layers), the gap widens monotonically to −0.0278 nats at R=7.
• Downstream 8-task lm-eval-harness average (medium scale) improves from tied at R=1 to DeepLoop leading by +0.58 points at R=7 1-shot, with WinoGrande gaining +1.74 points.
• On ARC-AGI-1 with HRM, DeepLoop (p=1/2) improves the paper-protocol K=2 voted accuracy from 36.50% to 39.75% (+3.25 pp), with gains at every voting budget K∈{1,2,10,100,1000}.

Why it matters / caveats: Shows that stable scaling of looped/recurrent-depth Transformers requires accounting for parameter-visit aggregation, not just nominal layer count, giving a one-line, tuning-free scaling rule. The authors note these are single-seed runs for the language modeling experiments, and future work should measure κR directly and test the rule at larger scale.

Problem: Existing song-generation systems rely on autoregressive or cascaded AR+diffusion pipelines that struggle to jointly deliver efficient generation, high-fidelity long-form audio, and controllable dual-stem (vocal/BGM) output.

Method: WanSong is a pure diffusion, single-stage model built on a hybrid-MMDiT transformer backbone (fully-shared AdaLN per block as in Wan2.1) conditioned on an LLM text captioner, where text and dual-stem audio continuous tokens are concatenated into one sequence; total model size is ~25B with an N/(N+K)=0.3 layer-sharing ratio. Audio is encoded via a continuous 1-D VAE (64 channels, 1024x downsampling, ~43.1 Hz latent rate, trained on 2.6×10^8 clips at 44.1kHz) using multi-resolution STFT magnitude loss, feature-matching loss, hinge adversarial loss, and KL loss. A dual-stem "joint-learning-in-layer" scheme keeps vocal and BGM tokens as separate output channels while sharing internal block computation; training uses flow matching across 90s/300s/SFT stages, plus RLHF via reward models combined with DPO followed by ReFL.

Key results:

• VAE at 1024x compression beats Stable Audio 2: on the music benchmark, SI-SDR improves from 4.386 dB (Stable Audio 2) to 7.246 dB (Ours 1024); on SeedTTS speech, SI-SDR reaches 12.922 dB vs 8.653 dB.
• On the WanSong benchmark (200 samples, 4 languages), WanSong achieves Pronunciation Error Rate 7.43% vs SunoV5's 22.80% and MurekaV7.6's 12.7%.
• On a custom musicality evaluation model (trained on 80k human-annotated songs), WanSong scores 5.49 vs SunoV5's 4.18 and MurekaV7.6's 3.83.
• Ablation shows compression ratio (not patch size) drives quality: compression 1024/patch 1 gives PER 15.0%/Quality 3.2, versus PER 19.2%/Quality 2.1 at compression 2048/patch 1.

Why it matters / caveats: Demonstrates that a single-stage, non-autoregressive diffusion pipeline can generate up to 5-minute multilingual songs with separated stems, simplifying editing workflows versus AR/cascaded designs. The paper notes existing automatic evaluators show only small score differences and may not generalize well, motivating their own trained musicality model.

Problem: No existing benchmark comprehensively evaluates multimodal LLMs as real-world assistive tools for visually impaired individuals across proactive, reactive, and interactive assistance behaviors using authentic long-form footage recorded by blind users themselves.

Method: VIABench is built via a five-stage annotation pipeline covering three tasks: Proactive Reminder (21 fine-grained sub-tasks, model must autonomously flag navigation-critical events), Visual Question Answering (online, causal, no future-frame access), and Vision-Guided Interaction (multi-turn closed-loop instruction giving). To evaluate offline MLLMs on the streaming Proactive Reminder task without fine-tuning, the paper proposes Token-Level Prompt Activation Decoding (TPAD), which feeds the full concatenated prompt+video token sequence through the model once, extracts each frame's final hidden state, projects it through the LM head, and computes a per-frame alert probability via softmax over the "Yes/No" answer tokens in a single forward pass.

Key results:

• The dataset contains 761 videos and 14,526 manually curated annotations totaling 46.9 hours, with average video duration 222s (max 1959s) versus 40s average in EgoBlind and 3s in WalkVLM.
• 530 real videos from visually impaired creators (~44 hours) plus 231 purpose-filmed simulated videos for Vision-Guided Interaction; 94% of data comes from actual VII recordings.
• The best model overall, GPT-5, reaches only an average Proactive Reminder score of 28.8 (out of 100) across sub-tasks; VQA and Vision-Guided Interaction scores (62.9 and 51.7 for GPT-5) are markedly higher.
• Purpose-built online streaming models perform far worse than offline models adapted via TPAD: VideoLLM-Online scores 0.2 Avg. and StreamingVLM scores 0.6 Avg. on Proactive Reminder, versus InternVL3.5-8B's 18.5 with TPAD.

Why it matters / caveats: Shows current MLLMs, even top proprietary ones, have only nascent proactive-assistance capability despite strong VQA performance. The authors note existing streaming models are trained mostly on dense captioning/narration data, which poorly prepares them for the complex instructions of real-world assistance.

Problem: Improving a language model's capability typically requires retraining/fine-tuning (costly) and reducing serving cost requires more accelerators, whereas repeatedly recomputing the same context (KV cache) on every inference call wastes compute without adding any new capability.

Method: The paper introduces Taliesin, a byte-exact KV-state capture/restore ("graft") mechanism verified via SHA-256 hash equality of output logits and zero KL divergence versus a fresh computation under a pinned deterministic configuration, and Galahad, a verify-then-cache "flywheel" loop that solves a problem with extra inference effort, verifies it via an external sound check (code execution or ground-truth matching), and deposits the verified solution as a persistent single-block KV artifact on disk, later restored via one-shot classification routing. Experiments run on frozen Gemma-4-12B (RTX 5090) and Gemma-4-31B (H100, B200), anchored against vendor model-card scores.

Key results:

• Frozen Gemma-4-12B improves from 80.0% to 93.3% on AIME 2025 (28/30) after grafting an 8-problem verified solution library (441 MB KV state, ~4,571 tokens), exceeding both its own 77.5% model-card anchor and the 31B's 89.2% anchor.
• On the 8 recurring problems the base model never solves in a 401,026-token best-of-5 budget, the flywheel solves all 8 in 61 total decode tokens, a 6,574x token reduction.
• The same byte-exact store widens usable context from a 32,768-token serving window to 2,854,766 tokens (87.1x) at zero extra accelerator memory, with constant per-access cost (0.29s restore) regardless of depth.
• Own-position graft achieves exact zero KL divergence across 50 samples with 0/50 argmax disagreements and 5/5 SHA-256 byte matches; on a frozen 31B (H100), held-out transfer reaches 7/7.

Why it matters / caveats: Demonstrates verified knowledge can be added to a frozen model's inference-time behavior without any gradient step, at dramatically lower cost than sampling-based capability gains. Stated limitations: byte-exactness holds only at the original capture position and same GPU architecture; transfer fails when cached code hard-codes problem-specific constants (2 of 7 misses); a cached procedure can actively hurt accuracy (55-point drop in one negative-control case); and the router has no confidence gate, so confident-wrong grafts remain structurally possible.

Problem: The paper tests whether LLM in-context estimates, when treated as conditional probability estimates (e.g., in persona prompting), actually obey basic probability axioms such as the law of total probability across different partitions of a population.

Method: The authors build binary conditioning trees (BCTs) that recursively partition a population (the 2024 American Community Survey, 3.8M individuals) via demographic split criteria, verbalize each node as a natural-language persona description, and elicit LLM estimates of tail probabilities (e.g., P(income > τ)) and subgroup priors via in-context learning. They reconstruct population-level aggregates at each tree level using the law of total probability and compare them against direct root-level prompting and against ACS ground truth, formalizing two reference-free self-consistency checks: split consistency and order consistency.

Key results:

• Reconstructed aggregates from finer subpopulation estimates are consistently more aligned with ACS ground truth than direct root-level ("macro") prompting — a pattern the authors call the "macro fallacy" — across models (GPT-5.4, GPT-4o mini, Opus 4.7, Sonnet 4.6, Gemini 3.1 Pro, 4.20, Gemini 3 Flash, 3.6 Plus, K2.6) and income thresholds (τ = 100 to 80k USD).
• Aggregation gain follows a concave trend with tree depth: alignment improves through the first ~2-3 refinement levels then can decline at deeper levels as LLM-estimated subgroup priors become less accurate.
• Micro-to-macro prompting partially recovers the aggregation benefit with almost no extra compute, though gains are model-dependent.
• Split-consistency violations imply worst-case error accumulation growing linearly with tree depth, though observed empirical error grows more slowly than this bound.

Why it matters / caveats: Suggests LLMs possess relevant subpopulation-level knowledge but fail to reliably propagate it into aggregate estimates, establishing statistical self-consistency as a reference-free evaluation criterion not saturated even by frontier models. The study's case is limited to income-related tail probabilities and demographic splits.

Problem: Existing generalizable 3D Gaussian Splatting models for long-sequence, high-resolution novel view synthesis (e.g., LongLRM) stack many identical layers over fine-grained tokens for both geometry and appearance prediction, causing redundant computation and high parameter demand.

Method: AsySplat decouples geometry and appearance modeling into two asymmetric branches: a geometry branch processing coarse-grained tokens (patch size 16) through three hierarchical stages combining bidirectional Mamba (4 layers) with a sparse attention module, holding most of the model's parameters; and a lightweight appearance branch using fine-grained tokens (patch size 8, fixed width 256) with MambaVision layers restricted to intra-frame interactions (~10% of total parameters). The branches exchange information via a bilateral connection module (cross-attention + self-attention) per stage, merged via a strided 3×3 convolution to predict Gaussians. Training uses a progressive resolution schedule (256×256 → 512×512 → 540×960).

Key results:

• On DL3DV-140 with 32-view 960P inputs, AsySplat achieves near-800× speedup over 3DGS optimization (<1s vs. 13min) with higher PSNR (24.0 vs. 23.6); with 10 post-optimization iterations (18s) PSNR reaches 25.2, beating Scaffold-GS's 24.8.
• Versus LongLRM (142M params), AsySplat uses 98M parameters (30% fewer), reduces training time by ~30%, cuts inference FLOPs by 20%, predicts 50% fewer Gaussians, and achieves 60% faster post-optimization.
• On synthetic Replica (0 post-opt iterations), AsySplat scores 27.46 PSNR vs. LongLRM's 25.89; with 10 iterations, AsySplat reaches 30.83 PSNR.
• The sparse attention module reduces iteration time at 540×960 resolution from 8.5s (full attention) to 6.0s while keeping GPU memory at 48G vs 52G.

Why it matters / caveats: The asymmetric allocation of computation and parameters lets a smaller model match or beat a larger stacked baseline in both quality and efficiency across four benchmarks. A stated limitation is that AsySplat trails competitors on LPIPS across several benchmarks, attributed to the lack of error-based densification common to generalizable 3DGS methods.

Problem: Agentic RAG systems struggle to decide when to retrieve, whether to use lexical or semantic search, and what context granularity to expose at each reasoning step, causing hallucination and error propagation in multi-hop question answering.

Method: GRASP formulates adaptive multi-tool retrieval as an RL problem trained with GRPO on a Qwen2.5-3B-Instruct policy, with three retrieval/read actions—semantic search (dense retrieval via Qwen3-0.6B), keyword search (BM25), and paragraph reading (expands a retrieved sentence to its parent paragraph)—plus a termination/answer action. The trajectory-level reward combines answer accuracy (token-F1), grounded reading (F1 between read and gold documents), complementary search (both semantic and keyword surface a gold document), and turn efficiency, aggregated as R = RA + 0.7·RR + 0.15·RS + 0.15·RE. Training uses the HotpotQA distractor split (90,447 examples) via the Verl-Tool framework.

Key results:

• Retrieval recall: GRASP reaches 0.90/0.90/0.70 on HotpotQA/2Wiki/MuSiQue vs. Search-R1 (GRPO) at 0.74/0.77/0.62.
• QA metrics (EM/F1/JD): GRASP achieves 0.53/0.66/0.71 on HotpotQA, outperforming Search-R1 (GRPO) at 0.45/0.56/0.58.
• Ablations: removing paragraph reading costs 0.122 EM / 0.147 F1; removing semantic search costs 0.072 EM / 0.064 F1; removing keyword search costs 0.012 EM / 0.010 F1.
• Per-step total reward rises from ~0.26 at the start of training to ~1.22 at convergence; tool-call usage stabilizes at approximately 8 calls per trajectory.

Why it matters / caveats: The learned policy exhibits interpretable "skimming and scanning" behavior, beating single-step, prompting-based, and RL-based baselines without distillation from a larger proprietary model. Stated limitations: the reward relies on gold supporting-fact annotations, limiting applicability to unlabeled corpora, and experiments use only a single 3B backbone.

Problem: Zero-shot CAD-to-image alignment methods that match visual foundation model features to CAD models produce appearance-driven correspondences that degrade under occlusion and sim-to-real domain shift, and typically require costly iterative pose refinement.

Method: SUFLECA trains a lightweight NOC (Normalized Object Coordinates) head—two shallow convolutional layers with a 64-bin classifier per coordinate axis—on top of a frozen DUNE-B perception encoder whose multi-scale features are fused via a Dense Prediction Transformer, supervised over 674K images from 12 real and synthetic datasets. At test time the NOC head is discarded and ℓ2-normalized DPT features are used for correspondence estimation via mutual k-nearest-neighbor matching (k=13) against pre-rendered CAD views, followed by anisotropic-scale estimation and eigenvector-based consensus filtering, before a space-partitioning RANSAC with Procrustes registration recovers the final pose; alignment quality is scored via a log-determinant fit score rather than a retrieval-confidence proxy.

Key results:

• On ScanNet25k, SUFLECA achieves 33.4%/42.3% category/instance accuracy, beating the strongest zero-shot baseline ZeroCAD by 10.3/12.2 percentage points, and surpasses fully supervised methods on 7 of 9 categories.
• On the DiffCAD split, SUFLECA reaches 36.1%/44.8% vs. ZeroCAD's 15.9%/20.9%, more than doubling its performance.
• Efficiency: SUFLECA uses a 384-dim feature (2.0×–5.3× smaller than competitors), 2,178 MB peak VRAM, 0.53s per-instance alignment, vs. ZeroCAD's 2048-dim/5,158 MB/3.77s.
• On CO3D unseen categories, SUFLECA-blend attains 49.50 3D-IoU vs. Diorama's 39.12 and DINOv3-L's 8.77.

Why it matters / caveats: SUFLECA is the first zero-shot method to surpass fully supervised CAD alignment on ScanNet25k while running sub-second without iterative refinement. Stated limitations include continued dependence on CAD retrieval accuracy (a >20-point accuracy gap with fully zero-shot retrieval) and restriction to indoor scenes and common object categories.

Problem: Streaming autoregressive video diffusion models generate efficiently but commit irreversibly to early decisions, limiting multi-step reasoning, while bidirectional diffusion models support global revision but require costly dense full-sequence denoising incompatible with low-latency streaming.

Method: HDR (Hierarchical Denoising for Visual Reasoning) organizes video latents into an L-level tree-structured hierarchy (built on Wan2.2-5B-TI2V, six hierarchy levels) where coarse tokens summarize global temporal structure and fine tokens encode local detail. Training uses a layer-wise flow-matching objective summing velocity-regression losses across all hierarchy levels, with a level-dependent sampling budget so coarse layers stop at higher residual noise while finer layers denoise further. Inference flattens the tree into a coarse-to-fine autoregressive order and applies SHAP (Sparse Hierarchical Attention Pattern), a structured mask restricting each token's attention to its same-level predecessor, parent/neighboring-parent tokens, and the first-frame condition, enabling constant-size attention and cross-level KV-cache sharing.

Key results:

• On a constructed 6-task benchmark (Tower of Hanoi, maze, one-line drawing, sliding puzzle, Sokoban, water pouring; 370 held-out videos), HDR improves overall success from 34.22 (CausalForcing baseline) to 60.29, a 76.2% relative gain.
• HDR achieves 0.70s per-latent streaming latency vs. 0.72s for CausalForcing and 37.92s for bidirectional diffusion (54.2× faster than bidirectional).
• Under 1-step denoising, HDR retains 57.6% of its full-step success vs. 32.9% for CausalForcing and 29.6% for bidirectional diffusion.
• With only 2% of training data, HDR retains 82.9% of its full-data success score vs. 52.0% for bidirectional diffusion.
• Layer-count ablation shows success rising from 34.22 (1 layer) to 60.29 (6 layers), with monotonic gains at each added hierarchy level.

Why it matters / caveats: Demonstrates that matching denoising strength to a latent hierarchy plus sparse attention can recover much of bidirectional diffusion's global-revision reasoning benefit while preserving near-streaming-autoregressive latency. The paper does not report failure modes or limitations beyond the benchmark's synthetic/robot-maze scope.

Problem: Discrete-space diffusion language models suffer from a "factorization problem" at high speedups (few generation steps) because multiple tokens are sampled in parallel from a product-marginal approximation rather than the true joint distribution, degrading text quality.

Method: The paper introduces Token Time Continuous Diffusion (TTCD), which interpolates token embeddings continuously from Gaussian noise (t=0) to clean embeddings (t=1) but assigns each token its own local time via a rank variable and a quantile-function schedule, so tokens deemed "sure" (via post-hoc entropy of a single forward pass) are denoised earlier while prompt tokens are pinned at time 1 for conditional generation. The model modifies a DiT's adaLN layers to condition on per-token times instead of a single global time (no new parameters), and is further distilled with a self-consistency "shortcut" loss minimizing KL between one-step and two-step-unrolled predictions.

Key results:

• On 9x9 Sudoku solving with a 6M-parameter transformer, TTCD achieves 31.51% board-solve accuracy at 2 generation steps vs. 11.65% for discrete entropy-based masking and 0.62% for discrete random masking.
• At 16 steps, discrete entropy-masking reaches 97.30% vs. TTCD's 68.46% (TTCD is second-best at higher step counts).
• A 160M-parameter TTCD model trained on OpenWebText for 1M steps, when distilled via shortcut, matches or outperforms Duo w/ DCD and FMLM on unconditional generation up to 4 steps, and achieves the best generative-perplexity/entropy trade-off on prefix-conditioned generation at 2 and 4 steps (16x and 8x speedups).

Why it matters / caveats: Shows continuous-space diffusion LMs can be made competitive with discrete diffusion at aggressive speedups while naturally supporting prefix-conditioned generation, which prior continuous methods handle poorly. The authors note results are limited to ~100-160M parameter scale, with scaling to 1B parameters left for future work.

Problem: Automatically generating executable, regulation-grounded test scenario scripts (in the Scenic DSL) from natural-language/regulatory descriptions is unreliable: retrieval-assemble methods generalize poorly while direct full-script LLM generation has low compilation success rates.

Method: Chat2Scenic uses a Gradio chatbot interface with an LLM-based Interpreter (using LangGraph checkpointing for iterative refinement) that decomposes a scenario into a logical structure (global config, spatial relations, ego behavior, objects, restrictions/termination). A dual-retriever RAG module queries a component-level Scenic code snippet database (sentence-transformers all-MiniLM-L6-v2 embeddings) and a documentation database (hybrid BM25 + embedding retrieval via Reciprocal Rank Fusion). A Generation Module iteratively synthesizes DSL code per component in dependency order, each conditioned on prior generated code, using Contextual Prompting, Chain-of-Thought, In-Context Learning, and RAG-ICL, before concatenation into a complete Scenic program runnable in CARLA 0.9.15.

Key results:

• Best configuration (CP+CoT+ICL+CodeICL, Gemini-3-Flash) achieves 76.42% Compilation Success Rate and 58.17% Framework Accuracy, vs. 30.08%/11.03% for ChatScene and 16.26%/10.86% for NL2Scenic.
• Zero-shot baseline scores 0% CSR/FA; adding Contextual Prompting alone raises CSR to 12.20%; CP+ICL reaches 47.15% CSR/32.62% FA.
• Benchmark comprises 123 regulation-grounded scenarios (24 from CARLA Leaderboard, 47 from NHTSA crash data, 52 from UN Vehicle Regulations).
• Open-source models (Qwen3-Coder:30B, Qwen3:30B, Gemma3:27B) achieve near-0% CSR (0–1.62%); response time for the best config is 222.11 seconds per scenario.

Why it matters / caveats: The first iterative, component-wise RAG framework for regulation-grounded DSL scenario generation substantially raises compilation reliability over prior assemble/direct-generation baselines. The paper notes response time (222s) is markedly slower than SOTA baselines, an acceptable trade-off only for offline scenario generation, and that adding a documentation-retrieval tier did not improve—and sometimes hurt—performance.

Problem: Automatic LLM-agent harness evolution methods are typically evaluated by searching for harness configurations using benchmark task feedback and then reporting performance on that same benchmark, conflating genuine harness-design gains with simple test-time search/overfitting effects.

Method: The authors formalize four methods under a matched compute budget K=5: Parallel Sampling (K independent trajectories, fixed harness), Sequential Refinement (iterative trajectory revision, fixed harness), Harness Evolution (a meta-agent updates a shared harness across a batch of tasks using an experience store, instantiated via AHE with its explore-agent disabled), and a newly introduced Harness Scaling (instance-level harness adaptation for a single task via a meta-agent updating the harness after each rollout). All methods start from an identical minimal harness (a single bash tool, no skills/middleware/memory) and are tested on Terminal-Bench 2.1 (89 verified terminal tasks) with Claude Opus 4.6, GPT-5.4, and GPT-5.4 mini.

Key results:

• Without unit tests: average pass@1 is 72.3% for Parallel Sampling, 71.8% for Harness Scaling, 69.3% for Sequential Refinement, and 67.4% for Harness Evolution, vs. 68.2% for the direct-sampling baseline — Harness Evolution underperforms the baseline overall.
• With unit tests: Parallel Sampling reaches 86.0% average pass@1 vs. Harness Evolution's 75.8% and Harness Scaling's 82.6%; Sequential Refinement leads pass@5 at 91.8%.
• Generalization test (45 train/10 val/34 held-out test tasks): Harness Evolution improves Claude Opus 4.6 by only +1.2 points and GPT-5.4 by +0.0 points, for an average gain of +0.6 points over the initial harness.

Why it matters / caveats: Suggests current harness-evolution gains largely reflect repeated sampling/search rather than transferable harness-design improvements, and evolved harnesses overfit to their search task set with limited generalization to held-out tasks. The authors note this may partly reflect Terminal-Bench being insufficiently harness-sensitive, and call for benchmarks with more headroom to properly evaluate harness evolution.

Problem: It is unknown whether human-like local, sequential (foveated) visual processing provides a fundamental computational benefit over the single global forward-pass encoding used by most vision models, specifically for length/complexity generalization in visual reasoning tasks.

Method: The authors introduce four synthetic/real testbed tasks (Visual Parity, State Machine, Recall, and Finding Roots from the MathSearch benchmark) with controllable in-distribution vs. out-of-distribution task length/resolution splits. They propose FoveAgent-LSTM: an LSTM backbone that at each step ingests a high-resolution foveal glimpse and a 4x-larger, downsampled peripheral glimpse (each encoded by a ResNet), outputs a displacement action plus a stop bit, trained via imitation learning on 50k oracle trajectories. A Qwen-based variant (FoveAgent-Qwen) is built for the real-world Finding Roots task since no pretrained recurrent VLM backbone exists.

Key results:

• FoveAgent-LSTM maintains high accuracy across OOD switch counts (11–20) and resolutions on Visual Parity/State Machine, while finetuned Qwen2.5-VL-3B-Instruct degrades sharply as task complexity increases.
• Ablation on visual interface: Global and Local+Global variants (seeing the full high-res canvas) degrade OOD despite matching InD performance, while the foveated (local-only) setup retains high accuracy.
• Architecture ablation on fixed local inputs: only nonlinear recurrent networks length-generalize on State Machine; transformers, Mamba, and xLSTM do not, even with local-only visual input.
• On the real-world Finding Roots task, FoveAgent-Qwen reaches 82.26% InD accuracy vs. 57.24% for the global-only Qwen baseline, and 77.24% vs. 50.12% on OOD-subplots; at matched visual-compute budget, FoveAgent-Qwen achieves a +29.0% accuracy gain over the global baseline, whereas scaling the global baseline's resolution 10x yields only +3.8%.
• On the Recall (non-state-tracking) task, the global Qwen2.5-VL-3B-Instruct significantly outperforms FoveAgent-LSTM, showing locality specifically aids state tracking, not general visual retrieval.

Why it matters / caveats: Argues recurrence and local (foveated) perception are each necessary and jointly sufficient for OOD length generalization in visual state-tracking reasoning, suggesting current global-vision-front-end VLMs may be fundamentally limited on such tasks. A stated limitation is that local perception policies are trained via imitation learning from ground-truth oracle policies, which is straightforward only for synthetic tasks; learning such policies more broadly is left as open work.