AI papers — 2026-09-25

Problem: Video generation ("world") models frequently violate object permanence and solidity — letting objects vanish, teleport, or pass through solid barriers — and no benchmark existed to measure or train this specific capability in three-dimensional, video-to-video settings.

Method: The authors build WROP, a Blender-generated benchmark/training corpus of 150 hand-authored generators across six cognitive task families (three probing object permanence, three probing object solidity), yielding a 1.5M-sample video-to-video training corpus and a fixed 300-question human-evaluated exam. They fine-tune PWM-WROP, a 16B model derived from Cosmos3-Nano, for one epoch on this corpus (117-frame packed clips at 320×192) using a native PyTorch/AWS-Trainium2 training stack (PWM), changing only the training signal, not the architecture.

Key results:

• In a blind pairwise Bradley–Terry/Elo study across 14 video models (3 reference-to-video, 7 edit/transfer, 4 true-continuation), PWM-WROP ranks 1st among true-continuation models (Elo 1679.5) and 3rd overall.
• Top overall: Wan 3.0 Prime and MiniMax H3 (both reference-to-video), tied at Elo 1723.6.
• PWM-WROP beats the next-best continuation model, Grok Imagine (video-extend), by 224 Elo points (1457 vs. 1680).
• At the matched 320×192 evaluation resolution, PWM-WROP achieves the best LPIPS and MS-SSIM against the target video.
• The custom Trainium2 training stack reached 5.7s/step (batch 16, 288×512, 64 NeuronCores), down from an initial 15.1s/step.

Why it matters / caveats: Demonstrates that targeted, core-cognition-inspired synthetic training data can substantially close the object-permanence gap in continuation-style video world models without architecture changes. However, the compared systems differ in architecture too, so the performance gap cannot be attributed to fine-tuning alone, and solidity/collision (OS) tasks remain harder to improve than occlusion (OP) tasks.

Problem: Embodied agents lack the ability to use spatial (directional) audio cues — jointly with vision — to localize sound sources and navigate, an ability humans use effortlessly but that is largely unaddressed by existing omni-modal models and benchmarks.

Method: The paper introduces OmniEchoBench (a real-world benchmark with 2,972 QA pairs over 197 first-order-ambisonics (FOA) audio-visual scenes, plus a 900-sample navigation benchmark across 30 real scenes) and OmniEcho, a model built on Qwen3-Omni-30B-A3B. OmniEcho adds a separately pretrained FOA spatial encoder (5-channel log-mel + intensity + diffuseness input, aligned to CLIP text via SigLIP, then fine-tuned for query-conditioned localization) alongside the frozen native semantic audio tower; only the LLM and a projector are trained in the final integration stage.

Key results:

• On OmniEchoBench-QA (audio+vision), OmniEcho scores 28.5 overall accuracy vs. 18.5 for the Qwen3-Omni-30B-A3B backbone and 11.4 for the closest spatial-audio baseline (SO-7B).
• On the Cognitive Map sub-task, OmniEcho reaches 47.5% vs. 22.8% (SO-7B) and 22.3% (backbone).
• On OmniEchoBench-Nav, OmniEcho achieves 16.2% success rate (SR) / 11.5% SPL using only FOA audio guidance, versus 5.4%/3.9% for a SoundSpaces binaural baseline, and is within ~1.6–5.2 points of a text-instruction VLN baseline (InternVLA-N1) despite using audio only.
• Ablations show the frozen FOA encoder (vs. training it in Stage 3) and retaining the native audio encoder both contribute to the best overall QA score.

Why it matters / caveats: First work to jointly address spatial audio-visual QA and sound-guided navigation for embodied agents with real-world FOA recordings; shows spatial audio is a useful complementary signal but training relies heavily on simulated data with an acknowledged sim-to-real gap, and camera-rotation reasoning still depends strongly on vision rather than audio alone.

Problem: Long-horizon LLM agents suffer from "task-state contamination" — accepting unsupported assumptions, retaining outdated plans, or mistaking partial progress for completion — and existing language world models try to fix this by predicting (high-entropy, execution-dependent) tool observations, which is difficult and offers limited value once real feedback is available.

Method: The paper proposes the Agent-Editing World Model (AEWM), which instead models the effect of the agent's current reasoning-action pair rather than the environment's next observation. AEWM has two capabilities: Action Judge classifies a proposed decision as CRITICAL, EXPLORATORY, or NOISY; State Revision rewrites noisy reasoning-action pairs before execution. EditAct integrates both into inference (retain good decisions, revise noisy ones, execute in the real environment), and AEWM-RFT distills verified EditAct trajectories back into the base agent via rejection-sampling fine-tuning. Training uses mid-training (52B tokens) plus SFT (120K examples) across Search, Terminal, and Software-Engineering domains.

Key results:

• AEWM achieves 70.5% macro-F1 on a new 3,000-decision Action Judge benchmark, beating the strongest frontier baseline (DeepSeek-V4-Pro, 59.9%) by 10.6 points.
• EditAct improves average scores across six benchmarks (BrowseComp, DeepSearchQA, Terminal-Bench 2.0, Doc2Repo, NL2Repo, SWE-Bench Pro) by 3.2–6.7 points over the strongest baseline, depending on backbone size (Qwen3.5-4B/9B/35B-A3B).
• Qwen3.5-9B with EditAct (44.1 avg) surpasses Qwen3.5-35B-A3B with plain ReAct (42.2 avg).
• AEWM-RFT (no online AEWM guidance at inference) beats Self-RFT by 2.2–2.6 points across three domains, while reducing average turns by up to 30%.

Why it matters / caveats: Reframes what a "world model" should predict for agents — decision effects rather than raw observations — and shows this transfers across in- and out-of-distribution benchmarks. Gains on the strongest backbone (Qwen3.5-Plus) are smaller on Terminal/SWE, likely due to a capacity gap between the AEWM judge and a much stronger agent.

Problem: It is unclear whether morpho-syntactic categories like part-of-speech (POS) are encoded by individual, monosemantic Sparse Autoencoder (SAE) latents or by distributed, structured groups of latents in LLM representations.

Method: Using LLaMA-3-8B and a pretrained SAE (EleutherAI sae-llama-3-8b-32x, layer 30 residual stream), the authors extract token-level SAE activations on the UD English GUM treebank and a custom controlled dataset. They run one-vs-rest L1-logistic-regression probes per POS tag, use probe coefficients for feature-salience ranking, compute a per-category "coverage" curve to find the minimal latent set reaching 95% activation coverage, then validate the resulting compact latent groups on held-out data and a controlled synthetic dataset.

Key results:

• POS categories are linearly recoverable from SAE activations with high F1; closed classes and punctuation are easiest, nouns/verbs are the best-performing open classes.
• A compact set of only 498 latents (12% shared across 2+ POS) yields multi-class classification performance comparable to the full 130,246-dimensional SAE representation.
• Open-class POS require more latents (larger k95) than closed-class POS, confirming a compactness gradient tied to lexical variability.
• On held-out data, per-category recall is consistently ≥0.95, but a Distinctiveness score averages only D=0.27 (chance = 0.06), showing latent groups are stable but only partially category-specific.
• Randomizing labels drops performance to 0.54 accuracy/0.42 macro-F1 (vs. 0.88/0.97 for real labels), and randomly replacing latents from the compact set collapses accuracy from 0.87–0.89 to 0.23–0.24 at 0% overlap.

Why it matters / caveats: Shows SAEs localize linguistic structure in a distributed, category-dependent way rather than via one-latent-per-category monosemanticity — nuancing claims about SAE interpretability. The controlled-dataset pseudo-multilabel evaluation shows high recall but low precision, and a "first-token" confound latent group was identified and had to be controlled for.

Problem: Building reliable mobile-planning agents for complex, long-horizon real-world tasks is limited by the cost and scale of real-device interaction, and by the difficulty of coordinating data production, training, and runtime support as agent capability evolves.

Method: The paper presents a closed-loop "AI-for-AI" framework comprising three stages: AI for Data (agent-driven task construction, trajectory collection, and feedback-refined data composition across three complementary environment backends — programmatic sandbox, LLM-simulated, and real-device); AI for Training (a planning-oriented cold start plus hybrid-environment online agentic RL using Competence-Aware Reward-and-Advantage Engineering, CARE, an LLM-based controller that adapts reward schedules to the model's evolving competence); and AI for Harness (a unified Model-Harness runtime combining Skills, persistent Memory, and execution feedback, with AI-assisted diagnosis driving revisions, all under human review before deployment). The resulting system, Qwen-Planner-Agent (27B), couples the trained Planner Model with this Harness.

Key results:

• On MobilePA-Bench, Qwen-Planner-Agent achieves the highest overall score among evaluated frontier models/agent systems (77.1), ahead of GPT-6 Astra (76.8), Claude Fable 5 (75.7), Seed 2.1 Pro (74.5), and others (Claude Opus 5 at 71.8, Qwen3.8 Max at 64.9).
• It shows strong capability breakdowns: Tool Use 77.79, Memory 76.33, Skills 93.25, Sub-agent coordination 68.54.
• It achieves this performance at an estimated per-task output cost lower than the commercial LLMs compared, including thinking tokens.
• The Planner Model generalizes to non-mobile general agentic benchmarks while largely preserving general capabilities, and ablations confirm model–harness co-evolution contributes to gains.

Why it matters / caveats: A practical case study in using AI systems to help build and iteratively refine other AI agent systems (data, training, and runtime co-evolution) rather than just a static model release; specific numeric details of the CARE reward-schedule mechanism and full ablation breakdowns are deferred to appendices not captured here.

Problem: Single-policy ReAct-style deep-search agents conflate heterogeneous skills (planning, evidence use, synthesis) in one policy and suffer from unbounded context accumulation over long search horizons — the paper reports over 59% of 64K-context ReAct trajectories on BrowseComp fail to terminate before context exhaustion.

Method: IterSynth is a role-decoupled, summary-based workflow in which a single shared-parameter LLM alternates between a Planner role (observes the question and a compact evolving summary, decides to search or answer) and a Synthesizer role (integrates newly retrieved evidence into the persistent summary, resolving conflicts and filtering noise), formalized as a dual-role augmented MDP. Training uses cold-start SFT on the Planner/Synthesizer protocol followed by Role-Decoupled Policy Optimization (RDPO), which combines terminal outcome rewards with turn-level rubric scores and computes group-relative advantages separately for each role.

Key results:

• IterSynth-8B reaches an average score of 50.7% across five long-horizon deep-search benchmarks (GAIA-text-only, xBench-2505, xBench-2510, BrowseComp, BrowseComp-ZH), beating the strongest prior ≤8B agent by +4.2%, and remaining competitive with several 30B-scale agents at under a third of the parameters.
• Role-decoupled RL matters: outcome-only GRPO raises the SFT baseline from 44.1% to 48.9%, while RDPO raises it further to 50.7%.
• As a zero-shot prompting paradigm applied to frontier proprietary models (Claude-4.5-Opus, DeepSeek-V3.1), IterSynth consistently beats ReAct and IterResearch, with up to +10.0% over ReAct on BrowseComp-ZH.

Why it matters / caveats: Shows role decoupling plus a persistent, learnable summary state can outperform both larger single-policy agents and separate multi-agent systems without added parameter count, and transfers as a model-agnostic prompting strategy. The gains from role-specific credit assignment are most pronounced on exploration-intensive benchmarks specifically.

Problem: Generalized task and motion planning (TAMP) — solving long-horizon manipulation problems with tightly coupled discrete and geometric/kinematic/dynamic decisions across varying instances — normally requires substantial hand-designed, TAMP-specific engineering (predicates, operators, samplers), and it was unclear whether general-purpose coding agents could automate this without such scaffolding.

Method: The authors give off-the-shelf coding agents (Claude Code with Opus 5, and Codex with GPT-5.6 Sol / GPT-6 Astra) only a task description and simulator access (reset/step), and let each agent, within a fixed synthesis budget, write and test Python programs (using only NumPy/SciPy — no TAMP libraries) that generalize across problem instances with varying object counts. The resulting program is then frozen and evaluated on 100 held-out instances per run, across 28 environments from KinDER and PDDLStream (980 generated programs, 98,000 evaluation episodes total), compared against hand-engineered TAMP planners, one-shot LLM generation, and an LLM-based generalized-planning baseline (LLMGenPlan).

Key results:

• On the 16 environments where a hand-engineered planner exists, all three agent configurations outperform it in mean success: Claude Code averages 82% vs. the planner's 47%; Codex with GPT-6 Astra averages 95%; Codex with GPT-5.6 Sol averages 56%.
• As object counts grow, agent-written programs maintain higher success while using roughly an order of magnitude less computation per instance than the planner.
• All three agents also beat one-shot generation and LLMGenPlan in mean success across all 28 environments.
• Interaction logs show agents discovering unexpected but successful strategies (e.g., non-prehensile pushing/sweeping maneuvers) absent from prior published solutions on these benchmarks.
• Failures remain concentrated in dynamic 3D environments requiring sweeping/pouring of many small objects.

Why it matters / caveats: Suggests coding agents can substitute for much of the domain-specific engineering that generalized TAMP methods traditionally require, and can discover physically plausible strategies not seen in prior literature — useful evidence for agentic physical reasoning, though restricted to simplified, fully-observed, object-centric simulation environments rather than real robots with perception.

Problem: As text-to-video generators scale to 30-second, complex, multi-shot outputs, prompt enhancers built on forward rewriting (enriching a user request into a longer description) produce outputs that follow a synthetic rewriting distribution mismatched with the video-grounded captions the video generator was actually trained on, and struggle to keep user requirements consistent across all shots of a long cinematic plan.

Method: WanPE is a 397B-parameter prompt-enhancement model trained via "video-grounded reverse construction": rather than forward-expanding a user request, the pipeline captions ~1.05M real-world video clips into hierarchical, shot-level cinematic conditions, then uses an LLM (with few-shot demonstrations) to reconstruct a plausible compatible user request from each caption — inverting the usual supervision direction so SFT targets match the video generator's real training distribution. On top of this SFT, Semantic-Consistency GRPO (SC-GRPO) further optimizes the model with a nine-dimension reward (style, subjects, actions, dialogue, sound, camera, lighting, spatial relations, scene) scored by Qwen3.7-Max, penalizing omissions, alterations, and cross-shot inconsistencies.

Key results:

• Evaluated on WanPEval (a new 5–30s human-annotated testbed, ~11K blind pairwise video assessments), WanPE-397B improves human preference over raw user prompts by 10.66–18.84 points at 5–15 seconds, and by 50.86 points at 30 seconds.
• WanPE leads all evaluated commercial prompt-enhancement offerings at 5–15 seconds and remains competitive with Seedance 2.5 at 30 seconds.
• Ablations show reverse construction clearly outperforms forward rewriting, and SC-GRPO improves semantic consistency by 18.6–23.3 points across model scales (4B–397B).

Why it matters / caveats: Reframes prompt enhancement as director-level cinematic planning rather than cosmetic detail-adding, closing a training/inference distribution mismatch that becomes increasingly important as video generators handle longer, more complex conditioning. Gains are demonstrated specifically when paired with Wan3.0's video generator; the paper notes the approach "transfers across video generators after format adaptation" but the bulk of quantitative results are Wan3.0-specific.

Problem: Standard capacity-allocation tools for Transformer design/compression (#Params, #FLOPs) cannot distinguish between architectures with the same budget but different depth-width tradeoffs, head allocation, or FFN ratios, and existing training-free NAS proxies require instantiating a randomly-initialized network and are not exactly optimizable (only searchable via black-box methods).

Method: The authors propose Neural Spectral Capacity (NSC), a closed-form scalar computed directly from an architecture's specification (no model instantiation, data, or gradients). NSC is grounded in treating each weight matrix as a linear Gaussian communication channel and taking its mutual-information capacity (a sum over log(1+σᵢ²) of its singular values); under standard random initialization, the Marchenko–Pastur law renders this quantity's expectation a deterministic closed-form function of the matrix's dimensions and initialization variance alone. Because per-matrix capacity is additive across layers, the authors design NSC-DP, an exact dynamic-programming (bounded-knapsack) solver that finds the architecture globally maximizing NSC under a resource budget.

Key results:

• On FlexiBERT, NSC achieves Kendall τ=0.505 in ranking architectures whose #Params differ by <10%, versus #Params collapsing to τ=0.082 in the same regime — outperforming #Params, #FLOPs, and other training-free proxies.
• NSC-DP discovers a Transformer-XL architecture on WikiText-103 that beats the human-designed baseline, running in 2 seconds — over 400× faster than training-free proxies paired with heuristic search.
• Pruning LLaMA-7B to 5.7B via NSC-DP over the LoNAS supernet produces the best model across eight commonsense-reasoning tasks without any calibration data, ~5900× faster than the strongest training-free baseline.
• The Marchenko–Pastur closed form matches the exact SVD-based value with <0.4% relative error at hidden dimension 128, and ~10⁻⁴ error at 1024; on the LoNAS-LLaMA-7B supernet it matches exactly (τ=ρ=1.0000) across all 129 Pareto-optimal subnets with 720× compute savings.

Why it matters / caveats: Provides a data-free, instantiation-free scalar that both ranks architectures better than size/compute metrics and admits exact (not heuristic) resource-constrained optimization — useful for both pretraining design choices and post-hoc structured pruning. The correlation with trained performance is a "deterministic equivalent" tied to standard random initialization schemes, so its validity for non-standard initializations is less established.

Problem: Modern LLM agents routinely cross trust boundaries (untrusted web/repo content, privileged system instructions, persistent memory, privileged tool calls), but today's governance/guardrail tools are application-level middleware that share a process trust boundary with the agent itself, so no mandatory, non-bypassable mediation layer exists for identity, input, memory, or execution.

Method: The paper is a position/architecture paper proposing AgentKernel, an agent-OS layer organized into four pillars — Identity (cryptographic enrollment, capability chains, mutual attestation for delegation), Perception (a graduated multi-layer pipeline that labels untrusted content before it enters the LLM context), Cognition (information-flow-controlled, taint-aware persistent memory), and Execution (binding declared tool permissions to actual host behavior via eBPF hooks and process-tree monitoring) — that sits between agent applications (e.g., Claude Code, OpenClaw) and the traditional OS kernel, forming what the authors call an "AI-Native OS."

Key results: Not stated (the paper presents a lifecycle diagnosis, architecture and design principles, and a structured/qualitative security analysis and comparison against existing harness tiers — orchestration frameworks, agent runtimes, governance platforms, execution sandboxes — rather than quantitative benchmarks or empirical performance/latency numbers).

Why it matters / caveats: Articulates a clear conceptual gap (mandatory, non-bypassable, OS-level mediation for agent semantics analogous to classical OS security) and a mapping of the current harness ecosystem's structural weaknesses (fragmentation, blurry trust boundaries, non-mandatory enforcement). As the paper contains no empirical evaluation of AgentKernel itself (e.g., measured overhead, attack success-rate reduction, or a working implementation's benchmarks), its practical effectiveness and deployment cost remain unverified by this paper.

Problem: Building an AI teammate for a real-time multiplayer game requires combining real-time embodied gameplay under strict latency constraints with natural voice interaction, and keeping the agent's speech synchronized with its actions as the game world continuously changes — a combination not addressed by prior game agents that focus purely on autonomous play.

Method: PUBG Ally ("Ally") uses a System 1/System 2 architecture: an LLM agent (System 2) interprets player speech, queries a bounded tool interface for relevant game state/memory, decides what to say, and issues high-level actions, while a deterministic behavior-tree layer (System 1) executes those intents at game-tick rate for latency-critical movement/combat/recovery. Training data comes from real human-Ally matches (38,956 sessions, 1,046 participants) using teacher demonstrations (31B model with GEPA-optimized prompts) followed by DAgger-style teacher correction of student rollouts, iteratively distilled down to an 8B intermediate teacher and a deployable 2B on-device student via on-policy knowledge distillation.

Key results:

• Model/pipeline compression plus context compaction enable on-device deployment: a spoken exchange completes in ~1.6s on-device versus 3.4s with a cloud configuration.
• In a live-service beta survey spanning 141 countries, among respondents whose play with Ally was confirmed in game records, positive responses exceeded negative by 25.1 percentage points when asked if they'd recommend Ally.
• 18.5% of respondents described Ally as a "teammate" and 31.5% as a "companion," together 50.0% of respondents choosing a relational framing over a purely functional one.
• Data collection spanned 28 collection days at a rented Korean gaming cafe with 38,956 total sessions.

Why it matters / caveats: First (to the authors' knowledge) conversational embodied AI teammate deployed in a commercial live battle-royale game with on-device reasoning and speech; the reported "positive minus negative" recommendation gap and framing percentages come from a self-selected survey of beta participants rather than a controlled comparison, so absolute quality claims should be read as directional evidence from a live deployment rather than a benchmark result.

Problem: Existing ways of using vision-language models (VLMs) for robot manipulation either use them indirectly (predicting constraints/paths for a downstream policy, or writing programs) or give them a passive view of the scene to choose actions from, without letting the VLM preview and revise its own actions before they take irreversible effect in the physical world.

Method: World Action Agent (WAA) is a multi-agent harness in which a VLM pilots a robot through basic tool calls within a "visual action workspace" with three properties: automatically-selected contact views centered on the current interaction; action rehearsal, where each proposed action is an editable, previewable proposal (optionally refined by a separate Imagination Agent) before committing; and in-view correction, closing the loop between observation, rehearsal, and execution. A Skill Agent retrieves reusable multimodal skills that are themselves evolved (via a Learner/Editor/Reviewer loop) from expert videos and human teaching, and WAA's own interaction traces are used to fine-tune smaller VLMs (e.g., Qwen3.5-9B) to pilot the same harness directly.

Key results:

• On LIBERO-Pro, WAA using skills evolved only from LIBERO-90 reaches a state-of-the-art 75.6% average success, above ASPIRE's 72.0%.
• The same evolved skills transfer to robosuite without any further learning.
• Fine-tuning Qwen3.5-9B on WAA's harness interaction traces raises its out-of-domain success from 1.7% to 43.3%.
• WAA outperforms end-to-end VLA models, code-as-policy agents, and a visual-harness baseline using the same backbone.

Why it matters / caveats: Demonstrates that giving a general-purpose VLM a rehearsable, interaction-centered visual workspace — rather than fine-tuning it for action prediction — can preserve general reasoning while achieving state-of-the-art manipulation success, and that harness interaction traces are themselves a viable distillation signal for smaller pilot models. Results are reported on simulation benchmarks (LIBERO-Pro, robosuite); no real-robot hardware results are given in the sections reviewed.

Problem: Evaluating AI systems' ability to genuinely explore (form hypotheses, design experiments, iterate) is hard because tasks must be simultaneously new to the system (so success can't come from pretraining recall) and fully verifiable by the evaluator — a combination existing benchmarks fail to satisfy jointly.

Method: ExplorationBench provides two deterministic, executable "Alien World" sandboxes — AlienCode (a small programming language, 31 discovery targets) and AlienLogic (a natural-deduction system, 24 discovery targets) — whose rules deliberately contradict both a provided flawed manual and models' pretraining priors. A system starts from the flawed manual and fixed worked examples, then runs four rounds of self-chosen probes (programs or proofs) against the environment, receiving exact deterministic feedback; at each milestone it is tested tool-free on 70 held-out tasks (graded by an interpreter or proof-checker) and reports the rules it believes it has found, isolating "discovering a rule" from "using it."

Key results:

• Before any exploration, no AlienCode trajectory exceeds 15.7% held-out accuracy (confirming resistance to recall); after four exploration rounds, the best AlienCode trajectory reaches 87.6%, versus only 0.5–11.0% for the same number of model turns without environment feedback.
• Letting a system choose its own probes matters: in AlienCode, replaying a system's own best probes without letting it choose them (hindsight exploration) lowers accuracy for 9 of 10 systems versus autonomous exploration.
• A system's exploration rank on AlienCode barely predicts its rank on AlienLogic (Spearman ρ=0.35).
• Discovering vs. using a rule diverge: tasks whose required rule a system states correctly are still solved only 70.9% of the time; in AlienLogic, simply being told the rules (93–97% accuracy) beats every system's own exploration.
• Exploration is unreliable: trajectories of the same system under the same budget end up to 72.8 accuracy points apart, and 6 of 30 AlienCode trajectories end at least 3 points below an earlier milestone (regression during continued exploration).

Why it matters / caveats: Provides a genuinely recall-resistant, exactly-verifiable framework for measuring exploration as a distinct capability from static knowledge/reasoning benchmarks, and finds that even the strongest systems explore unreliably and don't always apply what they've correctly identified. Only ten frontier AI systems were evaluated, each with three trajectories per sandbox, so per-system rankings carry meaningful trajectory-to-trajectory variance.

Problem: Detectors used to screen deployed LLMs for alignment failures are typically generative judges (one decoding pass per criterion) or single-label classifiers (one probability per call), making multi-criterion or multi-angle detection expensive; and it was unknown whether a model trained to answer many typed questions with calibrated probabilities in one call ("Jev," trained via reinforcement learning for calibrated decisions, RLCD) could detect alignment failures, many of which are relational (defined against a reference the response alone may not reveal, e.g., the user's belief or an injected instruction).

Method: The authors build RLCDAlignBench, spanning ten failure types (sycophancy, jailbreaks, deception, prompt injection, hallucination, privacy violation, social bias, reward hacking, concealing uncertainty, power seeking) across 44 benchmarks, 7,193 detection instances, and five open 2–7B target models. They vary two factors independently — what Jev is asked (generic template question vs. targeted wording naming the behavior; NOUL/CHOICE/SCORE answer types) and what Jev sees (which fields of the interaction state are included) — and evaluate Jev's single-call probability outputs against each benchmark's reference-scorer or human labels, using a split-half protocol (question selection on one half of items, scoring on the other) to avoid overstating gains from search.

Key results:

• A single generic question, scored zero-shot as a probability, reaches a median AUROC of 0.886 across 31 benchmarks with a NOUL form, beating supervised TF-IDF/length baselines on 25 of them.
• Targeted question wording adds only +0.006 [-0.004, +0.015] AUROC out of sample — wording matters little.
• What the state/label contains matters much more: giving Jev a reference that defines the label produces large gains (e.g., PrivacyLens 0.79→0.95).
• Against human labels on StrongREJECT, Jev's generic question matches the reference scorer's agreement with humans (Cohen's κ 0.809 vs. 0.811) while ranking better.
• Jev's confident disagreements with existing benchmark labels exposed label-changing defects in three benchmarks and revealed labels the given state literally cannot determine in four more.
• A full pass over 19 judge-scored benchmarks costs $0.30 with Jev versus $18.96 for LLM judges (GPT-4o(-mini), Claude Haiku) at list prices — a 63× cost reduction.
• Calibration is imperfect: median expected calibration error (ECE) is 0.168 against a null of 0.074, because Jev's mean probability misses each benchmark's base rate, so thresholds still need a small labeled calibration set.

Why it matters / caveats: Shows a single-call, calibrated-probability model can rank most alignment failures nearly as well as expensive generative judges at a fraction of the cost, and can even help surface benchmark label defects — but it needs task-specific threshold calibration (not just ranking) and its probabilities are not well-calibrated as thresholds out of the box.

Problem: Existing world-action models (WAMs) for robot control predict dense future video frames during training, redundantly modeling mostly-unchanged scene content and coupling action-relevant dynamics to nuisance visual factors (lighting, texture), while at inference every control step still requires processing the complete current observation through a heavy video expert, bottlenecking few-step action generation.

Method: DeltaWAM decomposes world-action modeling into three token streams — a dense anchor stream (a reference observation encoded by an Anchor Network initialized from a pretrained video generator), a sparse delta stream (compact tokens from a frozen delta encoder capturing only inter-frame visual change), and an action stream — jointly trained via flow matching, with three architectural variants (Anchor-Shared, Separated, Action-Shared with Dual-Stream Residual Experts) differing in how they share the pretrained backbone. Streaming Delta Memory (SDM) then caches the layer-wise KV context from a dense anchor and incrementally updates it using only the compact observed deltas rather than reprocessing full frames, with periodic anchor refreshes and asynchronous updates overlapping with action execution.

Key results:

• On RoboTwin, DeltaWAM with SDM improves average success over the Fast-WAM baseline from 81.3% to 85.4% in the clean setting, and from 75.8% to 83.9% under visual randomization.
• The three DeltaWAM architectural variants reduce training FLOPs by 17.78–23.77% versus the baseline.
• SDM reduces visual-context KV computation by 71.97%, cutting one-step inference latency by 36.57% and inference FLOPs by 31.55%, at comparable performance.
• In real-world bimanual manipulation across three tasks, DeltaWAM achieves the highest overall success rate (41.67%) and normalized progress (72.14%) among evaluated policies, versus 35.00% success for π0.5 and 28.7% for O-VLA (mean SR metric from the paper's summary figure).

Why it matters / caveats: Directly targets the redundancy of dense future-frame prediction in world-action models, improving both robustness (under visual randomization) and efficiency simultaneously rather than trading one for the other, with gains validated on both simulation (RoboTwin) and real bimanual hardware. Ablations reportedly confirm the dense anchor is still necessary (not just deltas alone), implying compute savings are bounded by how often the anchor must be refreshed.

Problem: Open-weight base checkpoints have lowered the barrier to post-training research, but published post-training recipes are typically reported too thinly (more like system cards than reproducible procedures) for other teams to replicate the data, reward design, infrastructure, and stage ordering choices that actually matter.

Method: Rufus-Air is a fully open, reproducible eight-stage serial post-training pipeline applied to GLM-4.5-Air-Base (106B total / 12B active MoE parameters): SFT → Reasoning RL → Coding RL → Instruction-Following RL → General Agent → Coding Agent → Search Agent → RLHF, with each stage trained on the checkpoint produced by the previous one. The stage order is set by two axes — capability (basic to advanced) and reward reliability (hard verifiable rewards first, softer judge-based rewards later, to limit exposure to reward hacking) — and the recipe uses only open-source components and public data, with difficulty filtering acting as an automatic curriculum in each RL stage.

Key results:

• Rufus-Air improves over the official GLM-4.5-Air release on nearly every reported benchmark: e.g., IFBench 76.9 vs. 33.6, Multi-Challenge 65.8 vs. 36.0, Arena-Hard v2 (Hard Prompts) 89.1 vs. 55.0, LiveCodeBench v6 76.4 vs. 59.6, Tau2-Telecom 93.0 vs. 32.7, BrowseComp 37.1 vs. 22.7, HLE-Verified Gold 51.1 vs. 20.2, Terminal-Bench 2.1 42.7 vs. 24.7, SWE-bench Verified 65.6 vs. 50.6.
• Rufus-Air is competitive with similarly-sized open models (INTELLECT-3, Nemotron-3-Super), beating them on most metrics; exceptions include Tau2-Airline and Tau2-Retail (Nemotron-3-Super ahead) and Arena-Hard v2 Creative Writing (both baselines ahead).
• A stagewise progression table shows exactly which stage produced which gain, e.g., IF RL raises IFEval from 90.5 to 94.5 (+4.0) and Multi-challenge from 31.1 to 55.8 (+24.7); RLHF raises Arena-Hard v2 (Creative Writing) from 38.6 to 53.0 (+14.4).
• SFT uses 9,014,929 samples / 27.04B assistant tokens, dominated by General Agent (39.6% of samples) and Math (29.4% of training tokens despite only 12.7% of samples).

Why it matters / caveats: A rare, fully documented, reproducible post-training recipe (data, rewards, infrastructure, stage order) built entirely on open components at a compute footprint accessible outside frontier labs — valuable as a template rather than as a claim of a new capability ceiling. The authors note some ordering choices (e.g., reasoning before instruction-following) were inherited from earlier experiments rather than fully ablated.

Problem: State-of-the-art few-step autoregressive video diffusion distillation relies on Distribution Matching Distillation (DMD), which requires maintaining three full video-diffusion networks during training (a frozen teacher, an online critic, and the generator), making training expensive in both compute and memory.

Method: ViRDM replaces the DMD teacher-critic stack with Representation Distribution Matching (RDM) — matching generated video features against a precomputed offline reference distribution under frozen encoders (a V-JEPA 2.1 video encoder and a SigLIP2 text encoder), using an MMD objective — extended to video and made memory-feasible via three techniques: (1) stochastic truncated clean-exit supervision, so only one of the multiple denoising steps' clean predictions is backpropagated per update; (2) a lightweight VAE decoder and staged vector-Jacobian products so the encoder/decoder/generator graphs don't coexist in memory; and (3) an empirically-derived video-specific optimization regime (small fresh-generated batches of 8–64 videos, and causally-adapted initialization) plus lightweight dynamics regularization to counteract video features' weak temporal-dynamics signal.

Key results:

• On the official VBench evaluation, the complete ViRDM recipe reaches 84.87 Total after only 20 generator updates, beating the previous best few-step causal baseline (Causal Forcing) by 0.36, using only 16 A100 GPU-hours.
• Before adding dynamics regularization, the model reaches 85.77 Total-excluding-Dynamic-Degree, surpassing the previous best (Self Forcing, 85.34); with dynamics regularization it reaches 72.02 Dynamic Degree specifically.
• In the same 8-A100 setting, ViRDM reduces peak memory from 77.1GB to 48.3GB per GPU and post-training time from 22 hours to 2 hours versus a DMD baseline, while improving VBench Total from 84.51 to 84.87.
• The recipe also runs on a single 80GB A100 via gradient accumulation (68.5GB peak memory), and extends to 1-, 2-step causal and 1-, 2-, 4-step bidirectional generation settings.

Why it matters / caveats: Demonstrates that a three-network distillation pipeline can be replaced by generator-only post-training against a fixed offline target, substantially cutting both training memory and wall-clock time while modestly improving quality — a meaningful practical efficiency gain for deploying low-latency streaming video generation. The paper notes RDM alone underperforms on Dynamic Degree specifically until an explicit regularizer is added, since video representation distributions only weakly constrain motion.

Problem: Full-reference image-quality metrics (MS-SSIM, LPIPS, DISTS, Wasserstein Distortion) often align better with human perception than the standard sum-of-squared-errors (SSE) distortion used in video codecs, but they don't decompose block-wise and require the fully-decoded image, so they cannot be used "in-loop" during block-based rate-distortion optimization (RDO) the way SSE can.

Method: The authors approximate any sufficiently smooth full-reference metric by an input-dependent quadratic distortion (IDQD) via a second-order Taylor expansion around the source image, whose quadratic form is the metric's Hessian evaluated at the source. Since the full Hessian is far too large to form explicitly, they estimate its block-diagonal or diagonal restriction stochastically using Hessian-vector products (via automatic differentiation with Rademacher probes), with a lower-variance Gauss-Newton variant for metrics that are squared residual norms (LPIPS, DISTS, Wasserstein Distortion), plus an input-smoothing step to stabilize Hessians of neural-network-based metrics. This lets any target metric's approximate distortion be minimized block-wise inside standard VVC intra-coding RDO without decoder changes.

Key results:

• Across five metrics (SSIM, MS-SSIM, LPIPS, DISTS, Wasserstein Distortion) on Kodak and CLIC, IDQD-RDO achieves 14.2–36.7% BD-rate savings under the corresponding target metric versus standard SSE-RDO, with no decoder changes.
• The block-diagonal Hessian estimator outperforms the diagonal estimator on its own target metric in essentially every case, and outperforms the PerceptQPA baseline on every target metric (up to 21.0 percentage points better); the diagonal estimator alone still beats PerceptQPA in 6 of 10 cases.
• Encoding complexity overhead is 10–30%, with no change to decoder complexity.
• Optimizing for SSIM or MS-SSIM can slightly worsen DISTS results and vice versa (e.g., SSIM-map optimization gives +1.5% BD-rate under DISTS on Kodak), which the authors attribute to the two metrics capturing different image properties.

Why it matters / caveats: Provides a general, metric-agnostic way to bring perceptual full-reference metrics into standard block-based codec RDO without redesigning the decoder, unlike prior approaches limited to SSIM/WPSNR or requiring retraining a learned codec. The block-diagonal Hessian isn't guaranteed positive semidefinite for neural-network metrics and must be projected onto the PSD cone, and results are validated only on VVC intra-coding, not inter-frame or other codecs.

Problem: It was unknown whether the approximate layer-to-layer linearity previously observed in decoder-only Transformer residual streams extends to the model's full end-to-end input-output behavior — specifically, whether feeding a linear combination (average) of two distinct input token streams causes the model to output something like a superposition of the two streams' individual next-token distributions, despite the architecture's heavy reliance on non-linear attention and MLP components.

Method: The authors define the "Superposition Linearity Hypothesis": averaging the token embeddings of two text sequences A and B element-wise and passing the mixture through a frozen pretrained LLM should yield a mixed output distribution approximating the average of the two streams' independent next-token distributions. They test this via (1) rank analysis — where does each stream's independently-predicted top token land in the mixed distribution's ranking; (2) distributional-shape metrics (KL, JS, Wasserstein divergence) between the mixed output and the ideal 50/50 mixture, normalized into a "Superposition Approximation Ratio"; (3) tracking hidden-state additivity across Pythia's pretraining checkpoints to distinguish architectural bias from learned capability; and (4) an attention-patching analysis (donor patching vs. permutation patching) to isolate whether attention's structural shape or its content-specific computation enables the effect. They also test lightweight fine-tuning to restore/amplify linearity and a guided decoding procedure to disentangle the two streams' continuations from one mixed forward pass.

Key results:

• On unmodified pretrained models (Pythia-2.8B, Llama-3.2-3B, Qwen2.5-3B), each stream's true top token lands in the mixed distribution's top-10 ranks in ~30–40% of cases, top-50 in 50–60%, and top-100 in 60–65%, far above chance given vocabularies ≥50,000 tokens.
• The Superposition Approximation Ratio (mixed-vs-ideal-mixture divergence, normalized by divergence between two unrelated distributions) is consistently <1 across model families for KL, JS, and Wasserstein distance on FineWeb.
• Hidden-state superposition error is smallest at the earliest Pythia pretraining checkpoints and grows monotonically with training, indicating the effect is an intrinsic architectural bias that pretraining actually erodes, not a learned capability.
• Lightweight fine-tuning (less than 0.025% of original pretraining data size) substantially restores/amplifies this linearity, e.g., raising Qwen2.5-3B's median rank-agreement on hard "content" tokens from 284 (base) to 5 (fine-tuned).
• Attention-patching shows predictable-position tokens (~65% of positions) survive mixing even when attention structure comes from an unrelated donor sequence, but content-position tokens degrade sharply under both embedding mixing and donor patching, while permutation patching (destroying attention's structural shape) collapses performance on both token types — indicating attention's structural shape, not its specific content, is what preserves the superposed signal.
• The phenomenon persists (with quantitative but not qualitative degradation) when scaled to three simultaneous streams (N=3).

Why it matters / caveats: Suggests an underappreciated inherent linearity in Transformers that could enable running two (or more) independent generations from a single forward pass after lightweight fine-tuning — a potential efficiency mechanism — but the effect is strongest on "predictable" token positions dominated by the LM-head's frequency prior, and degrades substantially on genuinely content-dependent tokens in the unmodified base models.