AI papers — 2026-09-25

Problem: Video generation models used as "world models" systematically fail at object permanence (objects vanishing/reappearing wrongly after occlusion) and object solidity (objects passing through solid barriers), and there was no principled way to evaluate or train these specific capabilities.

Method: The authors build WROP (World Reasoning with Object Permanence), 150 hand-authored Blender generators (no rigid-body solver; motion is authored via keyframe animation) spanning six cognitively-grounded task families (three object-permanence: Baillargeonian Occlusion, Object Static Occlusion, Container Permanence; three object-solidity: Baillargeonian Obstruction, Object Drop, Object Collision), each producing 10,000 samples (120-frame clips at 1280x720/24fps split into 60-frame input/60-frame target) for a 1.5M-sample training corpus plus a 300-question exam. They fine-tune PWM-WROP, a 16B model initialized from Cosmos3-Nano, for one epoch on the corpus at 320x192 resolution (video-to-video, no architecture changes), using a custom native-PyTorch training stack ("PWM") on AWS Trainium2 (36-layer model, tensor-parallel x FSDP2 over 64 NeuronCores).

Key results:

• In a blind pairwise human study (20 raters, Bradley-Terry/Elo, 361 judgments across 14 models), PWM-WROP ranks 3rd overall (Elo 1679.5) and 1st among true-continuation models, beating the next-best continuation model (Grok Imagine) by 224 Elo points (1457).
• Top overall: Wan 3.0 Prime and MiniMax H3 tie at Elo 1723.6 (both reference-to-video); Seedance 2.5 4th at 1650.
• PWM-WROP ranks 1st within-family on Object Static Occlusion (OP-2) and 2nd on Object Drop (OS-2), but only 8th on Object Collision (OS-3), showing OP/OS asymmetry.
• Training throughput on Trainium2: optimized from 15.1s/step down to 5.7s/step (batch 16, 288x512 geometry) after engineering fixes.
• Rater quality: 90.0% attention-check accuracy, Cohen's κ=0.891 self-agreement, no position bias (51.4% left-preference, p=0.615).

Why it matters / caveats: Shows concept-specific synthetic training data can measurably improve physical-reasoning behavior in video generation models even at much lower native resolution (320x192) than commercial competitors (720p/1080p). The authors note the comparison is confounded by architecture differences across models, so the Elo gains cannot be attributed to fine-tuning data alone.

Problem: Whether standard decoder-only Transformers process a linear combination (average) of two distinct input token streams as an approximate superposition of their independent next-token distributions, and whether this could be exploited for parallel inference.

Method: The authors mix two text sequences by element-wise averaging their token embeddings and pass the result through frozen pretrained models (Pythia, Qwen, Llama, OLMo, Gemma families) on TinyStories and FineWeb, measuring rank-preservation of each stream's ground-truth next token and KL/JS/Wasserstein divergence to the target mixture distribution 0.5(P(x|A)+P(x|B)). They track hidden-state additivity error across Pythia's pretraining checkpoints, run attention-patching ablations (donor patching vs. permutation patching) to isolate the role of attention shape, then apply a self-distillation fine-tuning objective (student on mixed input, frozen teacher's averaged independent predictions, KL loss) to restore/amplify linearity, and finally propose "Joint Contrastive" decoding (using a small auxiliary model to disentangle logits: ℓ̃(A) = ℓlarge(z) + α·ℓsmall(A) − β·ℓsmall(B)) to recover two separate continuations from one forward pass.

Key results:

• Base pretrained models: true next token appears in top-10 of the mixed distribution ~30-40% of cases, top-50 in 50-60%, top-100 in 60-65% (vs. ~1-10% under a frequency-only cross-stream baseline).
• Superposition Approximation Ratio R_D < 1 for all models/metrics (e.g., Pythia-2.8B: R_KL=0.42 base → 0.06 after fine-tuning).
• Linearity error (Ē) grows monotonically over Pythia pretraining (Fig. 2), i.e., pretraining degrades intrinsic superposition.
• After fine-tuning (~200k steps, <0.025% of pretraining data size), Pythia-2.8B: KL divergence to target drops 1.86→0.27; top-5 rank-recovery rises from ~30% to >60%; content-token median rank drops from 284 to 5 with top-1 agreement rising to 22.8%.
• Costs: single-stream LAMBADA accuracy degrades (Pythia-2.8B 0.544→0.357; Qwen2.5-3B 0.602→0.460).
• Joint Contrastive decoding raises mixed-stream LAMBADA mean accuracy from 0.06-0.18 (pretrained) to 0.11-0.43 (e.g., Llama-3.2-3B reaches 0.430 vs. 0.540 single-stream small-model baseline).
• Throughput: "Separate" (fused-embedding, two-head) decoding matches batch-2 baseline within 3% and gives ~2x throughput over sequential two-pass decoding.

Why it matters / caveats: Suggests linear superposition is an intrinsic architectural property (present at initialization, not learned) that could in principle enable 2x throughput / halved KV-cache via parallel multi-stream inference, but full disentanglement is blocked by a "geometric-mean obstruction" in decoding that remains an open problem; experiments are limited to short/medium contexts (≤512 tokens) and monolingual text, and multimodal extension is untested.

Problem: As text-to-video generators scale to 30-second, instruction-faithful outputs, conventional prompt enhancers built via forward descriptive rewriting create a distribution mismatch with the video-grounded captions the video generator was trained on, and fail to preserve user requirements consistently across multiple shots and over time.

Method: WanPE is a 397B-parameter (Qwen3.5-397B-A17B-initialized; variants also at 4B/9B/35B) prompt enhancer trained via "video-grounded reverse construction": real videos (~1.05M clips, 10 content categories) are captioned into hierarchical shot-level cinematic plans y (via a multimodal captioner), then GPT-5.4 with few-shot prompting reverse-generates a plausible user request x from y, giving SFT pairs (x,y) that keep the target distribution aligned with real video-grounded captions rather than synthetic rewrites. On top of this SFT model, they apply Semantic-Consistency GRPO (SC-GRPO), a GRPO variant with a 9-dimension reward (style, subjects, actions, dialogue, sound, camera, lighting, spatial relations, scene) scored by Qwen3.7-Max on ~15K prompts, to penalize omissions/alterations/mis-bindings/temporal inconsistencies across shots. They also introduce WanPEval, a 249-request human-annotated benchmark spanning 5-30s durations and intent/scene/shot-level granularities, evaluated via ~11K blind pairwise expert (60 screenwriting/film experts) comparisons scored with Bradley-Terry.

Key results:

• WanPE-397B improves human preference over raw prompts by 10.66 (5s), 16.28 (10s), 18.84 (15s) points, and 50.86 points at 30s (S: 9.38→60.24) under Wan3.0's video generator.
• On the 5-15s subset it beats all commercial baselines (LTX-2.5, Kling 3.0, HappyHorse 1.1, MiniMax-H3, Seedance 2.0), overall S=50.61/BT=61.85, beating Seedance 2.0 by 7.19 S points; remains competitive with Seedance 2.5 on 30s (59.76 vs 60.24 S).
• Reverse-constructed SFT beats Forward Rewriting by 10.37 points and Forward-target SFT by 14.69 points in S (49.86 vs 39.49 vs 35.17).
• SC-GRPO improves semantic-consistency score by 18.6-23.3 points across the four model scales (e.g., 397B: 75.5→97.6 overall) and lifts downstream video preference from 42.70 to 49.69.
• Format-adapted WanPE transfers to other generators: +14.45 S points on LTX-2.5-Base, +5.17 on MiniMax-H3-Base vs. native enhancers.

Why it matters / caveats: Reframes prompt enhancement as director-level cinematic planning rather than descriptive rewriting, showing the choice of supervision distribution (video-grounded vs. forward-rewritten) matters more than scale alone for long-duration T2V generation; gains are demonstrated specifically atop Wan3.0's generator and via LLM-based (Qwen3.7-Max/gemini) automatic judges for semantic consistency.

Problem: Embodied agents lack the ability to use spatial (directional) audio cues jointly with vision for perception and navigation, and there was no benchmark or scalable training pipeline for evaluating/teaching spatial audio-visual understanding in real-world settings.

Method: The authors build OmniEchoBench: OmniEchoBench-QA (2,972 QA pairs over 197 real human-recorded scenes with synchronized first-person video, 360° panoramic reference video, and 4-channel First-Order Ambisonics/FOA audio, covering source direction, 3D localization, source motion, camera rotation, and a bird's-eye "cognitive map" task) and OmniEchoBench-Nav (900 navigation tasks across 30 real-scanned indoor scenes, 12,900 dense FOA recording points, non-speech + spoken-command sound sources). They also build a controllable spherical-harmonics-based FOA rendering pipeline for scalable synthetic training data (363,193 examples: QA + navigation from ScaleVLN/RxR/R2R/VLN-PE). They propose OmniEcho, built on Qwen3-Omni-30B-A3B, adding a separate FOA encoder (5-channel log-mel + intensity + diffuseness features, trained with 3-stage recipe: Stage 1 SigLIP-style semantic alignment to a frozen CLIP text encoder on 100k synthetic FOA clips, Stage 2 query-conditioned cross-attention localization fine-tuning, Stage 3 grafting the frozen FOA encoder alongside the native audio tower into the LLM via a trainable projector, updating only LLM + projector).

Key results:

• On OmniEchoBench-QA (audio+vision), OmniEcho achieves 28.5% overall accuracy vs. 18.5% for the Qwen3-Omni-30B-A3B backbone and 11.4% for the closest competitor SO-7B; audio-only OmniEcho gets 21.8% vs. 17.5% (backbone) and 10.1% (SO-7B).
• OmniEcho: Cognitive Map task 47.5% (vs ~20-23% for other models), Camera Rotation 41.7%, Source Direction 22.6%.
• On OmniEchoBench-Nav (real FOA): OmniEcho gets SR=16.2%, SPL=11.5%, close to text-guided InternVLA-N1 (SR=17.8%, SPL=16.7%) and beating Seq2Seq/CMA text baselines and SoundSpaces binaural baseline (SR=5.4%).
• On VLN-CE R2R (simulated): OmniEcho SR=22.2%, NE=7.31, shortest trajectory length (5.54) among reported methods, though behind stronger text-guided systems like InternVLA-N1 (SR=50.6%).
• Ablation: full model (native audio tower + frozen FOA encoder) gets 28.5 overall vs. 19.8 without FOA encoder and 26.2 with FOA encoder trained (not frozen) in stage 3.
• Feature-based FOA input with Stage-1 pretraining achieves 17.9° azimuth / 7.70° elevation / 1.13 distance error, vs. 30.5°/13.8°/1.65 for raw waveform input.

Why it matters / caveats: First unified benchmark and model combining real-world spatial-audio-visual perception with sound-guided navigation; demonstrates spatial audio narrows the gap to text-guided navigation without route-level instructions. Authors note fine-grained localization/distance estimation remain weak and training relies on simulated data with an acknowledged sim-to-real distribution gap.

Problem: Existing language world models for LLM agents predict future tool/environment observations, which is difficult and low-value when real execution feedback is available anyway; meanwhile agents suffer "task-state contamination," where unsupported assumptions and outdated plans persist in history and corrupt later decisions.

Method: The authors propose the Agent-Editing World Model (AEWM), which instead of predicting observations, models the effect of the agent's current reasoning-action pair on future task progress via two components on a shared Qwen3.5-35B-A3B backbone: Action Judge (MAJ) classifies the pre-execution state as CRITICAL, EXPLORATORY, or NOISY; State Revision (MSR) regenerates a new reasoning-action pair from the same history when judged NOISY. "EditAct" integrates these at inference: retain the proposal if critical/exploratory, replace it if noisy, then execute the (possibly revised) action in the real environment. Training uses synthesized Action Judge and State Revision data (from annotation/proposal/revision agents built on DeepSeek-V4-Pro, GLM-5, Qwen3.5-35B-A3B) across Search, Terminal, and SWE domains, via two-stage training: mid-training on ~52B tokens then SFT on 120K curated examples (60K Action Judge + 60K State Revision). AEWM-RFT further does rejection-sampling fine-tuning of the base agent on verified EditAct trajectories to internalize the corrections without needing AEWM online at inference.

Key results:

• AEWM achieves 70.5% macro-F1 on their 3,000-decision Action Judge benchmark, beating the strongest frontier baseline (DeepSeek-V4-Pro, 59.9%) by 10.6 points; per-domain: 60.9% Search, 72.1% Terminal, 77.8% SWE (10.3-13.4 points over best baselines).
• EditAct beats ReAct and Step-/Trajectory-level Best@3 across all six benchmarks (BrowseComp, DeepSearchQA, Terminal-Bench 2.0, Doc2Repo, NL2Repo, SWE-Bench Pro) and three backbones, with average-score gains of 6.7 (Qwen3.5-4B), 5.2 (Qwen3.5-9B), 3.2 (Qwen3.5-35B-A3B) points over the strongest baseline.
• Qwen3.5-9B+EditAct (44.1 avg) surpasses Qwen3.5-35B-A3B+ReAct (42.2 avg), showing cross-scale gap-narrowing.
• AEWM-RFT beats Self-RFT by 2.2-2.6 points across BrowseComp (45.4 vs 43.2), Terminal-Bench 2.0 (43.4 vs 40.8), Doc2Repo (48.6 vs 46.1), without using AEWM online, and reduces average turns by up to 30%.
• Ablations: EditAct beats Random Gate, Agent Resampling, AEWM-Hint, and single-component (action-only/reasoning-only) revision variants across BC/TB2/Doc2Repo; full mid-training+SFT recipe beats SFT-only and mid-training-only.

Why it matters / caveats: Reframes what a "world model" should predict for LLM agents (decision effects/state corrections rather than raw observations), directly addressing a documented failure mode (task-state contamination); gains hold on both in- and out-of-distribution benchmarks, though benefits diminish with a much stronger backbone (Qwen3.5-Plus), attributed to a capacity gap between AEWM and the inference agent.

Problem: It is unclear whether sparse autoencoder (SAE) latents represent linguistic categories like part-of-speech (POS) as individual monosemantic units or as distributed groups of features.

Method: The authors extract token-level residual-stream activations from layer 30 of LLaMA-3-8B on the UD English GUM treebank, encode them with the pretrained EleutherAI/sae-llama-3-8b-32x SAE (via the Sparsify library), and analyze the resulting sparse activation vectors (131,072-dim latent space) against gold Universal Dependencies POS tags. They use L1-regularized one-vs-rest logistic regression probes for recoverability, a feature-salience/coverage analysis (smallest set of latents reaching 95% coverage per POS tag) for localization, and a compact multi-class classifier trained only on the union of these latent groups (L*, 498 latents) to test sufficiency; stability is validated on the held-out GUM test split and on a small controlled dataset of 180 lexical items in minimal templates.

Key results:

• One-vs-rest probing F1 is high for most POS tags (5-fold CV on GUM train); closed classes and punctuation are easiest, low-frequency/heterogeneous open classes are harder.
• The compact feature set L* has only 498 latents (12% shared across 2+ POS) yet gives multi-class classification performance comparable to the full SAE representation.
• Number of latents needed for 95% coverage (kc*) varies widely: closed classes are compact (e.g., DET dominated by one latent), open classes need many more (NOUN 10,043 non-zero latents, 7.7% of latent space, vs. CCONJ only 645, 0.5%).
• Control with randomized labels drops accuracy to 0.54/macro-F1 0.42 vs 0.88/0.97 for real labels (34-37 point gap), showing recoverability isn't just lexical memorization; SAE probe (0.88 acc) is comparable to raw layer-30 (0.92) and layer-0 embedding (0.88) probes using ~8x fewer features.
• On held-out data, recall for latent groups is mostly ≥0.95, but cross-category off-diagonal co-activation shows overlap (mean Distinctiveness D=0.27, σ=0.07, vs. 0.06 chance baseline).
• Randomly replacing L latents at 0%/25%/50% overlap collapses multi-class accuracy from 0.87-0.89 to 0.23-0.24, confirming L latents are specifically POS-relevant.

Why it matters / caveats: Shows SAE interpretability of morpho-syntax is category-dependent and distributed rather than one-latent-per-category, cautioning against reading top-activating examples as clean atomic features; the study is limited to one model (LLaMA-3-8B), one SAE, one layer family, and English POS only, with probe coefficients not established as causally used by the model.

Problem: Post-training recipes for open LLMs are usually reported only at the level of a system card, leaving the data, reward design, and infrastructure choices needed for reproduction undisclosed.

Method: Rufus-Air is an eight-stage serial post-training pipeline applied to GLM-4.5-Air-Base (106B total/12B active MoE): SFT → Reasoning RL → Coding RL → Instruction-Following RL → General Agent → Coding Agent → Search Agent → RLHF, each stage training on the checkpoint the previous stage produced. SFT uses 9.01M samples/27B loss-tokens from 17 public datasets (no in-house distillation or new human annotation); RL stages use Group Sequence Policy Optimization (GSPO) or GRPO with difficulty/learnability filtering (dropping too-easy and too-hard prompts, DAPO-style dynamic sampling), deterministic verifiers (Math-Verify, Python checkers, execution tests) for early stages, and rubric-based LLM judges for later stages (IF RL, RLHF); infrastructure runs on Slime/Megatron-LM/SGLang with Rollout Routing Replay and token-in/token-out multi-turn rollouts.

Key results:

• Rufus-Air leads the official GLM-4.5-Air release on every benchmark except Arena-Hard v2 Creative Writing (53.0 vs 60.3); e.g., IFBench 76.9 vs 33.6, IFEval 95.4 vs 83.0, Tau2-Telecom 93.0 vs 32.7, BrowseComp 37.1 vs 22.7, SWE-bench Verified 65.6 vs 50.6.
• SFT alone (checkpoint 3799, before any RL) already beats the public GLM-4.5-Air release on IFEval (+5.3), IFBench (+24.2), AIME25 (+6.6), AIME26 (+3.5), trailing only on GPQA (-5.7).
• Per-stage gains: Reasoning RL raises GPQA 68.2→73.5 (+5.3) with AIME dipping ~2.6-2.8 pts (guardrail, not target); Coding RL raises LiveCodeBench v6 pass@1 68.6→75.9 (+7.3); IF RL raises Multi-challenge 31.1→55.8 (+24.7) and IFBench 63.8→77.8 (+14.0); RLHF raises Arena-Hard v2 Hard Prompt +6.0 and Creative Writing +14.4.
• Competitive with similarly-sized open models INTELLECT-3 and Nemotron-3-Super, trailing mainly on Arena-Hard v2 Creative Writing and Tau2-Airline.

Why it matters / caveats: Provides a fully documented, reproducible recipe built entirely on open components and public data at a compute scale (8-32 nodes) accessible outside frontier labs; authors note the stage order was set by prior experience and compute budget rather than shown optimal, no single benchmark suite was tracked across every stage (so per-stage attribution is imprecise), and Coding Agent training stopped at its compute budget rather than convergence.

Problem: Building reliable mobile planning agents for long-horizon, real-world tasks is limited by costly, hard-to-parallelize real-device interaction, constraining the scale of data collection and evaluation.

Method: The paper presents an "AI-for-AI" closed-loop framework with three parts: (1) AI for Data — agents construct tasks and collect trajectories across a hybrid environment (programmatic sandboxes, LLM-simulated environments, and selected real-device sessions), with AI-assisted diagnosis reweighting/curating training data; (2) AI for Training — a planning-oriented supervised cold start (masked cross-entropy over verified trajectories) followed by online agentic RL using Competence-Aware Reward-and-Advantage Engineering (CARE), which assigns each trajectory group to one of three competence-dependent reward regimes (progress shaping, outcome consolidation, efficiency refinement) and applies a quality-preserving advantage-calibration floor to prevent efficiency signals from swamping success signals in GRPO-style normalization; (3) AI for Harness — a deployment-time Harness (Scenario Adapter + Persistent Memory Manager + Executor) coupled to the model via an iterative model-Harness co-evolution loop. Planner Models are trained at 35B-A3B and 27B scales on Qwen backbones.

Key results:

• On MobilePA-Bench (1,700+ tasks, 200+ tools, 13 domains), Qwen-Planner-Agent 27B scores Overall 77.05%, best among evaluated systems including GPT 6 Astra (76.84%) and Claude Opus 5 (75.71%); baseline-to-agent gains: 27B Overall 67.22%→77.05%, 35B-A3B 54.90%→69.91%.
• Estimated output cost is lowest among compared systems at $2.41 per 1,000 tasks vs $3.06-$67.76 for others.
• Harness alone (fixed model) raises 27B Overall 71.90%→77.05%, Tool Use 72.79%→77.79%, Skills 79.25%→86.25%.
• CARE matches Vanilla RL accuracy while cutting output tokens by 32.5%; removing advantage calibration produces shorter outputs but substantially lower accuracy.
• Model-Harness co-evolution improves Overall from 82.67%→88.50% on MobilePA-Internal (4 iterations) and 38.00%→46.98% on MCPMark (3 iterations), beating harness-only baselines (84.23%, 42.26%).
• On long-context memory (BEAM benchmark), Harness raises mean scores from 42.18%→68.29% (BEAM-500K), 40.41%→70.27% (BEAM-1M), 23.42%→61.66% (BEAM-10M), while direct-context baselines collapse (best model ≤25.64% on BEAM-10M).

Why it matters / caveats: Demonstrates a practical pipeline coupling data flywheel, competence-adaptive RL, and a co-evolving runtime harness for real-world mobile agents at competitive cost; the paper frames co-evolution as "a development pathway," not evidence of established autonomous co-evolution, and all model/harness updates remain human-reviewed rather than applied autonomously.

Problem: ReAct-style deep-search agents suffer from role coupling (one policy must plan, use evidence, and synthesize) and context accumulation (growing search histories add noise and bury useful information), causing premature termination or shallow evidence use on long-horizon search.

Method: IterSynth is a role-decoupled, summary-based workflow in which a single shared LLM policy alternates between a Planner (observes only the question and a compact global summary, decides to search or answer) and a Synthesizer (integrates retrieved evidence into the persistent summary, cannot search or answer), formalized as an augmented MDP. Training uses a two-stage recipe on Qwen3-8B: cold-start SFT on ~10K trajectories (unrolled into ~87.4K role-conditioned samples) synthesized by Qwen3.5-397B-A17B rolling out the dual-role loop, followed by Role-Decoupled Policy Optimization (RDPO), which combines a broadcast terminal accuracy reward with turn-level LLM-judge rubric scores and computes GRPO-style group-relative advantages separately within Planner and Synthesizer reward pools.

Key results:

• IterSynth-8B achieves an average of 50.7% across BrowseComp, BrowseComp-ZH, GAIA-text-only, xBench-DS-2505/2510, beating the strongest prior ≤8B agent (MiroThinker-v1.0-8B, 46.5%) by +4.2 points, with the largest gain on BrowseComp-ZH (55.4% vs. 40.2%, +15.2).
• It is competitive with several 30B-scale agents (beats ReSum-30B 33.3, AgentFold-30B-A3B 50.2, OpenSeeker-30B-SFT 50.6) at under one-third the parameters.
• Ablations: IterSynth-SFT alone scores 44.1 average; outcome-only GRPO raises it to 48.9; full RDPO reaches 50.7; a variant with the same composite reward but mixed-role advantage normalization ("w/o RD") drops to 47.2, below plain GRPO.
• Role-swap ablation: replacing the trained Synthesizer with untrained Qwen3-8B drops average score by 17.4 points; replacing the Planner drops it by 41.1 points, showing planning is the more critical role.
• As a training-free prompting paradigm on frontier models, IterSynth improves average score over ReAct by +5.5% (Claude-4.5-Opus) and +4.5% (DeepSeek-V3.1), with up to +10.0% over ReAct on BrowseComp-ZH-type gains; it also outperforms IterResearch on most benchmarks.

Why it matters / caveats: Shows that decoupling planning from synthesis (without adding parameters) and using role-specific credit assignment in RL yields more reliable long-horizon search than monolithic ReAct agents, and that the workflow itself (not just training) transfers zero-shot to frontier proprietary models.

Problem: It is unclear whether general-purpose coding agents can automate the substantial TAMP-specific engineering (predicates, operators, samplers, skills) normally required for generalized task and motion planning (TAMP), which couples discrete decisions to continuous geometric/kinematic/dynamic constraints.

Method: The authors define AgenticGenPlan: given only a task description and sandboxed simulator access (reset/step interface, no source code in the main setting), an off-the-shelf coding agent (Claude Code with Opus 5, or Codex with GPT-5.6 Sol or GPT-6 Astra) interactively writes, tests, and revises a Python program implementing a policy class (reset + get_action) within a fixed $20 synthesis budget; the program is then frozen and evaluated with no further LLM calls. They compare against hand-engineered TAMP planners (symbolic search + sampling, from KinDER/PDDLStream), a non-agentic LLM-based generalized-planning baseline (LLMGenPlan) with and without one-shot generation, and an "+source" variant giving agents the environment source code, across 28 environments (25 from KinDER across four families, plus 3 PDDLStream domains), with 5 runs/method/environment and 100 held-out test instances each (98,000 evaluation episodes total).

Key results:

• All three agent configurations beat hand-engineered planners on the 16 environments where one exists: Claude Code (Opus 5) averages 82% success (planner 47%), Codex/GPT-6 Astra averages 95%, Codex/GPT-5.6 Sol averages 56%.
• GPT-6 Astra is the best-performing agent overall, beating Opus in 20/28 environments; per-family Astra means: 99% Kinematic2D, 97% Dynamic2D, 93% Kinematic3D, 65% Dynamic3D, ~100% PDDLStream.
• Agents use far less computation than planners: on 14 environments with a planner and varying object counts, Opus and Astra programs average 2.1s and 0.5s per instance vs. 29s for planners; without source code, decision time averages 11.7ms/action (Opus) and 1.3ms/action (Astra).
• Source-code access raises mean success from 74%→84% (Opus) and 86%→95% (Astra), while LLMGenPlan with the same source access and budget reaches only 28% (agent's own program is higher in 27/28 environments), isolating the benefit of agentic (test-and-revise) synthesis.
• All methods beat One-shot generation and LLMGenPlan in mean success across all 28 environments; agents also discovered unexpected manipulation strategies (e.g., non-prehensile pushing, novel regrasping) not seen in prior published solutions.

Why it matters / caveats: Establishes coding agents as a strong, low-engineering baseline for generalized TAMP that can scale better than hand-engineered planners as object counts grow. Limitations: the setup assumes full state observability and simulator access during synthesis (no perception uncertainty), some dynamic 3D tasks (e.g., sweeping/pouring many small objects) remain largely unsolved, and training-data exposure to benchmark code cannot be fully excluded (though synthesis logs show genuine environment probing).

Problem: It is hard to evaluate an AI system's genuine scientific-exploration ability because tasks must be novel enough that pretraining recall cannot solve them, yet verifiable enough that ground truth is fully known to the evaluator.

Method: ExplorationBench provides two deterministic, executable "Alien World" sandboxes whose rules deliberately contradict familiar semantics and pre-training priors: AlienCode (a programming language, 31 discovery targets, 70 held-out tasks, graded by an interpreter) and AlienLogic (a natural-deduction system, 24 discovery targets, 70 held-out tasks, graded by a proof-checker). Each system starts from a flawed manual and fixed worked examples, then runs four autonomous exploration rounds (submitting programs/proofs as "probes" and reading deterministic feedback, no weight updates), and at each milestone M0–M4 is tested tool-free on the held-out tasks and asked to report the rules it believes hold. Five/six exploration conditions (autonomous, hindsight replay, fixed-probe, without-tool, direct, and open-book variants) isolate who selects evidence from whether evidence arrives; the primary metric is Best@3 (best final accuracy among 3 independent trajectories per system).

Key results:

• Ten frontier systems evaluated (Claude Opus 5, GPT-5.6 Sol, Gemini 3.8 Flash, Kimi K3, Grok 4.6, Qwen3.8-Max, Hy4 preview, DeepSeek-V4.1-Flash, Seed2.1 Pro, DeepSeek-V4-Pro), each with 3 trajectories per sandbox.
• Before exploration, no AlienCode trajectory exceeds 15.7% (M0); after 4 rounds, Best@3 reaches 87.6% (Claude Opus 5), with 7/10 systems exceeding 60%; extra model turns without environment feedback leave AlienCode at 0.5-11.0%.
• Autonomous exploration beats hindsight replay of the same probes for 9/10 systems in AlienCode (median 66.0% vs 40.7%; fixed-probe only 5.7%), showing designing experiments matters, not just receiving results; in AlienLogic autonomous and hindsight tie.
• Cross-sandbox rank correlation is weak (Spearman 0.35): e.g., Grok 4.6 ranks 5th in AlienCode but 1st in AlienLogic.
• Discovering a rule and using it dissociate: on 647 task-trajectory pairs where all required rules were reported correctly, tasks are still solved only 70.9% of the time; number of correctly-stated rules correlates with M4 accuracy at r=0.85 (correlational only).
• In AlienCode, being told the rules upfront (open-book, 27-91%) underperforms exploration+use for 7/10 systems (best exploration 87.6% vs open-book 68.1% for GPT-5.6 Sol); in AlienLogic the reverse holds (open-book 93-97% beats every system's own exploration, max 83.8%).
• Reliability is poor: same-system same-budget trajectories vary by up to 72.8 points (AlienCode) and 21.0 points (AlienLogic), far beyond the ≤4.7-point answering noise; 6/30 AlienCode and 3/30 AlienLogic trajectories end at least 3 points below an earlier milestone (progress can reverse).

Why it matters / caveats: Offers a recall-resistant, exactly verifiable framework for measuring exploration as a distinct capability from static knowledge/reasoning benchmarks, revealing that frontier systems can acquire unfamiliar rules but do so unreliably and don't always apply what they find. Authors note the two sandboxes are deterministic and synthetic (unlike noisy, costly, open-ended real science) and only 3 trajectories/3 answers per condition were run, insufficient to precisely estimate variability distributions.

Problem: Existing RGB-D semantic segmentation benchmarks (NYUv1/v2, SUN RGB-D) are too small, cover too few semantic categories, and contain substantial annotation noise, limiting the training and evaluation of modern deep segmentation models.

Method: The authors curate RGBD20K, 20,000 RGB-D image pairs assembled from SUN RGB-D, RGB-D Mirror, VidSOD, DepthTrack, ARKitTrack, and DIML RGB-D, re-annotated via a multi-stage manual pixel-level labeling and refinement process into a unified 160-class taxonomy spanning 75 scene types (18,000 train / 2,000 test split). They also propose Score-Purified Fusion (SPF), a Swin-L-backboned, SegFormer-style network that replaces standard cross-attention fusion with a "purify-then-attend" mechanism: a Score Head/Relation Arbiter computes intra- and cross-modal reliability scores that adaptively weight learnable noise and cross-modal features to produce purified Key/Value representations before Multi-Head Attention, reducing "attention dilution" from noisy/misaligned depth.

Key results:

• RGBD20K: 20,000 image pairs, 160 categories, 75 scenes, 368,312 masks (vs. NYUv2's 1,449 images/40 classes and SUN RGB-D's 10,335 images/37 classes).
• SPF reaches 46.3% mIoU on RGBD20K, 60.5% on NYUv2, and 55.0%/62.2% on SUN RGB-D/SUN RGB-D† (re-annotated), outperforming GeminiFusion, DFormer v2, DPLNet, CMX, CMNeXt, MultiMAE, TokenFusion, and PGDENet.
• Re-annotating the SUN RGB-D test set alone raised a pretrained DPLNet's mIoU from 52.8 to 55.0; retraining on the fully refined SUN RGB-D† raised DPLNet to 59.0 mIoU.
• Ablations: removing RGB/depth alignment projections costs -0.6 mIoU; removing the purification score costs -0.8 mIoU; a 2-layer MLP + Sigmoid Relation Arbiter outperforms Softmax or CNN variants.

Why it matters / caveats: A substantially larger and cleaner RGB-D benchmark could improve generalization of multimodal perception models for robotics/autonomous systems; the paper's own analysis shows annotation noise in prior benchmarks meaningfully understated model performance, which is itself a notable finding independent of the new dataset.

Problem: LLMs can now prove many mathematical conjectures, but there is no way to determine whether newly generated theorems are mathematically interesting or useful rather than trivial restatements within the "convex hull" of existing mathematics.

Method: The authors define theorem interestingness as I(T|P) = 100·V(T|P)/L(T|P), the ratio of conditional proof difficulty (lines of Lean 4 code) to conditional statement description length; they train a value model Vθ by fine-tuning Qwen3.6-27B with GRPO on ~100k mathlib-derived (theorem, premises, proof) triplets built via a "premise expansion" technique, using a reward combining grounding, Bellman-consistency, and premise-monotonicity terms. They then use Vθ as a reward to RL-train a conjecturer (Qwen3.6-27B) to produce more interesting Lean propositions, and separately run an inference-time iterative discovery loop (conjecturer = Claude 4.6, proving agent = Claude Code) that promotes the ten most-interesting verified theorems each round into the next round's premise set.

Key results:

• Vθ predicts proof difficulty more accurately than GPT-5.5 and Claude Opus 4.6 (Spearman ρ=0.912 vs. 0.776 and 0.815; MAE 20.2 vs. 31.0/34.3 proof lines).
• Utility (downstream compression value) correlates with interestingness at Spearman ρ=0.756 on mathlib.
• RL training raises mean ground-truth interestingness from 1.76 (base Qwen3.6-27B) to 7.58 (trained model), a per-area improvement of 2.10× (combinatorics) to 8.72× (number theory), beating Claude Opus 4.6 in every tested area.
• Only 30.6% of trained-model statements are judged substantially/fully contained in mathlib vs. 91.9% (base) and 92.5% (Claude), indicating more out-of-distribution generation.
• In the inference-time iterative-discovery ablation, promoting by interestingness beats promoting randomly, by raw proof length, or retaining everything, on quality, diversity, and "most interesting" judge comparisons.

Why it matters / caveats: Provides a computable, human-judgment-free proxy for mathematical value that can steer both training and inference-time theorem discovery toward genuinely novel results. Authors note proof-line-count can be a stylistic artifact of automation tactics, the metric captures only some notions of mathematical value (e.g., not cross-field unification), and it remains unclear whether the newly discovered theorems are actually useful for future proofs.

Problem: Standard scalars for allocating capacity in Transformer design/compression (#Params, #FLOPs) cannot distinguish architectures with identical budgets but different depth-width, head, or FFN allocations, and existing training-free NAS proxies require model instantiation and only support heuristic (non-optimal) black-box search.

Method: The paper defines Neural Spectral Capacity (NSC), a per-weight-matrix "spectral capacity" ψ(W) = ln det(I+WᵀW) motivated by treating each matrix as a linear Gaussian communication channel; under the Marchenko–Pastur law, ψ reduces to a closed-form function of matrix dimensions and initialization variance alone (no instantiation, data, or gradients needed), with per-head decomposition for multi-head attention and layer-wise summation across the network. Because NSC is layer-wise additive, the authors build NSC-DP, an exact dynamic-programming solver that treats architecture selection as a knapsack problem and returns the globally NSC-maximizing architecture under a resource budget.

Key results:

• On FlexiBERT (500 BERT architectures), NSC ranking correlation reaches τ=0.695 (vs. #Params 0.485, #FLOPs 0.552); under a 10%-parameter-matched control, NSC retains τ=0.505 while #Params collapses to τ=0.082.
• NSC computes in ~2ms per architecture (CPU) vs. 63–88s for training-free proxies (W-PCA, ZeroLM, SNIP, GradNorm) on GPU.
• NSC-DP discovers a Transformer-XL architecture with test PPL 23.087 on WikiText-103 (beating the human-designed baseline's 23.279) in 2.0 seconds, >400× faster than proxy-guided evolutionary search (883–965s).
• On AutoFormer-Tiny (ImageNet-1K), NSC-DP matches the 24-GPU-day AutoFormer oracle (75.276 vs. 75.308 Acc@1) in 0.03s.
• Pruning LLaMA-7B to 5.7B via the LoNAS supernet, NSC-DP achieves the best Avg8 commonsense-reasoning score (65.47%, +1.64pp over W-PCA's 63.83%) with no calibration data, in 0.46s — ~2,800× faster than the fastest baseline (GradNorm, 22 min) and ~5,900× faster than the strongest baseline (W-PCA, 45 min).

Why it matters / caveats: Offers a cheap, closed-form, and exactly-optimizable alternative to expensive proxy-guided architecture search and pruning, with claimed generality to MoE expert allocation and GQA/MQA grouping; the approach relies on random-matrix-theory approximations valid at standard initialization and is validated primarily on Transformer/CNN families studied in the paper.

Problem: Modern LLM agents cross trust boundaries (untrusted web/tool content, privileged instructions, persistent memory, privileged tool execution) with no mandatory, non-bypassable mediation layer analogous to a traditional OS kernel, leaving current governance stacks as bypassable, co-located application-level middleware.

Method: The paper proposes AgentKernel, an architecture organized into four pillars — Identity, Perception, Cognition, Execution — instantiated as a mandatory security kernel sitting between agent applications and the traditional OS/LLM. Identity uses a Global Agent Registry issuing Ed25519-signed Agent Identity Cards (AICs) with a kernel-held private key and TEE-backed key custody; Perception applies a four-layer graduated pipeline (Source Tagger, Rule-Based Filter, Semantic Firewall, Jailbreak/Multi-Turn Detector); Cognition applies lattice-based, item-level (rather than session-level) information-flow taint propagation to memory; Execution bridges semantic tool-call intent to syscall-level enforcement via eBPF hooks, process-tree monitoring, and a Plan–Trace Aligner, with permissions always computed as an intersection (deny-by-default) across developer/operator/context policies.

Key results: This is a systems/architecture position paper with no empirical benchmark results; contributions are a lifecycle diagnosis of infrastructure gaps (Table 1), five design principles derived from classical OS security, the four-pillar architecture and its cross-pillar security invariants (Table 2), and a qualitative, tiered comparison against orchestration frameworks (LangChain/AutoGen/CrewAI), agent runtimes (AIOS, Letta, SmythOS), governance platforms (Microsoft's Agent Governance Toolkit), and execution sandboxes (E2B, Anthropic's sandbox-runtime), arguing none provide mandatory, non-bypassable, full-lifecycle mediation.

Why it matters / caveats: Frames agent security as an OS-design problem rather than an add-on guardrail, potentially enabling operators to grant broader agent autonomy with a structurally enforced trust boundary; however, the paper provides no quantitative security evaluation, attack success rate reduction, or performance/overhead measurements, and explicitly discusses open questions (policy conflict resolution, manifest-vs-behavior mismatch, adversarial benchmarking of each pillar) as future work.

Problem: Building a voice-enabled AI teammate for a real-time battle-royale game requires simultaneously handling low-latency embodied perception/control in a constantly changing world and natural, speech-action-synchronized conversational interaction — a combination not addressed by prior game agents (which target autonomous play) or dialogue agents alone.

Method: Ally uses a dual-system architecture: System 2 is an event-driven LLM agent (small on-device SLM) that uses a bounded 16-tool interface (7 observation, 2 knowledge/memory, 2 action, 3 speech, 1 loop-control, 1 safety tools) to interpret player speech and game events and issue high-level actions with a ~5,000-token context budget and cache-friendly context layout; System 1 is a deterministic behavior tree executing those decisions at game-tick rate. Training uses a three-stage recipe: (a) SFT of an 8B intermediate teacher on Gemma 4 31B teacher rollouts (with prompts optimized via GEPA) plus DAgger-style teacher corrections of student-visited trajectories, (b) off-policy distillation of a 2B student via forward-KL to the 8B teacher's logits, (c) agentic on-policy distillation on student-generated trajectories. Safety uses a custom content taxonomy (unsafe categories plus an in-game-violence exception), targeted safety SFT, and runtime guardrails filtering speech before TTS.

Key results:

• Data collected from 1,046 participants across 38,956 gameplay sessions (28 days) at a Korean PC bang, averaging 14.1 min and 59 trajectories per session; correction sets totaled 313K examples added to an initial 464K-example corpus.
• GEPA prompt optimization raised teacher Event/Traject capability scores from 0.917/0.884 to 0.952/0.910, closing the gap to Claude Opus 4.8 (0.951/0.924).
• Distilled 2B student scores within overlapping confidence intervals of the 8B teacher on all 5 capability dimensions (e.g., Traject 0.902 vs. 0.910).
• Final safety-trained models reach 98.3–99.4% harmless response rate on broad-coverage benchmarks and 84.1–99.0% on production-representative dialogue (vs. 48.5–91.2% for earlier checkpoints), with over-refusal on benign inputs staying at 2.2–6.1%.
• On-device LM inference is 3.2× faster than cloud (median 0.80s vs. 2.54s); full spoken exchange completes in ~1.6s on-device vs. 3.4s cloud.
• In a live 141-country beta survey, positive responses exceeded negative by 25.1 percentage points on recommendation, and 50.0% of respondents framed Ally as a "teammate" or "companion."

Why it matters / caveats: Demonstrates a practical, deployed real-time conversational embodied agent architecture (System1/System2 split, on-device small models, iterative DAgger-style data collection) validated with real players at commercial scale; authors note the "boundary breached" safety condition remains the clearest residual failure mode (63.6% harmless response rate) and evaluation required iterative refinement because offline metrics initially diverged from player preference.

Problem: Existing approaches let VLMs guide robot manipulation only indirectly (predicting constraints/paths or writing programs) or give them a passive view of the scene, rather than a workspace in which they can directly observe, test, and correct actions before execution.

Method: World Action Agent (WAA) is a multi-agent harness with three properties: (1) automatically-selected "Contact views" that optimize visibility/framing/orthogonality around the current interaction region from the scene point cloud; (2) "action rehearsal," where each action is an editable proposal previewed via inverse kinematics and cuRobo motion planning (with an Imagination Agent iterating on infeasible poses) before commitment; (3) "in-view correction," where the agent drags reference points in a Contact view to issue bounded end-effector displacement corrections. A Skill Agent retrieves multimodal skills (procedure + reference images) evolved from expert videos/human teaching via a Learner–Editor–Reviewer pipeline (driven by GPT-5.5/Codex), and interaction traces are used to fine-tune a smaller Qwen3.5-9B (via LoRA) to pilot the same harness.

Key results:

• On LIBERO-Pro, WAA with skills evolved only from LIBERO-90 reaches 75.6% average success, beating ASPIRE (72.0%), RATs (43.8%), CaP-Agent0 (18.2–23.2%), π0.5 (12.8%), OpenVLA (0.0%), and Show-Harness (6.7%, same Gemini 3.7 Flash backbone).
• Zero-shot WAA (no skills) reaches 28.9% average vs. Show-Harness's 6.7% with the identical backbone; evolved skills raise this from 28.9%→43.3% (seed skills)→75.6%.
• WAA is more efficient than Show-Harness: 31 model calls/150s per episode vs. 120 calls/874s ($0.1996 vs $0.5021 API cost).
• Skills learned only in LIBERO transfer to robosuite without further learning: WAA reaches 100% on cube lift/stack and 100% on restack with LIBERO skills (vs. 60% without), beating CaP-Agent0+RATs (63.3% average).
• Replacing simulator point clouds with fused RGB-D or VGGT reconstruction only drops average success to 71.1%/68.9% (from 75.6%).
• Fine-tuning Qwen3.5-9B on 1,774 harness tool calls raises its success from 0.0%→55.0% in-domain and 1.7%→43.3% out-of-domain.

Why it matters / caveats: Shows that giving a general-purpose VLM a rehearsable, correctable visual action workspace (rather than fine-tuning it into a VLA or having it write code) preserves generality while achieving state-of-the-art manipulation success and transfers/distills efficiently. Authors note performance remains bounded by the VLM backbone's multi-view integration ability, and episodes still require tens of model calls, motivating further work on smaller distilled pilots.

Problem: RL post-training for joint audio-video diffusion generators is hampered by entangled multimodal rewards, high memory cost of jointly optimizing both modality towers, and unfair synchronization-reward comparisons caused by varying counterpart difficulty.

Method: AV-GRPO extends Flow-GRPO to two-tower audio-video diffusion models (built on LTX-2.3, 22B) via "modality-anchored rollouts": one modality's full denoising trajectory (audio or video) is fixed as an anchor while G trajectories of the other (target) modality are sampled, so the anchor reward cancels out under group-relative advantage normalization and only target-quality/alignment plus synchronization-vs-a-fixed-counterpart remain. It adds trajectory locking and tower freezing (only the target tower is backpropagated/updated, alternating every 4 steps), modality-specific reward compositions (VideoAlign/CLIP/DeSync for video; Audiobox Aesthetics/CLAP/DeSync for audio) and hyperparameters (noise strength aV=0.02 vs aA=0.8), plus Adaptive Noise Clipping for stable SDE sampling and a reweighted policy/KL objective for late denoising steps (following LongCat-Video). The authors also build 5DAV, a 5,760-prompt dataset spanning 288 orthogonal categories along 5 decoupled dimensions (semantic hierarchy, sound source, sync difficulty, temporal complexity, instruction granularity).

Key results:

• On JavisBench, full fine-tuned AV-GRPO improves Audio Quality from 5.097 (LTX-2.3 base) to 5.798, CLAP from 0.408 to 0.468, DeSync from 0.757 to 0.607, and JavisScore from 0.183 to 0.222.
• On VABench, Lip Sync rises from 1.351 (base) to 1.646 and DeSync drops from 0.800 to 0.542.
• Outperforms GDPO baseline on nearly all metrics (e.g., AV-IB 0.247 vs 0.224, JavisScore 0.222 vs 0.202).
• Enables full-parameter post-training of the 22B model on 8 NVIDIA A800 GPUs (previously memory-prohibitive with joint two-tower updates).
• Ablations show alternating every 4 steps is near-optimal, and the 5DAV dataset outperforms VGGSound under identical training settings.

Why it matters / caveats: Demonstrates that anchoring one modality and freezing its tower turns an entangled joint audio-video RL problem into tractable conditional subproblems with theoretical convergence guarantees (proven via Gibbs-sampling contraction argument), making full-parameter RLHF-style post-training feasible for large joint generators. Some metrics (e.g., LoRA's Visual Quality, full model's VABench visual realism) slightly regress relative to the base model, showing tradeoffs remain.

Problem: Existing few-step autoregressive video diffusion distillation (DMD-based) requires a heavy frozen teacher plus an online critic alongside the generator, making post-training memory- and compute-expensive.

Method: ViRDM adapts Representation Distribution Matching (RDM, previously used for one-step image generation) to few-step causal video generation, matching generated video populations against a fixed, precomputed reference distribution in a frozen V-JEPA 2.1 ViT-L/16 + SigLIP2 text-encoder joint representation space via MMD, eliminating the teacher and critic entirely. To make this memory-feasible, it uses consistency-style sampling with a stochastically sampled single "clean-exit" per denoising step (à la Self Forcing) so only one exit's graph is backpropagated, stages vector-Jacobian products so the representation encoder, VAE decoder, and generator backward graphs never coexist in memory, and swaps the heavy Wan VAE decoder for a lightweight TAEW2.1 decoder in the gradient path. It further establishes that small fresh-generated batches (B=64) suffice, causal-ODE initialization is required (bidirectional or non-causal starts fail), and adds a one-sided flow-based (RAFT optical-flow) dynamics regularizer to fix an under-constrained-motion failure mode of pooled video representations.

Key results:

• Reaches 84.87 VBench Total (vs. previous best few-step causal baseline Causal Forcing's 84.51, +0.36), with 85.82 Quality and 81.09 Semantic, using only 20 generator updates.
• Full post-training: 16 A100 GPU-hours vs. Self Forcing's 176 GPU-hours; peak memory 48.3 GB/GPU vs. 77.1 GB/GPU; training time 2 hours vs. 22 hours.
• Dynamics regularizer raises Dynamic Degree from 48.61 to 72.02 while changing non-dynamics VBench dimensions by <0.2 points.
• User study: ViRDM preferred over CausVid/Self Forcing/Causal Forcing in 40.4% (alignment) and 43.0% (visual quality) of comparisons; 85.6% preferred over its own no-dynamics-regularizer variant on dynamics judgments.
• Extends to 1-2 step causal and 1/2/4-step bidirectional generation with competitive Total/Quality scores.

Why it matters / caveats: Shows a resource-intensive three-network distillation pipeline can be replaced by generator-only post-training against an offline target distribution, substantially cutting compute while improving quality. Bidirectional (non-causal) initialization causes severe drift (Total drops to 65.80), so RDM can refine but not create causal transport from scratch — causal-adapted initialization remains a prerequisite.

Problem: Whether Jev, a model trained via "reinforcement learning for calibrated decisions" (RLCD) that answers typed questions with calibrated probabilities in a single call, can detect diverse AI alignment failures (sycophancy, jailbreaks, deception, prompt injection, etc.) had not been measured, unlike existing detectors that spend a full decoding pass per criterion.

Method: The authors build RLCDA LIGN B ENCH, covering 10 failure types across 44 benchmarks, 7,193 detection instances from five 2–7B open target models (Qwen3.5-2B, Phi-4-mini, Gemma-2-2B, Llama-3.2-3B, Olmo-3-7B), labeled by each benchmark's own reference scorer (rule, LLM judge, or multi-turn grader) and, on two benchmarks, by humans. They separately vary "what Jev is asked" (a generic per-benchmark template question in N OUL/C HOICE/S CORE answer types, vs. targeted questions naming the labeled behavior) and "what Jev sees" (canonical state = target's input+output, vs. context variants adding references like the user's belief, injected instruction, or secret lists). A split-half protocol (select strategy on one half of items, score on the other) removes selection inflation, and metrics include AUROC, F1, ECE, and Cohen's κ against human labels.

Key results:

• A single generic N OUL question reaches median AUROC 0.886 [0.821, 0.952] zero-shot across 31 benchmarks, beating TF-IDF/length baselines on 25 of 31 (median +0.132 AUROC, sign test p=9×10⁻⁴).
• Targeted wording adds only +0.006 [−0.004, +0.015] AUROC out-of-sample (in-sample selection would overstate this by 0.008).
• Deployable context (info a real monitor could hold) helps on only 1 of 7 benchmarks; label-key fields (part of the label definition, e.g. PrivacyLens's secret list) give larger gains (e.g., 0.79→0.95) but reflect the label construct rather than the failure itself.
• On StrongREJECT human labels, Jev matches the reference GPT-4o-mini scorer's agreement (κ=0.809 vs 0.811) and ranks better (AUROC 0.971 vs 0.929).
• Median per-benchmark ECE is 0.168 (vs null 0.074) — Jev ranks well but is miscalibrated on base rates; a 10-label threshold raises median F1 from 0.706 to 0.793.
• Costs $0.30 for a full pass over 19 judge-scored benchmarks vs. $18.96 for LLM judges (63× cheaper); Jev's confident disagreements exposed label defects in 3 benchmarks and unobservable-label issues in 4 more.

Why it matters / caveats: Suggests a single cheap calibrated-probability model with generic questions can rival specialized/generative judges as an alignment-failure screen and can even help audit benchmark label quality. Limitations stated by authors: covers only one RLCD model (jev-1.13.0), English benchmarks, 2–7B targets, and mostly scorer (not human) labels; per-generator calibration varies (κ dropped to 0.668 vs scorer's 0.790 on GPT-3.5 outputs).

Problem: World-action models for robot control predict dense future video frames during training (wasting compute on largely static/unchanged content and coupling action-relevant dynamics to nuisance appearance variation) and still require processing the full current observation through a heavy video expert at every inference step, bottlenecking few-step action generation.

Method: DeltaWAM decomposes world-action modeling into three token streams — a dense anchor stream (reference observation, encoded by a network initialized from Wan2.2-TI2V-5B and adapted via LoRA r=64), a sparse delta stream (single-token per-frame-pair visual transitions from a frozen delta encoder, e.g. DeltaTok or a latent-action model), and an action stream — jointly trained with separate flow-matching objectives (L∆ and La) combined as Ljoint = λ∆L∆ + λaLa. Three architectural variants (Anchor-Shared, Separated, Action-Shared with Dual-Stream Residual Experts) explore different representation/computation sharing. Streaming Delta Memory (SDM) caches layer-wise anchor context and incrementally updates it with only newly observed compact deltas (rather than reprocessing full frames), with periodic anchor refreshes and an Asynchronous SDM Update to overlap context construction with action execution.

Key results:

• On RoboTwin (10 tasks), DeltaWAM+SDM raises average success from Fast-WAM's 81.3%/75.8% (clean/randomized) to 85.4%/83.9%.
• The three architectures reduce training FLOPs by 17.78–23.77% vs. Fast-WAM; Anchor-Shared performs best overall.
• SDM reduces visual/reference KV computation by 71.97%, cutting one-step inference latency by 36.57% and FLOPs by 31.55% at comparable success rates.
• Ablations: removing the dense anchor entirely collapses success to 32.6%/35.2%; LoRA rank 64 vs 8 mainly improves randomized robustness (70.8%→75.4%).
• Real-world (dual-arm RealMan RM75-6F, 3 bimanual tasks, 20 trials each): DeltaWAM achieves highest overall success rate 41.67% (vs π0.5's 38.33%, Fast-WAM's 35.00%) and highest normalized progress 72.14%.

Why it matters / caveats: Shows that replacing dense future-frame prediction with sparse visual "deltas" plus a streaming KV memory improves both robustness to visual randomization and efficiency simultaneously, rather than trading one for the other. Authors note the delta encoder itself adds ~3.05 TFLOPs/sample training overhead and 0.457 TFLOPs/chunk inference overhead, partially offsetting savings — motivating future lightweight delta encoders; SDM also trades off clean-setting performance (86.4%→82.8%) for randomized-setting gains in one evaluation panel.

Problem: Full-reference image quality metrics (MS-SSIM, LPIPS, DISTS, etc.) align better with human perception than sum-of-squared-errors (SSE) but cannot be used "in-loop" in block-based video codecs because they don't decompose block-wise and require the fully decoded image.

Method: Building on prior metric-quadratization theory, the paper approximates any differentiable FR-IQA metric by an Input-Dependent Quadratic Distortion (IDQD) whose quadratic form is the Hessian of the metric evaluated at the source image (a first/second-order Taylor expansion around x̂=x). Since the full Hessian is too large and non-block-separable, they estimate its block-diagonal or diagonal via stochastic Hessian-vector products (Rademacher probes, computed with one forward + two backward automatic-differentiation passes), using a lower-variance Gauss-Newton form (H(x)=2J(x)ᵀJ(x)) for squared-residual metrics like LPIPS/DISTS/WD, plus Monte Carlo "smoothing" (averaging Hessians over Gaussian-perturbed inputs) to stabilize noisy neural-network gradients. The resulting block-wise IDQD replaces SSE directly in VVC (VTM 23.8) RDO for partitioning, prediction mode, transform selection, and RDOQ, with a derived Lagrangian λm = λs·E[tr Q(x)]/np to control the target-metric/PSNR trade-off — all without any decoder changes.

Key results:

• Across 5 metrics (SSIM, MS-SSIM, LPIPS, DISTS, WD) on Kodak and CLIC, block-diagonal IDQD-RDO achieves BD-rate savings of 15.5–23.6% (Kodak) and 14.2–36.7% (CLIC) on the targeted metric versus SSE-RDO.
• Outperforms PerceptQPA baseline by up to 21.0% and outperforms a prior learned-codec bit-allocation-transfer method (Yang & Bajić) on the optimized metric (e.g., LPIPS BD-rate −17.63% vs. −8.33% under matched RGB-PSNR cost).
• Block-diagonal estimator consistently beats the pure-diagonal estimator on the targeted metric.
• Encoding complexity overhead is 10–30%; decoder is completely unchanged; Hessian estimation takes 1–10 seconds per image at m=256 probes, with m=64 retaining ≥83% of the gain at 1/4 the estimation time.
• SSIM/MS-SSIM Hessians are highly local (99% of row energy within the 8×8 tile), while LPIPS/DISTS have wider receptive fields, making the block approximation less exact for those but still beneficial.

Why it matters / caveats: Provides a general, standard-compliant (no decoder change) recipe to optimize video codecs directly for perceptual/learned FR-IQA metrics in-loop, rather than only via post-hoc QP offsets, generalizing beyond SSIM/WPSNR to any differentiable metric including learned ones. Some metric pairs are antagonistic (e.g., SSIM-optimized and DISTS-optimized maps degrade each other's target metric), and NN-based metrics require smoothing/Gauss-Newton tricks that add complexity.