AI papers — 2026-09-22

Problem: Iterative LLM-driven evolution of agent harnesses (prompts, control flow, tools, memory, context management) tends to overfit to the finite "evolve set" it is scored on, producing gains that shrink or vanish on out-of-distribution benchmarks.

Method: RRSI regularizes both sides of the harness-evolution loop while keeping the full harness edit space open. On the proposal side: an L0-style annealed update-sparsity budget (cosine schedule from b_max to b_min over T rounds) limits how many independently attributable edits a candidate can bundle per round; evidence-aware credit assignment conditions the proposer on the full history of accepted/rejected edits; and structured exploration redirects search to underexplored components when progress stalls. On the selection side: a leakage-screening critic rejects benchmark-specific/task-specific edits before evaluation; a noise-adjusted performance floor (stability-aware acceptance) rejects gains within the empirical noise band; Ridge/L2-style complexity-aware acceptance requires cost increases to be justified by measured score gains (Δcost ≤ β0 + β1·Δscore); and Lasso/L1-style structural pruning removes harness components with no recent positive contribution. Evaluated with Claude Opus 4.8 (and cross-checked with Gemini 3.5 Flash / 3.1 Flash Lite) as frozen backbone across coding (Terminal-Bench 2.1, SWE-bench Verified), agentic workspace (Harvey LAB, JobBench, GDPval, APEX-Agents), and engineering design (EngDesign, Frontier-Eng) domains, against baselines Meta-Harness, AHE, TTHE, HarnessX.

Key results:

• Gains up to 14.1 points on the evolve split and up to 4.7 points (7.2–13.1%) on five OOD benchmarks; no held-out split regresses.
• On agentic workspace tasks, RRSI's OOD average (43.6) beats H0 (39.7) by >1 point, while baselines like TTHE finish 1.7 points below H0 OOD; RRSI's evolve-set gain (90.5) is the smallest of any evolved harness (deliberate trade-off).
• Uses 30% fewer policy tokens than unregularized evolution (2.42M vs 3.80M tokens/trial); AHE spends 3.82M tokens/trial for 4.4 points less OOD performance.
• Ablation: removing acceptance-side regularizers raises evolve score (90.5→91.5) but drops OOD avg (43.6→41.0) and raises cost 1.5x; removing both regularizer groups yields the highest evolve score (92.8) but OOD avg falls to within 1 point of H0, at 3.80M tokens/trial.
• Cross-model transfer: harness evolved with Gemini 3.5 Flash improves Terminal-Bench 2.1 for a smaller unseen model (Gemini 3.1 Flash Lite) from 11.2 to 14.6 (+30.4% relative), showing mechanisms transfer across backbones.

Why it matters / caveats: Demonstrates that recursive self-improvement of agent systems needs explicit regularization of both what changes and how feedback becomes permanent state, not just an open edit space. Limitations: relies on a finite evolve set and several regularization hyperparameters, and the study keeps model weights frozen, not addressing joint weight+harness self-improvement.

Problem: Interactive video world models struggle to remain consistent with prior observations over long horizons and across viewpoints when users revisit previously seen locations or subjects.

Method: WorldCrafter is a camera-controllable autoregressive video diffusion model (DiT, initialized from Helios-base) augmented with a learned "implicit 3D-aware memory": a memory encoder (initialized from the LagerNVS multi-view encoder, replacing its shallow DINO layers with a latent patch-embedding layer) writes a fixed number of complementary history latent frames (selected via max-coverage history retrieval based on joint field-of-view coverage of the target trajectory) into a compact 3D-aware representation. A pose-guided memory readout module (initialized from LagerNVS's shallow decoder) then queries this representation using the upcoming camera trajectory to produce a fixed-size set of memory tokens, which condition the DiT jointly with recent temporal context via self-attention (no explicit depth-based correspondences or target-view reconstruction). Camera conditioning uses UCPE-style parallel camera-attention branches with PRoPE-style relative pose encoding. The memory encoder, readout module, and DiT are jointly trained in stages on OpenSora-Plan, DL3DV, and synthetic MIND videos; a distilled variant (WorldCrafter-fast) uses pyramid coarse-to-fine distribution matching distillation (à la Helios) for 16 fps real-time streaming inference on a 4-GPU machine.

Key results:

• On a curated 145-image/725-video benchmark, WorldCrafter reduces LPIPS from 0.487 (best baseline, Lyra 2.0) to 0.255 and raises PSNR from 14.050 to 18.016 dB for long-horizon revisit consistency; WorldCrafter-fast is best overall (LPIPS 0.186, PSNR 20.868).
• Achieves lowest camera-control error on all 3 metrics (RotErr, TransErr, CamMC), e.g., RotErr 13.536 vs. 16.145 for the next-best baseline (Lyra 2.0).
• VBench overall visual-quality score of 81.910, best among 8 evaluated baselines (5 of 8 sub-dimensions best).
• Ablations: replacing implicit memory with raw context-memory frames degrades consistency and camera control; joint (vs. frozen) memory-encoder training and pose-guided (vs. pose-free) readout each improve results; max-coverage history retrieval outperforms similarity-based retrieval.
• Memory processing is 21.7x faster than depth-based spatial memory approaches (0.062s vs 1.346s per chunk for encoding+readout vs. depth estimation+warping).

Why it matters / caveats: Shows that adapting pretrained multi-view/novel-view reconstruction representations (rather than geometry-estimation-only features) into a compact, pose-queryable memory improves both appearance fidelity and efficiency for interactive world models. Authors note consistency can still break down on very complex/extended trajectories, and re-encoding history at every chunk adds latency; they suggest an incremental streaming memory encoder as future work.

Problem: Standard approaches adapt VLMs to robot control via large-scale robot-action training data, which is costly, embodiment-specific, hard to scale, and reportedly degrades the VLM's general-purpose reasoning/instruction-following capabilities.

Method: RoboDawn is a human-intuitive interface that exposes robot control to a frozen, agentic VLM as a compact set of discrete, semantically interpretable commands (arm move/rotate/point/gripper/home/wait/done, defined relative to the "gripper interaction point," with translation/rotation clipped to 20cm/90° per command) rather than continuous low-level actions. The VLM operates in closed loop, observing multi-view images and robot state, reasoning, issuing commands, and updating a scratchpad/memory from execution feedback (Eq. 1: y_t, a_t = π_θ(L, E, D; I_t, x_t, F_{t-1}, M_t)). An in-context learning (ICL) scheme grounds both interface semantics and task strategy using a shared command primer (D_prim, illustrating primitive effects) plus 0/1/few task-level demonstrations (D_task) converted from raw expert trajectories into the semantic command space, with rationale text and sparsified images for long-horizon demos. No parameter updates or task-specific robot training are performed.

Key results:

• On RoboTwin 2.0 C2R (50 bimanual tasks, domain-randomized eval), RoboDawn with GPT-6 Astra achieves 53.2% zero-shot (vs. π0.5 46.0%, LingBot-VLA 50.4%, both trained on full 50-task demo sets) and 73.6% one-shot, exceeding HarnessVLA (Claude Code) full-set-trained baseline (58.4%) by 15.2 points.
• On RoboDojo (42 tasks), success rate rises from 35.67% zero-shot to 47.17% one-shot, versus full-set post-trained DM0.5 at 19.34%.
• Ablations: performance scales with base VLM (GPT-5.6-Luna 14.4% → GPT-6 Astra 73.6% one-shot); removing reasoning drops zero-shot success 47.0%→34.8%; removing grid-based localization drops it to 32.4%; removing the command primer drops it to 44.0%; demo count has diminishing/slightly negative returns beyond 4 shots (65.4% at 4-shot, 62.7% at 8-shot).
• Test-time scaling on RoboDojo: one-shot success rises from 31.2% (60 commands) to 47.2% (240 commands).
• Real-world Franka deployment (zero-shot): 9/10 block-in-basket, 5/10 block stacking; cloth folding on Piper failed (0/10), attributed to under-represented rotational/orientation motions in web-scale pretraining.

Why it matters / caveats: Suggests intelligence transfer from digital-world VLM pretraining to physical robot control is achievable via interface design and few-shot ICL rather than large-scale robot-action training, but the paper notes limitations in inference speed (slower than end-to-end VLA/WAM policies), weaker handling of precise rotations, and limited fine-grained/high-precision manipulation, plus deployment safety concerns.

Problem: Existing gameplay datasets/benchmarks cover a narrow range of (often non-AAA or single) games, lack dense multi-horizon language instructions, and rely on high-variance, low-sample online rollouts that are hard to reproduce and conflate distinct failure modes.

Method: GameHorizon Suite has three parts. (1) GameHorizon-Annotator: an automated, bottom-up pipeline that performs action-aware video segmentation (using keyboard-mouse traces, refined by a VLM) into short clips, then progressively merges clips (via VLM judgments of action/goal continuity plus a dynamic-programming step enforcing per-level duration ranges) into a 3-level instruction pyramid: short-horizon operations (L1, 1–5s), medium-horizon goals (L2, 1–2min), and long-horizon strategies (L3, 5–8min). (2) GameHorizon-Data: 5,000 hours of gameplay from 100 human expert players across 21 AAA titles, with synchronized 2K video and keyboard-mouse actions (411.03M action events), annotated with 6,184,036 instructions (5,947,588 L1, 189,158 L2, 47,290 L3). (3) GameHorizon-Bench: a reproducible offline track of standardized multiple-choice questions across three primary tasks — T1 single-horizon action, T2 multi-horizon instruction decomposition, T3 cross-horizon consistency — plus 10 diagnostic variant tasks (5,000 MCQs total), and a stepwise online track (10 causal + 10 thematic tasks, 62 verifiable Minecraft subtasks with environment reset on failure) to localize failures in long-horizon play.

Key results:

• Evaluated 47 models (35 general VLMs, 4 UMMs, 2 GUI agents, 3 coding agents, 3 dedicated game agents) over 1M+ model invocations/API calls.
• Mean offline accuracy across 44 QA-capable models is 64.7% (vs. 25% random), ranging 44.6%–80.2%; task difficulty hierarchy: T1 57.3% (hardest), T2 65.1%, T3 71.6% (easiest).
• GPT-6-Astra ranks first overall (80.2%), followed by Gemini 3.8 Flash (77.3%) and Gemini 3.7 Flash (76.7%); Kimi-K3 is the top open-weight model (74.5%, rank 6).
• Dedicated game agents (trained specifically for action control) score much lower on T1 than general VLMs in a zero-shot cross-domain setting, e.g., NitroGen 22.0%, Open-P2P 24.4%, JARVIS-VLA 28.1% on GameHorizon vs. Gemma-4-31B-IT reference 54.1%; JARVIS-VLA in-domain (its native VPT/Minecraft benchmark) scores 54.2%, similar to zero-shot Gemma.
• UMMs and GUI agents mostly fall into lower performance tiers (e.g., UI-TARS-1.5-7B underperforms its own general VLM backbone Qwen2.5-VL-7B-Instruct by 3.7 points), and "thinking" mode helps stronger models (Doubao-Seed-2.1-Pro +9.3 points) but hurts lightweight ones (UI-TARS-1.5-7B −8.2, Qwen2.5-VL-7B −5.9).
• Providing medium/long-horizon instructions (vs. vision-only input) improves future-action planning by 7.2 percentage points.

Why it matters / caveats: Provides the first large-scale, AAA-focused, densely multi-horizon-annotated gameplay dataset with a reproducible offline benchmark plus stepwise online failure localization, addressing reproducibility and scale gaps in prior single-game/low-rollout gameplay benchmarks; the paper reports a positive offline-online score association, supporting offline accuracy as a valid capability proxy, though the stepwise online track itself is implemented only in Minecraft due to limited access to underlying game state in most AAA titles.

Problem: Enterprise RAG pipelines must ingest heterogeneous, layout-heavy document formats (PDFs, DOCX, PPTX, scans) whose structure (reading order, tables, heading hierarchy) is destroyed by rule-based text extraction, while fully agentic LLM chunking that repairs and regenerates the text is accurate but slow, expensive, and hallucination-prone.

Method: D-RAC extends the authors' prior Web Retrieval-Aware Chunking (W-RAC) framework to arbitrary document formats via a 4-stage pipeline: (1) deterministic normalization of any input format into PDF and rendering pages to PNG at 200 DPI (capped at 1,568 px); (2) a single multimodal LLM pass (Gemma-3 27B/12B via AWS Bedrock, 5-page batches, 5 parallel workers) that converts pages into retrieval-optimized Markdown, rewriting every table row as a self-contained prose sentence (never merging rows into disjunctive statements), suppressing decorative images, and reconstructing explicit heading hierarchy; (3) deterministic parsing of the Markdown into ID-addressable elements (headers/content blocks) with recursive header-boundary sectioning for documents exceeding a 60-element planning budget, carrying parent-header context; (4) LLM chunk planning that emits only ordered ID arrays (never regenerated text), with programmatic coverage verification and fallback grouping for lossless ingestion.

Key results:

• Converted and chunked the full 236-document, 795-page PDF subset of RAG-Multi-Corpus in ~72 minutes wall-clock with zero conversion or chunking errors, producing 1,748 chunks.
• Reduced chunking-stage output tokens by 95.7% (270,454 → 11,714 tokens) versus agentic chunking with frontier LLMs.
• Cut chunking cost by 77.8% under GPT-4.1 pricing ($2.815 → $0.624) and 85.6% under Gemini 2.5 Pro pricing ($3.112 → $0.448) for the full corpus; reduced chunking time by 75% (2,167.5s → 541.8s).
• On 762-query retrieval evaluation, D-RAC matched/exceeded agentic chunking on all 7 metrics (Recall@6 0.798 vs. 0.795, MRR 0.690 vs. 0.682) and beat fixed-size/rule-based extraction baseline (Recall@6 0.717→0.798, +11.3% relative; MRR 0.602→0.690, +14.6%).
• Scales linearly to 500+ page documents: a 503-page stress-test document converted in 21.6 min (27B model) / 13.4 min (12B) and planned its 5,060 elements in 68.7s.

Why it matters / caveats: Because the expensive multimodal conversion is a one-time, per-document cost and re-chunking only requires cheap ID-level re-planning, retrieval-strategy iteration (chunk size, entity-aware grouping, per-tenant policies) becomes near-free after initial ingestion. Caveat: evaluation is on a benchmark of fictional enterprise organizations and uses the authors' own W-RAC-derived benchmark and prior agentic-chunking baseline; boolean queries were the one category where agentic chunking retained an edge.

Problem: Existing educational LLMs typically specialize narrowly in either subject problem-solving or tutoring dialogue, and their training data is organized by source/subject rather than by the distinct capabilities (curriculum grounding, error diagnosis, pedagogical action) that an effective K-12 learning-and-teaching assistant actually needs.

Method: The authors fine-tune Qwen3.5-4B-Base, Qwen3.5-9B-Base, and Qwen3.8-27B on a capability-oriented instruction corpus organized around four categories — subject competence, curriculum grounding, diagnostic reasoning, and pedagogical action/scaffolding. A six-stage pipeline (capability taxonomy/source collection → deterministic cleaning and decontamination → LLM-assisted semantic auditing/rewriting via Qwen3.5-122B-A10B-FP8 with a 0-100 keep/rewrite/remove scoring → preliminary k-center-greedy diversity selection plus GPT-5.6-Terra fine-grained 1-5 scoring → token-budgeted k-center-greedy diversity selection per task bucket → pedagogical instruction assignment using 20 system-instruction templates) reduces ~1.34M raw examples to 60,951 education-specific examples (~12.0M supervised response tokens), combined with 9,048 general-purpose examples for a final 69,999-example, 15.96M-token corpus. Training uses LlamaFactory, LR 5e-6, max sequence length 32,768, 3 epochs.

Key results:

• OmniEdu-27B: 63.12% EM / 76.69% F1 on K12-Bench (up from base 52.11%/73.48%), 85.89% accuracy on MathFish, 86.95% MaC on EDUMATH.
• On GAOKAO-Bench, OmniEdu-27B improves full-score rate from 91.55% to 94.87%; on MDK12-Bench, overall score rises from 46.04% to 57.76%; on EXAMS-V, OmniEdu-4B rises from 44.69% to 57.62%.
• MathTutorBench Scaffold win rate for OmniEdu-27B reaches 78.74% (base 57.16%), with the smaller models showing even larger jumps (OmniEdu-4B: 20.42%→75.79%, OmniEdu-9B: 14.00%→75.26%).
• Best Teaching average of 3.02 on LongTutor among all evaluated models (open and proprietary), with LongTutor Evidence average rising from 36.80% to 78.20% for the 27B model.
• General-capability retention: MMMU-Pro accuracy improves for all scales (e.g., 27B: 64.97%→67.98%) and IFEval/GPQA generally improve, indicating specialization doesn't broadly degrade general ability.

Why it matters / caveats: Demonstrates that capability-balanced, quality-filtered instruction data (rather than raw scale) can turn general LLMs into strong open educational systems that beat existing open-weight educational baselines (EduChat, MuduoLLM, Confucius3-Math) and remain competitive with much larger proprietary models like GPT-5.6-Sol and Claude-Opus-5 on several benchmarks. Caveat: some proprietary models (e.g., Kimi-K3, Claude-Opus-5) still outperform OmniEdu-27B on individual benchmarks (e.g., EDUMATH, TutorBench, LongTutor-Evidence), and knowledge-state diagnosis accuracy remains low (~54%) even for the best model.

Problem: State-of-the-art video generation models produce high visual fidelity but often fail to satisfy prompts requiring specialized/procedural knowledge, specific entity identities, physical consistency, or correctly ordered multi-shot events.

Method: VideoGen-Agent is a multimodal agent (built on Qwen3-VL-8B-Instruct) trained via multitask agentic reinforcement learning to orchestrate augmentation (text/image retrieval, physics simulation), generation (T2V/I2V/R2V/M2V), and verification (object detection, depth estimation) tools through a multi-turn reasoning-action-observation loop, across six task categories: Procedural Knowledge, Single-Entity Identity, Multi-Entity Identity, Physics Simulation, Compositional Scene, and Multi-Shot. Training is two-stage: SFT on 16K teacher-distilled tool-use trajectories (AdamW, lr 5e-5, 2 epochs), followed by GRPO-based RL on 8K prompts (n=6 rollouts/prompt, ε_lo=0.2, ε_hi=0.28, β_KL=1e-3) using a category-aware hybrid reward combining tool-call validity, task-appropriate tool use, and a VLM-judged (Gemini 3.1 Pro) video-quality score, with only agent-generated tokens (not tool outputs) contributing to the RL objective.

Key results:

• On VABench (a new 600-prompt, 6-category held-out benchmark), VideoGen-Agent with Toolset 1 scores 75.6 overall, a 19.1-point improvement over its base T2V generator Seedance 1.0 (56.5), and 2.4 points above the strongest standalone baseline, Seedance 2.0 (73.2).
• Simply swapping in upgraded generation tools (Toolset 2), with no additional agent training, raises the overall score to 86.1, achieving the top score in all six categories (e.g., Multi-Entity Identity jumps from 65.3 to 86.7).
• Human raters preferred VideoGen-Agent-Toolset 2 over Seedance 2.0 in 84.3% of 100 side-by-side comparisons.
• Ablations: prompt rewriting alone raises the score only to 57.3 and zero-shot tool use to 59.5 (from 56.5 baseline); SFT raises it to 69.2; full RL adds another 6.4 points to 75.6. Removing the VLM reward drops the score to 73.3, removing the tool-use reward drops it to 71.2; a single-task RL variant scores 76.3, essentially matching the multitask agent (75.6) while requiring six separate policies.

Why it matters / caveats: Shows that a single trained agent policy generalizes tool-use strategies across heterogeneous video-generation tasks and that its learned coordination benefits transfer automatically when generation backends are upgraded, without retraining. Caveats: evaluation quality metric relies primarily on an LLM judge (Gemini 3.1 Pro) using the same rubric as the training reward, which could bias results in the agent's favor; the framework's ceiling is bounded by the quality/latency of its component tools per the authors' own limitations discussion.

Problem: Existing LLM alignment data annotation approaches force a tradeoff between cost, on-policy fidelity, and supervision granularity — manual writing/post-editing is costly and produces off-policy data, preference ranking over pre-sampled candidates is cheap but only gives coarse response-level signal and fails when the model cannot sample a good response at all, and agent-trajectory annotation additionally requires executing corrected tool calls against real environments.

Method: onPanda implements a "locate-correct-continue" interaction: while reading a streamed model response with per-token logprobs displayed via color-coded confidence, the annotator finds the first inappropriate token, either selects from the model's top-k (default 20) candidate tokens or free-form edits it, after which the system truncates everything after that point and requests native continuation (e.g., vLLM's continue_final_message) from the corrected prefix — repeating until the response passes a quality bar. Each correction forks a new node in an annotation tree (stored in a single .panda.json file), automatically yielding SFT samples (is_good=Y nodes), preference pairs (positive/negative node pairs sharing a prefix), and precise token-level correction triples (rejected token, chosen token, position). A response-template mechanism converts structured agent messages (reasoning, content, tool_calls) bidirectionally to/from raw token streams so corrections cover reasoning chains and tool-call arguments, with external tools connected via an MCP-based harness_to_mcp adapter (supporting harnesses like Claude Code, Codex, OpenClaw).

Key results:

• In a controlled study (3 annotators, 21 prompts, Latin-square design), onPanda's median annotation time was 330s vs. 681s for POTATO (post-editing, -51.5%) and 336s for Argilla (preference ranking); onPanda achieved a 66.7% pairwise win rate (GPT-5.5 judged) and lowest NASA-TLX workload score (3.1 vs. 5.4 Argilla, 6.8 POTATO).
• onPanda's response PPL under the rollout model was 1.181 (+0.86% vs. resampling baseline 1.171), close to Argilla's 1.161 (-0.83%), while POTATO's manual post-editing yielded PPL 1.596 (+36.31%), indicating far worse on-policy fidelity for post-editing.
• onPanda achieved 100% SFT coverage (like POTATO) vs. Argilla's 52% (11/21 prompts), and yielded 7.43 preference pairs per prompt vs. 6.00 (Argilla) and 0.95 (POTATO).
• In production deployment, onPanda generated ~388K token-level corrections across 25,596 vision, 105,143 audio, and 1,257 agentic annotation sessions; 97.0% of tokens in qualified responses were model-generated, only 0.9% manually typed.
• On the released Panda-CVL benchmark (token-level correction task), the best evaluated model (GPT-5.5) reached only 53.37% GoodAcc and 17.09% F1, showing current LLMs struggle at reliably performing token-level self-correction themselves.

Why it matters / caveats: Provides a practical, lower-cost way to generate genuinely on-policy SFT/preference/process-reward data at scale, and the token-level correction signal is proposed as a new supervision primitive for future post-training methods (a "correcting model," token-level DPO). Caveats: the controlled efficiency study is small-scale (3 annotators, 21 prompts, one rollout model), quality judgments rely mainly on LLM-as-judge, no controlled agent-trajectory study was run, and the paper does not verify the downstream training benefit of token-level correction data via actual training experiments; the method also requires inference APIs that expose prefix continuation and top-k logprobs, which many proprietary APIs do not support.

Problem: Pretrained backbones used in current robot foundation models (language backbones in VLAs, video-generation backbones in world-action models) do not require explicit metric 3D grounding of task-relevant objects, so manipulation policies built on them learn spatial precision only implicitly and indirectly from demonstrations, making them fragile to scene randomization and object relocation.

Method: The paper introduces the Grounded Action Model (GAM), which conditions a policy on a frozen, promptable 3D grounding backbone (WildDet3D) that turns language, 2D point, or 2D box prompts into per-object 2D/3D boxes and a dense metric depth map. From these detections GAM builds an object-centric observation with two streams: image tokens (a 16x16 grid masked to keep only cells overlapping detected task objects or the robot-arm silhouette) and detection tokens (per-object point clouds encoded via a shared point MLP with octant/max/mean pooling, plus box center/extent/rotation). These streams, plus a robot state-history token, are fused and fed to a 12-block multi-stream transformer (MM-DiT) trained with flow matching to predict chunks of absolute joint-position targets; only the action head is trained, the grounding backbone stays frozen.

Key results:

• RoboTwin 2.0 (50 tasks, single-task training on clean-scene demos only): GAM reaches 55.3% average success (Easy 63.0%, Hard 47.6%) vs. 52.0% average for the best baseline (Spatial Forcing) and 30.4% Hard-setting success for the next-best (Abot-M0).
• LIBERO-PRO (16 perturbation settings): GAM achieves 0.61 average success vs. 0.53 for π0.5, with especially large gains on target-relocation (Pos) and new-target (Task) settings (e.g., 0.88 vs. ≤0.11 for baselines on Spatial-Task).
• Bimanual YAM real robot: GAM retains 17/20 successes under visual shift (89% retention) vs. 4/20 for π0.5 (21% retention), both at 19/20 in-distribution.
• Franka with a Molmo2 planner: 64.7% in-distribution and 49.8% out-of-distribution step completion on long-horizon/memory tasks, vs. 42.4%/24.0% for π0.5 and 35.3%/17.1% for MolmoAct2.
• Ablations on 10 RoboTwin tasks: removing image masking and point cropping drops average success from 46.8% to 10.3%; using only detection or only image tokens gives 16.0%/20.3% vs. 46.8% for the combined model.

Why it matters / caveats: The results support 3D grounding (rather than language or video pretraining) as a stronger foundation for building manipulation policies robust to scene variation, but the approach depends on grounding quality — errors propagate to actions without recovery, and object-centric filtering can drop relevant unselected obstacles.

Problem: Pooled reinforcement learning on repository-level software engineering (SWE) tasks produces a "category see-saw," where gains on some task categories coincide with regressions on others, hidden behind a stable aggregate resolution score.

Method: The authors build SWE Labeler, an evidence-grounded hierarchical taxonomy (26 Task Type L1/119 L2 labels, 21 Repository Domain L1/108 L2 labels, plus 3 scale axes) that deterministically routes tasks into three categories (Pro-A: service/data/security, Pro-B: user-facing, Pro-C: systems/tooling/runtimes). Category-specific experts are trained from the same base model using Agentic-miniRL (a MiniRL-based multi-turn RL recipe combining RLOO advantage estimation, K1 reward-path KL regularization, behavior-corrected/proximal token importance weighting, and turn-aware loss reduction), alternated in a Refresh–Repair–Expand (RRE) loop: each round refreshes instance-level mastery estimates, reuses the policy's own verified successful trajectories for Repair SFT, then expands the training pool with previously unseen instances. The three experts are then consolidated into one deployable student via label-routed multi-teacher on-policy distillation (MOPD) with ReLU-gated reward extrapolation, using no external teacher trajectories.

Key results:

• On Pro-618 (SWE-bench Pro subset, 221/201/196 tasks per category): Pooled RL gains 2.86 pp Full resolution over base (52.64%→55.50%), Balanced RL gains 2.70 pp (55.34%); both show uneven category gains (SSG of 1.05 and 1.18 pp respectively during training).
• Final MOPD policy achieves 58.04% mean resolution on Pro-618, a 5.39 pp gain over base — exceeding Pooled RL by 2.54 pp and Balanced RL by 2.70 pp, with gains in every category (minimum category lift of 1.53 pp over Pooled RL and 2.04 pp over Balanced RL).
• MOPD retains 80.8%, 111.1%, and 84.8% of the corresponding individual experts' gains on categories A, B, and C respectively (on B it exceeds its own expert by 0.50 pp).
• On SWE-bench Multilingual (300 tasks, evaluated with SWE-agent): MOPD reaches 59.00% mean resolution vs. 56.22% base (+2.78 pp), and outperforms Pooled RL (55.56%) and Balanced RL (57.00%) overall and in all three routed categories.

Why it matters / caveats: Category-aware expert training plus distillation produces a single deployable model with both higher aggregate and higher per-category (Pareto-improving) resolution than pooled or balanced joint RL, without needing an external trajectory teacher; however, expert-gain recovery during integration is uneven across categories (lowest on Pro-A), and the reported SSG for MOPD is not zero, meaning some residual imbalance remains.

Problem: Optimized agent harnesses (external scaffolding for tool use, context management, and control flow) substantially boost LLM agent performance, but those gains are tied to the specific harness used at deployment, forcing a general-purpose agent to either accept a suboptimal shared harness or maintain and route among many specialized ones.

Method: Harness-Zero performs "agent harness distillation": it evolves a domain-specific student-side harness h⋆ via a skill-guided, three-round meta-harness evolution loop, then adapts it into a private "reference harness" K for a separate harnessing agent (agent-as-harness). During trajectory collection, the student proposes each response under the fixed minimal target harness h (a mini-SWE-agent-style single-Bash-tool harness); the harnessing agent reviews the proposal using K and either passes it or replaces it with the smallest coherent correction expressed in h's action space, without access to hidden solutions or the student's sandbox. SFT is then applied to these harness-guided trajectories (masking any leaked reviewer-perspective reasoning) to internalize the behavior into model weights (Qwen3.5-9B via LoRA), so h⋆, K, and the harnessing agent can all be removed at deployment.

Key results:

• Agent-as-harness (with adapted K) outperforms code-as-harness (mounting h⋆ directly) at inference time on frontier models: 81.1% average vs. 78.1% (meta-harness) and 68.6% (bare target harness) across six benchmark-model settings on SpreadsheetBench Verified, AppWorld, and USPTO Retrosynthesis.
• After distillation, the student under h alone raises macro-average task success from 23.3% to 44.3% (a 21.0 pp / 90.1% relative gain), exceeding the 41.7% achieved by the undistilled base model with h⋆ still attached.
• Ablation on USPTO: direct SFT on teacher (GPT-5.6 Sol) trajectories leaves the student at 12.0% pass@1 despite 52.0% collection success; review with an empty reference harness reaches 11%; review with oracle answers reaches 98.6% collection success but only 15% pass@1; Harness-Zero's harness-guided review reaches only 59.4% collection success but 30% pass@1.
• The distilled model recovers 82.3% of 28 mined harness-exclusive behavioral patterns (spanning memory, skill, tool, and middleware sources) across the three domains that the base model never exhibits under the plain target harness.

Why it matters / caveats: The results suggest procedural/behavioral harness gains (state inspection, verification steps) transfer well into weights, while deep domain knowledge (e.g., USPTO reaction priors) is harder to fully internalize via SFT alone; the method also depends on having a sufficiently capable harnessing model, and review adds ~2.4x latency during data collection (though not at deployment).

Problem: Existing LLM persona/role-playing methods rely on shallow, flat character descriptions that fail to sustain coherent, psychologically believable behavior across extended interactions, and existing evaluation methods rely on general linguistic metrics rather than measuring psychological realism.

Method: Deep Persona is a three-layer persona architecture — External (conscious, observable behavior/tone), Middle (pre-conscious beliefs/triggers revealed conditionally), and Internal (unconscious core motivations/drives, never verbalized directly) — built via a structured expert interview and encoded into a prompt with modules for narrative background, interaction-structure/staging, the three-layer rules, a control-and-logic module enforcing hard constraints against character breaks, and an optional embodied-expression module for nonverbal cues; the design follows two stated principles, "scripted determinism" (behavior not explicitly scripted degrades via stochastic drift) and "bounded agency" (restricting the agent to reactive rather than proactive/open-ended roles). The paper also proposes a reference-free evaluation framework adapted from the ADOS clinical instrument, computing pragmatic fluidity/echolalia, joint attention, affective congruence, and emotional expression diversity metrics, combined into a Dialogue Naturalness Score (DNS) via Mahalanobis distance to human dialogue baselines (with chi-squared hypothesis testing), plus an adversarial "stress test" (hallucination trap, out-of-role requests, ethical stressors).

Key results:

• Across human-LLM datasets, pragmatic fluency is high (0.88–0.97) but joint attention varies widely (0.46 for ABC-Eval vs. 0.78–0.93 for Role-Play/CounselChat), and emotional expression diversity is systematically low in open-domain datasets vs. elevated (possibly over-amplified) in CounselChat.
• Two case-study Deep Personas (Sarah, 49 turns; Evelyn, avg. 13 turns, implemented on Gemini 2.5 Pro) achieve DNS scores under a combined human baseline of 0.9177 and 0.8503 respectively, and are statistically indistinguishable from human dialogue (p > 0.05) across all evaluated dialogues, exceeding the DNS of all evaluated human-LLM comparison datasets under the same baseline.
• Embodied expression module produced nonverbal cues in 84% of Sarah's turns (41/49) with affective congruence score 0.52, and in 100% of Evelyn's turns with congruence 0.35.
• In stress tests, both personas maintained character under hallucination-trap and ethical-stressor attacks (e.g., Evelyn responded with in-character sardonic defiance rather than a generic safety disclaimer to a sarcastic threat).

Why it matters / caveats: The case study is a limited proof-of-concept (single-session Sarah interaction with one clinician; Evelyn interactions run by the persona's own developer, not naive users; no flat-prompt baseline for direct architectural comparison), so the strong DNS results are suggestive rather than a controlled demonstration of the architecture's causal contribution; several metrics also depend on emotion classifiers/lexicons that may not generalize across languages and domains.

Problem: Vision-Language-Action (VLA) policies for robotic manipulation are brittle once execution deviates from nominal trajectories (e.g., slipping, tipping, misaligned grasps), because they are trained mostly on successful expert demonstrations from nominal initial states and lack grounded recovery behavior.

Method: CARE (Corrective Atomic Robotic Execution) has two parts. (1) Experience-Guided Corrective Data Synthesis: it collects failed rollouts, fits stage-conditioned deviation distributions p(d|k) (translational Δτ and yaw Δr) per atomic stage using AIC/KS-test model selection over Gaussian/Beta/Gamma/Weibull/Log-Normal/Uniform candidates, samples from these distributions to synthesize new failure states, and collects corrective demonstrations (IK/motion-planning oracle in sim, teleoperation in the real world). (2) Atomic Corrective Execution: a GPT-4.1 VLM planner decomposes tasks into atomic stages with nominal/adjustment/re-operation instructions, and a 3D geometric monitor (SAM 3 + Depth Anything 3 point clouds) checks stage-critical geometric predicates to trigger intra-execution adjustment or post-execution re-operation, executed by the same VLA policy (instantiated on π0 and π0-FAST). The authors also introduce FSR-Bench, a benchmark that starts episodes from intermediate failure states (36 scenarios, Easy/Hard regimes) rather than nominal initial states.

Key results:

• Average task-success gain of 14.5 points in simulation and 15.9 points in the real world across backbones/benchmarks.
• On RoboTwin 2.0 hard bimanual tasks: π0 improves from 39.6% to 60.7% (+21.1 pts); π0-FAST from 17.4% to 33.1% (+15.7 pts).
• On RoboFactory multi-arm tasks: average gains of +12.0 pts (π0) and +9.3 pts (π0-FAST).
• On FSR-Bench, π0's average recovery success rises from 38.8% to 57.2% (Easy) and 15.8% to 21.2% (Hard); consistent gains also for RDT-1B and π0-FAST.
• Real-world SO-101 dual-arm tasks: π0 improves from 30.8% to 50.0% and π0-FAST from 18.8% to 31.3%, beating a reproduced FailSafe baseline by 13.7 and 7.3 points respectively.
• Ablations: corrective data alone contributes more than execution alone (e.g., +9.2 vs +4.2 pts on π0), and experience-guided sampling beats uniform-random sampling by 12.2 pts (π0) and 8.8 pts (π0-FAST). The learned 3D monitor beats a GPT-4.1 VLM monitor in accuracy (93.8% vs 71.4%) and is 14.1x faster (0.24s vs 3.40s per call).

Why it matters / caveats: Treating execution failures as structured supervision (rather than manual/random perturbations) yields consistent, backbone-agnostic gains in recovery without needing a separate recovery policy; however, results rely on a specific dual-arm platform (SO-101) and simulation benchmarks (RoboTwin 2.0, RoboFactory), and the authors note future work would add reinforcement learning for further improvement.

Problem: Existing agentic memory systems for long-horizon LLM agents rely on autoregressive LLMs to make frequent, high-frequency memory-control decisions (typing, relation judgment, query routing, candidate scoring, stopping), placing expensive generation on the critical path and creating latency/inference overhead.

Method: Jev-Mem is a System-One/System-Two architecture inspired by dual-process cognition. A dedicated "System-One" controller (built on "Jev," which produces typed probabilistic decisions without autoregressive generation) handles high-frequency structured decisions on both the write path (memory typing across episodic/semantic/procedural/preference scores, candidate discovery via vector+lexical+entity+temporal similarity, and semantic/temporal/causal/entity relation construction with threshold θrel) and the read path (query routing across relational views via activation threshold θact, budget allocation across active graphs proportional to pg(q)^γ, multi-hop depth prediction, anchor retrieval via reciprocal-rank fusion, iterative evidence-guided graph expansion with candidate scoring, and adaptive stopping based on evidence sufficiency/utility/contradiction thresholds). System Two (a full LLM) is invoked only for final answer synthesis over the retrieved evidence. Evaluated on LoCoMo against Full Context, A-MEM, MemoryOS, Nemori, and MAGMA baselines using gpt-4o-mini.

Key results:

• Jev-Mem achieves the highest overall LLM-as-a-Judge score of 0.777 on LoCoMo, an 11.0% relative improvement over the strongest baseline (MAGMA, 0.700).
• Best in 5 of 6 question categories: Multi-Hop 0.623 (vs. 0.569 best baseline), Open-Domain 0.610 (vs. 0.517), Adversarial 0.962 (vs. 0.742), Single-Hop 0.802 (best), matches best on Temporal (0.637 vs 0.650 best... actually ties/near-best).
• Memory construction time is 158s, a 6.6x speedup over the fastest competing system (Nemori, 1,044s); A-MEM and MemoryOS require over 3,000s.
• Average per-query latency of 0.93s, a 36.7% reduction versus the fastest memory baseline (MAGMA, 1.47s) and 46.6% lower than Full Context (1.74s); MemoryOS requires 32.68s per query.

Why it matters / caveats: Separating cheap, bounded-output "System One" decisions from expensive generative "System Two" reasoning improves both accuracy and efficiency simultaneously, rather than trading one for the other; results are reported on a single benchmark (LoCoMo) with one backbone LLM (gpt-4o-mini), so generalization to other tasks/models is not directly shown in the text provided.

Problem: State-of-the-art text-to-video diffusion models frequently generate physically implausible motion (e.g., objects floating, freezing mid-air), and the internal mechanism causing this failure was previously unexplored.

Method: The authors present an interpretability study of "motion planning" in Wan2.1-T2V-1.3B (a DiT-based flow-matching video diffusion model). They analyze cross-attention (video-latent-to-object-token) evolution across denoising steps using entropy and "support quality" metrics, and identify motion-planning-relevant attention heads via a causal attribution-patching metric plus zero-ablation, revealing that a small subset of heads with converging trajectory patterns drives motion planning. They then analyze self-attention and show Rotary Position Embedding (RoPE) causes excessive spatial attention decay ("spatial anchoring effect"), quantified via a "mutual consistency" metric between candidate object-position regions across frames, showing that early-stabilized (possibly implausible) regions can suppress more physically correct candidates in nearby frames. Based on this, they propose a lightweight fix: scaling RoPE's rotation frequency (via multiplicative factors λh, λw < 1.0 on height/width dimensions) during the first 5 denoising steps, applied either training-free or fine-tuned via LoRA with a custom timestep sampler emphasizing early denoising steps, using the WISA dataset (80K physics videos) for training.

Key results:

• On VideoPhy (343 test cases), base Wan2.1-T2V-1.3B: 53.64% Semantic Adherence (SA), 29.45% Physical Commonsense (PC) overall.
• Modified RoPE (training-based, LoRA) alone: 57.43% SA, 39.94% PC; combined with prompt refinement (PR): 86.30% SA, 58.89% PC — best among tested combinations.
• LoRA + modified RoPE + PR reaches 87.46% SA, 62.68% PC overall, outperforming LoRA alone (55.69%/35.57%) and VideoREPA (56.56%/37.90%).
• Gains are largest on the Solid-Solid subset (large-magnitude motions), the intended target of the method.
• Ablation: training a model at a fixed seed (42) with a given λh/w generalizes to improve trajectories generated from other random seeds; tuning only attention modules (not FFN) in LoRA gives better results, supporting that the failure originates in attention, not FFN.

Why it matters / caveats: The work locates a concrete architectural root cause (RoPE-induced spatial attention decay) for a widely-observed failure mode in video generation and shows a simple, lightweight fix works without external physics simulators or new architectures; validated mainly on Wan2.1-T2V-1.3B (with some validation on the 14B model mentioned but not detailed in the excerpt), and the training-free variant requires manual tuning of λh/w, motivating the LoRA fine-tuned version.

Problem: Real-robot interaction data for VLA pretraining is expensive to collect, while human videos are abundant but suffer from an embodiment gap (in both observations and actions) relative to target robots, and prior joint observation-action robotization work has mostly been task-matched rather than a scalable general pretraining data source.

Method: The authors build a three-stage robotization pipeline: (1) Human Video Annotation — estimate camera intrinsics (droidcalib/AnyCalib), detect and track hands (100DoH + BOT-SORT), estimate 3D hand pose (HAWOR/MANO), recover metric camera trajectory (masked DROID-SLAM + MoGe-2 + GeoCalib), and generate language instructions via VLM captioning (Qwen3.5) on chunked manipulation segments; (2) Action Conversion — retarget hand motion to robot joint trajectories via PyRoKi optimization (jointly solving chunk-level frame alignment and joint configurations, then full trajectory with temporal smoothness) for the ALLEX bimanual dexterous robot; (3) Visual Conversion — segment and inpaint human arms (SAM2 + Detectron2 + ProPainter) and overlay a rendered robot (Isaac Sim) using the retargeted joint trajectory and aligned camera. This produces the HuRo dataset (630K episodes, 142M frames, ~1,317 hours from Ego4D, EPIC-Kitchens, EgoDex, EgoVerse, Ego10K). A VLA policy based on GR00T-N1.6-3B architecture is pretrained on HuRo (flow-matching objective, EEF-based action head) then finetuned on real robot demonstrations.

Key results:

• Scaling HuRo pretraining data from 0% to 100% raises overall real-world completion from 51.5% to 80.3%, with ID completion 68.1%→88.4% and OOD (spatial/visual shift) completion 34.9%→72.2%.
• At full scale, the HuRo-pretrained model outperforms π0.5 (48.2 overall) and GR00T N1.6 (52.0 overall) reference models, reaching 80.3 overall.
• Visual robotization ablation: no-overlay variant (same actions, human-visual observations) reaches similar ID performance (89.4% vs 88.4%) but much lower OOD (55.7% vs 72.2%); it even underperforms the 10% PT overlay model under OOD (55.7% vs 59.5%).
• Action supervision ablation (Diverse Pick-and-Place task): visual-only pretraining gives modest gains over no pretraining, while visual+action pretraining reaches 61.1% ID and 50.0% OOD completion.
• Compared to an I2V+IDM (video-generation + inverse dynamics model) baseline at matched frame budgets, HuRo at 0.7M frames already outperforms I2V+IDM at 7.0M frames on both ID and OOD; I2V+IDM's OOD performance plateaus from 3.5M to 7.0M frames while HuRo keeps improving.
• Limitation noted: only 55.2% of retargeted trajectories in a 5-source audit had no detected non-grasp self-contact, meaning trajectories serve as pretraining supervision rather than directly executable demonstrations.

Why it matters / caveats: Demonstrates that heterogeneous, large-scale robotized human video (with both visual and action alignment) can substantially improve real-world VLA generalization and scales better than video-generation-based synthetic data approaches; the pipeline does not model occlusion between rendered robot and scene, lacks force/tactile signals, and does not model self-collision/contact physics during retargeting.

Problem: In sparse on-policy distillation (OPD), existing token-selection methods choose tokens by "usefulness" heuristics but ignore that the reverse-KL gradient at a token is estimated from a single sampled next token, which can be extremely noisy even at useful positions.

Method: The authors analyze the reverse-KL gradient of OPD in information geometry (Fisher metric) at a fixed prefix, deriving a signal/noise decomposition under an optimal variance-minimizing scalar baseline, and define the Information-Efficiency Ratio (IER) as this signal-to-noise ratio. Since exact IER requires full-vocabulary statistics, they approximate it on a top-K candidate set built from student and teacher logits plus the sampled token, then rank tokens by approximate IER and combine this ranking with existing usefulness scores (Prefix, Entropy, TIP, TA-OPD, CA-SoftOR) via soft-OR (IER-OR) and soft-AND (IER-AND) operators, while keeping the standard sampled-reverse-KL training objective.

Key results:

• On JustRL-Nemotron-1.5B→OpenMath-Nemotron-1.5B, IER alone at 0.1% token budget nearly matches full OPD on AIME26 (58.9 vs 59.9) and HMMT26 (34.1 vs 34.7), and exceeds full OPD on 3 of 4 benchmarks for JustRL-Qwen3-4B→Qwen3-1.7B.
• On medical reasoning (ClinAlign-4B→Qwen3-4B, HealthBench), IER at 0.1% budget (~1 token/trajectory) reaches 45.25 overall vs full OPD's 45.77, while Prefix alone gives essentially no improvement (38.30) at the same budget.
• TIP+IER-AND at 0.1% budget reaches HealthBench overall/hard of 46.08/19.61, close to full OPD's 45.77/19.77; Prefix+IER-OR raises HealthBench overall/hard from 38.30/8.68 to 44.98/19.49 at the same budget.
• Combining IER with usefulness scores at 1%-5% token budgets matches or outperforms full OPD (all tokens) across mathematical and medical reasoning settings; gains hold across strong-to-weak and big-to-small distillation, and in both thinking-on and thinking-off modes.
• Increasing token budget beyond 1-5% does not reliably improve, and sometimes degrades, performance.

Why it matters / caveats: The results suggest gradient-estimation reliability and token usefulness are complementary, largely independent axes for sparse distillation, enabling effective supervision with orders-of-magnitude fewer tokens. However, gains are selector- and setting-dependent (e.g., combinations with Entropy sometimes hurt), and both usefulness and IER scores remain approximations without guarantees.

Problem: World models produce more physically grounded, robust representations than standard Vision-Language-Action (VLA) policies because they are trained to predict future scene evolution, but rolling a world model forward at inference is too slow/costly (seconds per decision) for real-time robot control.

Method: The paper adds a single feature-alignment loss to ordinary VLA training: a frozen world model (Cosmos3-Nano, the Qwen3-VL-8B "understanding tower" of Cosmos 3, image-token hidden states at layer 24) is run once over training frames and cached; a two-layer MLP projector maps the student's mean-pooled per-view image-token features (from a QwenGR00T-style backbone: Qwen3-VL vision-language backbone + GR00T-style flow-matching action expert) to the teacher's feature width, and a stop-gradient cosine loss (λ=0.5) aligns student to cached teacher targets. No teacher is loaded during training, the projector is discarded afterward, and the deployed policy is architecturally identical (same latency/memory) to the undistilled baseline.

Key results:

• 0.8B distilled student reaches 97.9% average success on LIBERO (4 suites), 2.6 points above the identical undistilled student (95.3%), runs in 32ms/1.86GB on an RTX 5090 vs. π0.5's 65ms and DreamZero's 3s/45.9GB (OOM on a 32GB card).
• On RoboCasa-GR1 (24-task humanoid manipulation), the same 0.8B student improves from 48.2% to 50.5% success (a 2.3-point gain) at zero added inference cost, within 4.3 points of the 4B QwenGR00T (54.8%).
• Real robot: on AgileX Nero single-arm fruit pick-and-place, distilled 0.8B model reaches 93.3% (28/30), matching a 4B π-style policy (93.3%) and beating the undistilled 0.8B control (83.3%); on egg pick-and-place, distillation raises success from 46.7% (control) to 60.0%; on bimanual TRIP-Bag fruit handover, from 40.0% (control) to 46.7% (vs 53.3% for the 4B model).
• Ablations: gain holds across student scale (0.8B, 1B, 4B) and backbone family; alignment layer (final layer best, but within 4 points across depths); and teacher choice (Cosmos3-Nano +2.6, Fast-WAM +1.6, V-JEPA2-AC +1.2 points over undistilled control on LIBERO), indicating a general representational-prior effect rather than a fragile teacher-student pairing.

Why it matters / caveats: Demonstrates that world-model grounding can be inherited via offline feature-cache distillation without any inference-time cost, letting small VLA policies approach larger models' performance; gains are described by the authors as "modest but consistent," and the distilled model still trails state-of-the-art VLA/world-model policies overall.

Problem: Delta-rule linear RNNs (e.g., Kimi Delta Attention/KDA, Gated DeltaNet) use diagonal-plus-rank-one state transitions whose expressivity for state-tracking tasks (e.g., modular addition, permutation composition) is limited, and it is unclear what KDA's channel-wise gate (vs. GDN's scalar gate) actually buys in expressivity.

Method: The authors show analytically that KDA's transition A=(I−βkkᵀ)Diag(α) is symmetric (hence real-spectrum) when the gate is scalar, but a channel-wise gate can break this symmetry; they extend KDA's gate range to α∈[−1,1] (following Sarrof et al.) and the delta-rule coefficient to β∈[0,2] (following Grazzi et al.), calling the combination Complex KDA (CKDA), which lets the diagonal gate supply a coordinate reflection that composes with the Householder reflection into a genuine 2D rotation while remaining non-expansive and diagonal-plus-rank-one. They prove CKDA can represent every orthogonal diagonal-plus-rank-one matrix (Theorem 1), characterize its spectrum (at most one complex-conjugate eigenvalue pair per transition), and derive state-tracking bounds (one CKDA layer tracks any finite subgroup of SO(3) including S3, S4, A5; three layers handle general finite-group word problems and weighted finite automata), matching DeltaProduct2 with one fewer layer than (Gated) DeltaNet constructions. They validate empirically on synthetic state-tracking (S3/S4/A5 word problems), periodic audio continuation, and language modeling (up to 1.3B parameters, 100B tokens of FineWeb-Edu), implemented as a minor modification of KDA's FLA recurrence kernels.

Key results:

• CKDA (both range extensions) gives the strongest length extrapolation among tested KDA variants on S3 and S4 permutation word problems, where standard (nonnegative-gate) KDA fails to extrapolate.
• On periodic waveform continuation at test length 264 (training max 136), CKDA retains 38.1 dB SNR versus 2.8 dB for a causal Transformer (though a nonlinear GRU baseline is still more accurate).
• At 1.3B parameters / 100B FineWeb-Edu tokens: CKDA achieves 10.08 LAMBADA perplexity vs 10.53 for the bounded-gate KDA baseline and 11.68 for standard KDA; CKDA's average zero-shot accuracy across ten tasks is 54.06% (recurrent-only) and 54.37% (3:1 hybrid with attention), comparable to or exceeding KDA, Mamba-3, and Gated DeltaNet-2 baselines, and outperforming a Transformer baseline (50.86%).
• CKDA retains 96–97% of standard KDA's kernel throughput on H100 (near-baseline efficiency).
• Theoretically, CKDA needs at most max{1, 2n−2} transition factors to represent any non-expansive n×n matrix (max{1, n−1} for orthogonal matrices), and one-layer S5 tracking is ruled out for CKDA and DeltaProduct-k (k≤3) under non-expansive, finite-reachability constraints (Theorem 4).

Why it matters / caveats: Clarifies precisely why channel-wise gating (not just scalar gating) matters for linear-RNN expressivity and offers an alternative to DeltaProduct2's two-transitions-per-token cost for achieving 2D-rotation state tracking, at near-zero throughput overhead. Caveats: representability does not imply learnability (e.g., A5 was not learned from random initialization in their standard setup); CKDA still supports at most one complex-eigenvalue pair per transition; and general weighted-finite-automaton constructions require β>2, sacrificing guaranteed non-expansiveness.

Problem: Compositional single-image 3D scene reconstruction methods preserve object-level geometric fidelity by decoupling object shape from scene layout, but existing layout representations (sparse pose regression: translation/rotation/scale) are sparse and unbounded, making them hard to learn accurately from scarce scene-level 3D supervision.

Method: Mira-Scene introduces the Canonical Coordinate Map (CCM), a pixel-aligned field mapping each visible object pixel to a bounded canonical-space surface coordinate; combined with a scene-space Point Cloud Map (PCM) from monocular geometry estimation, CCM induces dense pixel-to-3D correspondences, and object transformations (scale, rotation, translation) are recovered via RANSAC + closed-form Umeyama alignment rather than direct neural regression. A multimodal diffusion transformer (Mixture-of-Transformers design) jointly generates canonical object geometry (voxel-latent Geometry Expert) and CCMs (pixel-space Layout Expert) as two modality-specific rectified-flow streams that exchange information through shared self-attention and a shared 3D positional embedding. Training uses a two-stage pipeline: pretraining on 60K rendered Objaverse objects (1M views, plus 20K background-inpainted views) for object-level CCM/geometry supervision without scene annotations, followed by fine-tuning on 20K occluded-object instances from 3D-FRONT scenes.

Key results:

• On BlendSwap, Mira-Scene improves 3D-IoU from 0.520 (SAM3D) to 0.727 (39.8% relative gain) and 2D-IoU from 0.672 to 0.783 (16.5% relative gain), while using substantially less/only public open-source training data than SAM3D's large proprietary data engine.
• On 3D-Future Scene, 3D-IoU improves from 0.596 (SAM3D) to 0.694 (16.4% relative gain), with lower Chamfer Distance and ICP-Rot error than all baselines (Gen3DSR, MIDI, SceneGen, SAM3D).
• Ablation on layout representation: CCM with PCM raises 3D-IoU from 0.379 (Coord Cube) to 0.727 and 2D-IoU from 0.381 to 0.783, showing the bounded-canonical-space design (not just densification) drives the gain — plain densification (Coord Cube) only marginally improves over raw pose regression (0.365→0.379 3D-IoU).
• Architecture ablation: removing joint (shared) attention between geometry and layout experts drops 2D-IoU from 0.757 to 0.535 and increases Chamfer Distance from 0.017 to 0.070; removing the shared positional embedding causes a smaller but consistent drop (2D-IoU 0.757→0.747).
• Correspondence comparison with CUPID shows Mira-Scene's reverse (pixel-to-3D) correspondence formulation achieves better Chamfer Distance and F-scores than CUPID's forward (3D-to-pixel) formulation despite CUPID's slightly higher 2D mask IoU.

Why it matters / caveats: Shows that reformulating scene layout as a dense, bounded correspondence problem (rather than sparse pose regression or scene-space point prediction) enables data-efficient, generalizable compositional 3D scene reconstruction across indoor/outdoor/synthetic/in-the-wild images, using far less scene-level supervision than prior data-scaling approaches like SAM3D.

Problem: Benchmarks like KernelBench decide whether an LLM-generated GPU kernel is "correct" using a handful of random inputs and a loose floating-point tolerance, and nobody could previously measure how adequate these correctness checkers actually are.

Method: The authors adapt mutation analysis to graded numerical oracles: 124 deterministic mutation rules across six fault families (arithmetic, indexing, semantic, boundary, synchronization, precision) are applied to 188 gate-verified CUDA substrates via NVRTC (84ms/mutant vs. 200s through the torch extension path), producing 10,303 mutants. A mutant is admitted into the scoring denominator only if it has an independent "kill witness" (a validity-gated input that provably detects it), yielding 7,384 witnessed mutants that form a kill matrix used to score any test protocol, audit existing checker patches (e.g., KernelBench-Verified), and synthesize minimal test suites via greedy set cover.

Key results:

• The official KernelBench check misses 16.9% of witnessed faults overall, but 78.6% of precision faults and 27.8% of synchronization faults escape vs. only 8.7% of arithmetic faults.
• KernelBench-Verified's +8.5 point improvement decomposes into +4.0 from hidden input distributions and +4.5 from tighter tolerance—a split its own authors could not compute.
• A reconstructed fuzzing baseline (Correctness-Illusion style) reaches 86.2% detection but falsely rejects 107 correct kernels by crossing a measured floating-point "validity ceiling."
• Optimized 2-input-per-problem suites (via set cover) reach 98.0% detection on the full pool and 94.8% on held-out mutants, versus 83.1% for the official 5-input protocol.
• Giving an LLM test generator the measurement-derived fault taxonomy nearly triples a fuzz baseline (21.6% to 61.0% survivors killed) and outperforms giving it the raw concrete mutated faults (57.3%).
• At the architecture (whole-network) scale across 48 networks, 17.3% of faults escape (vs. 16.9% at operator scale), concentrating in deep homogeneous pipelines (VGG-19 90%, SqueezeNet 90%) versus normalization/branch-dense networks (ResNet-18 11%); two problems are found to be fundamentally unrefereeable because their own fp32 reference violates the benchmark's tolerance against fp64.

Why it matters / caveats: Since KernelBench-style checkers serve as RL reward signals for kernel-generating models, blind spots enable reward hacking; the paper turns "is this checker good enough" from opinion into a measurable, actionable metric and releases the pipeline as KernelBench-M. The method's adequacy is relative to its 124 rules and naive substrates, so it cannot certify a passing kernel as truly correct, and results are from a single GPU generation (H100).

Problem: Existing safety fine-tuning for Vision-Language-Action (VLA) robot models relies on Lagrangian constrained optimization that only softly penalizes expected cumulative cost, causing residual safety violations or overly conservative behavior, and visual domains lack dense per-step safety labels needed to train a safety signal.

Method: ShieldVLA learns a model-free Hamilton-Jacobi (HJ) reachability safety critic Qsϕ via a discounted safety Bellman operator (TD learning on a shared off-policy replay buffer), then uses this critic as a hard gate on PPO policy optimization: states with Qsϕ > δ get the unmodified PPO reward gradient, while infeasible states get a deterministic policy gradient (Lsafety = -Qsϕ) pushing toward safety, with the safety-push coefficient βt tuned via dual ascent on a cost budget. Per-step safety margins ℓ(o), needed to train the critic since ground-truth costs are unavailable from vision, are derived from a frozen VLM (Qwen3-VL-8B) scoring each frame against structured, weighted safety rubrics, calibrated to per-episode binary outcome labels via Platt scaling (logistic regression), with an offline "Refinement-through-Differentiation" (RTD) loop using a larger VLM (Qwen2.5-VL-72B) to mine new rubrics from disagreement cases.

Key results:

• Averaged across five environments (Dubins-VL, TurtleBot-Nav/OmniVLA, Safety-CHORES Nav/Fetch/SPOC-VLA, Franka-Reach/OpenVLA-OFT), ShieldVLA reduces cumulative safety cost (CSC) by 57% on average and improves success rate (SR) by +0.13 over SafeVLA.
• Per-environment SR/CSC vs. SafeVLA: TurtleBot-Nav 0.54/6.90 vs 0.34/14.6; Safety-CHORES Nav 0.68/1.44 vs 0.59/1.82; Safety-CHORES Fetch 0.49/5.50 vs 0.34/8.98; Franka-Reach 0.45/3.50 vs 0.34/13.4.
• On Dubins-VL, ShieldVLA (0.32 SR, 1.3 CSC) nearly matches the privileged oracle HJ-with-ground-truth-cost baseline (0.38 SR, 1.13 CSC) despite using only VLM-derived costs.
• Ablations: replacing VLM rubric costs with a binary collision indicator collapses SR on 3/4 environments (e.g. Franka-Reach 0.25 vs 0.45); replacing feasibility gating with a Lagrangian-penalty using the same critic underperforms on both SR and CSC (0.33/7.80 vs 0.54/6.90 on TurtleBot-Nav).
• Under out-of-distribution visual perturbations (color/lighting shifts), ShieldVLA holds the lowest CSC in every tested cell and even improves safety on Safety-CHORES Nav (Δ CSC = -0.49) while SafeVLA degrades (+1.19), with comparable success-rate cost.

Why it matters / caveats: The approach decouples safety from reward optimization (zero penalty when safe, zero reward signal when unsafe) rather than trading them off globally, and needs no VLM calls or runtime shield at deployment. Acknowledged limitations: safety guarantees are empirical, not formal (finite-data function approximation); sub-8B VLM scorers show mode collapse on tail frames; comparison is against a single published baseline (SafeVLA); and all evaluation is in simulation, with real-robot validation left to future work.

Problem: Disaggregated evaluation of AI systems (reporting performance per domain, e.g. benchmark task type or conversation category) needs accurate per-domain estimates from a limited labeling budget, but direct estimators such as prediction-powered inference (PPI) use only a domain's own labels and become imprecise when a domain has few labels, and there is no principled way to choose among candidate estimators without ground truth.

Method: The paper frames evaluation as finite-population survey sampling and introduces prediction-powered smoothing (PP-S): a Bayesian Fay-Herriot area-level model fit to each domain's GREG (generalized regression, a tuned generalization of PPI) point estimate and its sampling variance, shrinking noisy domains toward a regression on domain-level covariates; an extension, PP-TS, adds nested random effects across a reporting taxonomy (e.g., task type nested in benchmark) to borrow strength hierarchically. For model selection/validation without an oracle, they derive a debiased design-based cross-validation score (extending Dong & Li's DB-CV) that removes both fold-level and sample-level bias via a closed-form covariance correction, enabling comparison across direct and model-based estimators from a single sample.

Key results:

• On the Open LLM Leaderboard benchmark (34 task types, phi-4 accuracy), PP-TS achieves the lowest RMSE and interval score under every auxiliary tested, e.g. under historical difficulty (strong auxiliary): RMSE 0.059 (PP-TS) vs 0.061 (PP-S) vs 0.065 (TFH) vs 0.067 (FH) vs 0.074 (GREG/PPI) vs 0.082 (HT).
• Interval coverage for all estimators stays between 0.93 and 0.95 against nominal 95%.
• PPI can underperform the plain sample-mean (HT) estimator under weak auxiliaries (RMSE 0.106 vs 0.082), because it lacks GREG's tuned correction slope.
• On PRISM deployed-agent traffic (63 domains), DB-CV correctly ranks all 7 candidate estimators exactly as the (normally hidden) oracle RMSE does, selecting PP-S with judge+content covariates (oracle RMSE 1.527) over HT (2.505).
• At equal sampling budget, DB-CV selects estimators about as well as splitting the budget into two independent samples (oracle RMSE of chosen candidate: 1.543 for DB-CV vs 1.557 for 50/50 split vs 1.678 for 80/20 split), while reporting error much more accurately: DB-CV's reported error is 1.07x the true oracle RMSE vs 2.59x-4.00x for the alternatives (naive CV, 50/50, 80/20 splits).
• A biased (non-probability) sampling illustration on PRISM shows persistent bias and below-nominal coverage that PPI does not fix, motivating the paper's reliance on probability sampling throughout.

Why it matters / caveats: The framework gives evaluators a practical recipe to get more precise, well-calibrated per-domain scores from a fixed labeling budget and to pick the best estimator/covariates from one sample rather than needing a held-out validation set. The authors note open questions, including reliable zero-shot (unlabeled) domain estimation and handling grader disagreement/measurement error, left for future work.

Problem: Existing video editing diffusion models rely on bidirectional full-sequence processing, making them incompatible with real-time causal/streaming applications (e.g., live style transfer, online inpainting), while training a streaming editing model from scratch or via distillation is prohibitively expensive (reported at ~128 H100 GPU-days).

Method: SVEET trains an editing control branch only on a frozen pretrained bidirectional video diffusion backbone (Wan2.1-1.3B-VACE) and transfers it zero-shot to a frozen causal streaming backbone (chunk-wise Causal Forcing) without retraining the streaming model. It replaces the control branch's full spatiotemporal self-attention with temporally-independent 2D spatial attention (each token attends only within its own frame, enforcing "conditional frame independence" and requiring no KV cache growth), and introduces Orthogonal Decoupled Training (ODT): using SVD to identify the dominant discrepancy subspace between bidirectional and causal backbone features (from a calibration set, via ridge-regression-derived residual transformation), then constraining the trainable LoRA-based control update (rank 128) to the orthogonal complement of that subspace via a layer-adaptive rank projector retaining 80% cumulative spectral energy.

Key results:

• Across three editing tasks (style transfer, video inpainting, depth-to-video), SVEET achieves the best or near-best scores on most metrics; e.g., on style transfer, VLM editing accuracy 7.43 (ours) vs 5.87 (LiveEdit) vs 7.07 (3D VACE attention) vs 1.89 (Channel concat).
• Ablation isolating the two components: on VLM score/motion smoothness, 3D-attn w/o ODT = 7.07/0.981, 3D w/ ODT = 7.33/0.986, 2D w/o ODT = 7.19/0.983, 2D w/ ODT (full method) = 7.43/0.990 — both components contribute, combined is best.
• Alternative transfer strategies underperform: inference-stage projection (post-hoc) scores 6.43 VLM/0.985 smoothness, and two-stage teacher forcing scores 7.09/0.988, both below SVEET's 7.43/0.990.
• Adaptive rank selection (retaining 80% of cumulative spectral energy) outperforms fixed-rank projections (k=32/64/128); the paper reports empirically that only about 4%-21% of singular directions are needed to explain 80% of the bidirectional-to-causal discrepancy energy across DiT layers, supporting the low-rank discrepancy assumption behind ODT.
• User study (10 participants, editing correctness/structural preservation/overall smoothness): ours scores 9.08/9.21/8.11 vs. next-best DayDream+CF at 7.85/8.62/7.95.
• SVEET runs at 15 FPS on a single H100 GPU without any auxiliary acceleration technique.

Why it matters / caveats: The method offers a cheap alternative to retraining/distilling a dedicated streaming editing backbone, enabling real-time video editing by transferring capability learned once on a bidirectional model. A stated limitation is that editing quality is bounded by the underlying bidirectional editing model's capability, and generalizing the transfer to broader editing tasks and more heterogeneous backbones is left as future work.