AI papers — 2026-09-11

Problem: Standard next-token prediction (NTP) gives language models no explicit, direct supervision signal for the higher-level, multi-token "concept" structure that is believed to emerge only as an indirect byproduct of token-level training.

Method: NCP-ArchPreview restructures an 8.9B-parameter OLMo-3-7B backbone into a Token Encoder (16 layers) → Concept Module (8 layers) → Token Decoder (16 layers) pipeline: token hidden states are mean-pooled into concept vectors (compression factor k=4), mapped to a discrete vocabulary via product-quantized VQ (32 codebooks × 128 entries × 128 dims), and the Concept Module autoregressively predicts the next concept as a differentiable weighted combination of codebook entries (Next Concept Prediction, NCP), which is causally shifted and fused back into the Token Decoder stream. Hierarchical residual connections — Intra-Module Residual Connections (IRC, MUDDFormer-style dynamic dense connections) and Cross-Module Residual Connections (CRC) — route information across layers and across the three modules. Training jointly optimizes L_total = L_NTP + α·L_NCP + β·L_VQ using the Moonlight Muon optimizer, over a two-stage OLMo-3 curriculum (Dolma 3 Mix, then Dolma 3 Dolmino) totaling 5.73T tokens.

Key results:

• Matches OLMo-3-7B's final Stage-1 pretraining loss using only 51.3% of training tokens (1.95× faster convergence); Stage-2 shows a 1.51× speedup and a 0.027 lower final loss.
• Outperforms OLMo-3-7B by +2.45 points macro-average downstream after Stage-1 (30-benchmark OLMo eval suite), including GSM8K +5.99, PiQA +8.60, MultiPL-E MBPP +5.29; Stage-2 macro-average gain is +0.59.
• Under parameter/compute-matched ablations, NCP-ArchPreview beats compute-matched and plain Vanilla OLMo-3-7B baselines and approaches a size-matched (40-block) baseline while using only 85% of its computation.
• Progressive component ablation (CM → +Residual → +NCP) shows each component adds training-loss improvement; full hierarchical residual design (IRC+CRC) gives a 0.0323 loss reduction over no-residual baseline at only +0.051% training FLOPs.
• Achieves 1.74× Pareto compute efficiency versus OLMo-3 scaling laws.
• The learned concept space enables lightweight domain adaptation by fine-tuning only the 17M-parameter VQ module, and injecting concept representations into a DFlash2 speculative drafter improves mean accepted length by 4.17% with negligible overhead.

Why it matters / caveats: This is presented as the largest-scale demonstration (8.9B params, 5.73T tokens) that a latent-space/concept-prediction objective can be jointly trained with NTP and deliver real efficiency and downstream gains rather than being purely auxiliary, positioning it as a scalable architectural blueprint. A caveat noted by the authors: at Stage-2, lower training loss did not always correlate with better downstream performance (e.g., in code tasks, likely due to data-distribution mismatch), and full weight/checkpoint release is used to invite further scrutiny.

Problem: Most unified multimodal systems perceive images through pretrained vision encoders but generate them through separate VAEs, forcing understanding and generation to operate in disconnected representational spaces that limit coordinated perception, reasoning, and visual creation.

Method: SenseNova-U1.5 is an 8B-parameter encoder-free, VAE-free native Mixture-of-Transformers (MoT) model that tokenizes raw 32×32 image patches directly (no external encoder/VAE), replacing the prior patch-wise MLP decoder with a spatially-coupled decoder using Pixel Shuffle upsampling and 3×3 convolutions for spatially coherent reconstruction at up to 4K resolution. Training proceeds through five stages: generation pre-training (pixel-space flow matching with resolution-aware noise conditioning), unified mid-training and unified SFT (joint autoregressive + flow-matching + LPIPS perceptual losses), then Stage 4 trains four specialized RL experts (aesthetics via HPSv3++ reward, bilingual OCR/text rendering via PaddleOCR-based multiset IoU reward, infographic generation, and image editing via a 5-dimension VLM reward) using GRPO/CPS/Precise sampling, and Stage 5 consolidates them into one policy via multi-expert on-policy velocity-field distillation (hard-routing each expert to the student's own generation trajectories).

Key results:

• Qwen-Image-Bench: best overall among open-source models with prompt enhancement (60.22 EN / 60.13 ZH), versus 48.28/45.99 for prior SenseNova-U1.
• GenEval: 0.92 overall (best open-source), surpassing 20B Qwen-Image (0.87) and SenseNova-U1 (0.91).
• DPG-Bench: 88.11 overall; CVTG-2K (dense text rendering): 0.948 average, best among all evaluated (including closed-source).
• LongText-Bench: 0.988 (EN) / 0.989 (ZH), leading open-source performance.
• ImgEdit editing benchmark: 4.59 overall, best open-source score, beating 20B FireRed-Image-Edit (4.56) and Qwen-Image-Edit-2511 (4.51).
• Retains strong language/multimodal understanding: MMLU-Pro 86.67, C-Eval 90.41, IFEval 93.35 (up from 91.13 in U1), MMMU 73.86.

Why it matters / caveats: Shows a single compact native visual representation (32×32→1 token) can jointly support understanding, reasoning, generation, and editing without encoder/VAE conversion, and that specialize-then-distill RL post-training avoids diluting task-specific gains from naive joint optimization; the model still trails top closed-source systems (e.g., GPT-Image-2, Nano-Banana-Pro) on several benchmarks like BizGenEval and IGenBench.

Problem: Large Vision-Language Models (LVLMs) struggle to reconstruct and reason about 3D scene structure from 2D images (spatial intelligence), and existing training approaches to fix this depend on costly, noisy, annotation-heavy real-scene datasets built with external perception modules.

Method: Inspired by developmental psychology (block play cultivates spatial cognition), the authors introduce SpatialBlock-15k, a fully synthetic dataset of 15,000 block-stacking problems spanning three question types — Q1: 3D-to-2D projection, Q2: viewpoint transformation, Q3: structural combination — each further extended with color-modulation visual cues (depth cues, anchor blocks, overlap cues) to encourage anchor-based reasoning, for a total of 5k samples per type. Two training strategies are built on top of Qwen2.5-VL-3B/7B, Qwen3-VL-4B, and InternVL3-2B backbones: SpatialBlock-direct (pure cross-entropy supervision on final answers) and SpatialBlock-reason (LoRA-based SFT initialization to preserve chain-of-thought ability, followed by GRPO reinforcement learning with a multi-objective reward combining accuracy, format, and length rewards, deliberately avoiding a cold-start phase with teacher-model trajectories since even GPT-5/Qwen2.5-VL-7B produce unreliable reasoning traces on these tasks).

Key results:

• On in-domain SB-Bench and four out-of-domain benchmarks (MindCube, MMSI-Bench, SPBench, MMMU), SpatialBlock models trained with only 15K synthetic samples outperform existing spatial specialists (SpaceQwen, SpatialMLLM, SpatialLadder-3B, Spatial-SSRL, SpaceR) trained on 25K–150K samples.
• SpatialBlock-3B-direct beats SpatialLadder-3B by 2.7% on MindCube; SpatialBlock-7B-direct improves 17.6% over its Qwen2.5-VL-7B backbone; SpatialBlock-4B-direct improves 25.1% over backbone, reaching 51.3% (best open-source result).
• SpatialBlock-3B-reason beats SpatialLadder-3B by 3.2% on MMSI-Bench; achieves a reasoning-alignment score of 21.1 vs. 17.8 for baseline.
• Ablations: removing visual cues drops MindCube performance by 7.9%/7.3% (direct/reason) and MMSI-Bench by 1.9%/4.8%; training on all three question types beats any single type; a matched-size real-scene-style "Synthetic-Real" dataset overfits to in-domain (higher SPBench score) but generalizes worse out-of-domain than SpatialBlock; LoRA-based RL initialization outperforms both no-init and full-SFT cold-start initialization (even using GPT-5 or a 7B teacher for cold-start).
• Despite training on no real-scene images, models maintain stable MMMU (general visual understanding) performance.

Why it matters / caveats: Shows a cheap, fully synthetic, small-scale (15K samples) dataset can match or beat annotation-heavy real-scene spatial training data and generalize to real-world spatial benchmarks, offering a scalable alternative to costly dense 3D annotation pipelines. Direct-answer models excel on canonical 90-degree transformations while reasoning models do better on complex multi-image/diverse-viewpoint tasks, suggesting the two training strategies are complementary rather than one being strictly superior.

Problem: Fixed, expert-designed system-level safety harnesses for LLM agents cannot simultaneously fit heterogeneous models (which need different amounts of enforcement) and heterogeneous domains (which need different safety relations and control flow), so a single universal harness either over-blocks capable models or leaves weaker models exposed.

Method: EvoSafeHarness is a closed-loop search framework that synthesizes, per (frozen model, target domain) deployment, a harness H = (P, C) consisting of a natural-language policy P and executable code logic C. Four components drive the loop: a Designer that proposes/revises candidates (warm-started from eight distilled security design experiences drawn from prior defenses like CaMeL/DRIFT), a fresh-context Criticizer that adversarially screens candidates for benchmark-artifact overfitting (renamed paths, rephrased attacks) before evaluation, a staged Cascade Test Environment (static check → smoke prefix → confidence-gated bootstrap → full search extension) that separately scores benign utility and direct/indirect ASR, and an Analyzer that turns failed traces into reusable experience for the next iteration. The optimization target is score = 100·(U − ASR), explicitly penalizing refuse-everything solutions.

Key results:

• On DecodingTrust-Agent (15 model×domain cells, 5 victims × 3 domains), EvoSafeHarness cuts average ASR from 45.6% to 10.0% at only a 3.3-point utility cost, best in 14/15 cells (vs. CaMeL 37.7% ASR, DRIFT 42.4% ASR, Progent 10.5% ASR but utility crashing to 56.4% vs. EvoSafeHarness's 79.8%).
• On AgentDojo it reaches 82.8% utility at 0.0% ASR — twice CaMeL's utility at the same zero-ASR point — and transfers unchanged to unseen AgentDyn suites at 75.0% utility, 0.0% ASR (above the undefended agent's 73.3% utility).
• On Agent-SafetyBench, averaged over three victims it is the only method lowering unsafe-behavior rate (12.3%) and ASR (7.4%) while raising utility-under-attack (63.4%), beating SafeHarness which ties ASR on GLM-5.2 but gives up 22 points of utility.
• Against adaptive PAIR attacks (refinement budget 16) on a frozen harness, mean ASR stays at 19.5%, still below the undefended baseline; pooled McNemar test rejects no-change in 13/15 grid cells (p≈2×10⁻⁷⁸).

Why it matters / caveats: Demonstrates that safety harnesses, like prompts, benefit from per-deployment search rather than one-size-fits-all design, and that adversarial screening (Criticizer) is needed to prevent the search from gaming benchmark artifacts — removing it leaves search score unchanged but drops held-out score by up to 31 points. Costs include running an agentic search process per model×domain deployment.

Problem: Iterative reference-conditioned AI image editing (feeding each generated output back as the next reference) can accumulate grid-like periodic ("lattice") and granular ("digital ripple") texture artifacts, and it is unclear when such artifacts can be safely filtered out versus when they are entangled with legitimate image content and require regeneration.

Method: Mi-Ripple is a diagnosis-guided restoration workflow with three stages: (1) diagnosis via spectral and spatial probes—a whole-image lattice probe (21×21 local median log-amplitude spectrum, connected components with excess ≥1.2 outside radius 24) and spatial probes (flat-window band-pass/kurtosis/blob-coverage tests and a whole-frame "scale index" over 128-pixel tiles at 64-pixel stride) that distinguish periodic lattice artifacts from content-entangled granular texture; (2) treatment—isolated-peak spectral notching (Gaussian-feathered exponential suppression of retained frequency components, Eq. 2) for separable lattice artifacts, versus structure-aware masked spatial suppression or cleaned-reference regeneration (with explicit face protection) for content-entangled granular texture; (3) verification—aligned residual-SD and high-frequency-retention checks (structural windows: residual SD ≤0.6 lightness units, retention ≥90%) to confirm filtering didn't damage structure, with an optional rule-based/LLM-assisted routing layer. Evaluated on commercial editing channels (OpenAI Image 2 desktop and an OpenAI-compatible gateway exposing gpt-image-2/gpt-image-2.5 routes) plus the external Banana100 dataset (110 edited outputs across 7 model families).

Key results:

• Across fourteen notch-only executions, whole-image residual SD ranged 0.08-0.44 (CIELAB lightness units), with high-frequency retention 98.9-99.8% on portrait candidates.
• Reference cleaning before regeneration reduced output debris density by 45% (1,842 → 1,020 components/megapixel) in a paired example; scale index dropped from 35.3% (untreated reference) to 15.8% (cleaned reference) on a dense-moss scene.
• On an eight-scene gpt-image-2.5 comparison, the restoration route reduced 6 of 8 gen4 endpoints to the "none" artifact grade: moss gorge scale index 25.3%→11.1%, wisteria tunnel 41.1%→12.1%, ice cave 20.0%→0.0%.
• Channel-level lattice survey: Channel B (gateway) was lattice-positive in 43/43 sampled outputs; Channel A (desktop) was negative in 20/20 at 1280×720 but positive in 6/6 at 1536×1024 — artifact presence depends on access configuration/resolution, not vendor name alone.
• Structure-aware cleaning lowered output band-pass SD from 1.05→0.87 (sea) and 2.61→1.77 (railing), though sky increased slightly (0.20→0.25), showing region-dependent effects; paired prompt constraints (adding foliage-texture instructions) showed no consistent effect (sign-test p=0.29-0.73 across three decompositions).

Why it matters / caveats: Offers a practical, measurable framework for diagnosing and repairing accumulating artifacts from repeated AI image editing rather than treating a single spectral anomaly score as an end goal, and cautions against unnecessary same-scene recursive editing chains. The authors note the study's thresholds need broader calibration, comparisons are largely single-draw/single-chain (not averaged treatment effects or matched-channel factorial experiments), and regeneration-based restoration can alter genuine image content rather than recovering true ground truth.

Problem: Reducing the depth of a speech LLM's audio encoder lowers inference cost but perturbs the embeddings fed to the frozen decoder, causing deletion errors and premature end-of-sequence predictions, and static per-layer importance scores fail to predict which multi-layer removals are jointly recoverable.

Method: X-AuT prunes the 18-layer Qwen3-ASR-0.6B audio Transformer in two hops (18→16→14 layers), using short (0.3-epoch) behavior-driven probes over single-layer and layer-pair candidates on a five-benchmark development suite to select recoverable combinations rather than relying on additive importance scores. Each pruned student is recovered via a three-stage recipe: Stage 0 representation alignment (grouped teacher-layer matching plus a learned 2048→1024 bottleneck MLP, combined intermediate/bridge/logit/CE losses) using a 1.7B cross-scale teacher; Stage 1 distillation with teacher-forced logit KD plus scheduled student-policy (on-policy) supervision after 20% of the stage, with rollout filtering (min 3 / max 256 new tokens, reject-and-fallback on degenerate batches); and Stage 2 LoRA fine-tuning (rank 32 adapters on q/k/v/o, tied output embedding) on CE loss only, with training-data source reweighting toward cockpit/target-domain data. The decoder backbone stays frozen except for LoRA and the tied embedding; training data is filtered by a nine-tier transcript-consistency scheme comparing the source transcript against two external ASR hypotheses.

Key results:

• 16-layer model: macro-average error drops from 5.61% to 5.27% (6.1% relative reduction) across ten Chinese/English benchmarks (AISHELL-1, Fleurs zh/en, LibriSpeech clean/other, THCHS-30, Tedlium, CommonVoice zh/en, WenetSpeech-meeting).
• 14-layer model: 5.75% macro error with 20.7% fewer audio-tower parameters (186.4M→147.8M); encoder latency down 21.4% on an in-vehicle accelerator and 11.4% on H800.
• Cross-scale (1.7B) teacher yields 5.55% mean error vs. 8.45% for same-scale self-distillation (better on all 10 benchmarks).
• Progressive 18→16→14 pruning (5.75%) beats direct 18→14 pruning (6.73%) under the same budget; the selected {5,6} layer pair beats the naively "strongest" {6,8} pair by 0.85pp after matched recovery, showing non-additive layer interactions.

Why it matters / caveats: Shows post-training depth reduction with cross-scale distillation and layer-pair probing can compress a speech-LLM encoder with minimal (16L) or modest (14L) accuracy cost and real latency wins, though end-to-end latency gains are small since autoregressive decoding dominates. All results are single runs (seed 42) on one model family (Qwen3-ASR) with no confidence intervals, so small differences (e.g., the 0.14pp 14-layer regression) are descriptive only.

Problem: Robotic manipulation policies are typically Markovian (conditioned on current or short-window observations), but many real-world tasks are non-Markovian and require long-horizon memory; existing memory mechanisms either lose fine-grained visual evidence (language summaries) or trade off history coverage against inference efficiency (growing visual windows/causal world models).

Method: MaP-WAM decomposes memory-dependent control into memory-grounded planning and plan-conditioned execution. It maintains structured multimodal episodic context as completed-segment records {language instruction, sparse visual context of 8 uniformly sampled frames}; a fine-tuned Qwen3.5-4B VLM planner predicts the next segment-level language plan from keyframes and instructions, and a causal world model (CWM), initialized from WAN-2.2-5B with block-causal attention over segment context, generates a corresponding visual plan (flow-matching objective). A World-Action-Progress (WAP) model — built as a Mixture-of-Transformers (video/action/progress experts, action expert 1.02B params, progress expert 207M params) on the WAN-2.2 video backbone — jointly predicts future visual latents, action chunks, and normalized execution progress conditioned on the fixed plan prefix (cacheable via structured attention masks), enabling variable-duration plan execution, progress-gated segment transitions (threshold τ=0.95), and plan-observation alignment (matching current observation to nearby visual-plan frames via pixel difference) to calibrate drifting progress estimates.

Key results:

• Achieves 83.3% average success rate on RMBench (9 memory-dependent tasks), the best among all baselines (DP 5.8%, π0.5 10.4%, X-VLA 9.8%, Mem-0 42.0%, LingBot-VA 77.1%).
• Reaches 96% success on both Swap T and Press Button tasks that require precise memory of object positions or disambiguating visually similar states; improves Observe and Pick Up from the best baseline's 9% to 19%.
• On real-robot tasks (Franka Research 3 arm), achieves 88% (Find Button) and 68% (Press Buttons) success over 50 trials, and 78.0% success overall on real-robot tasks reported in the abstract, versus baselines failing (near-zero) on the harder Press Buttons task.
• Maintains approximately constant ~827ms executor per-chunk latency regardless of history length, versus a full-context executor baseline that grows to ~4x latency at 1,500 frames and runs out of memory (>80GB) at 1,700 frames.
• Ablations: removing visual planning or replacing memory-grounded visual context with current-observation-only context substantially hurts Observe-and-Pick-Up (19%→2/1%) and Swap T (96%→14/13%); progress-modeling ablations show classification-based completion detection (37.0% avg) is much worse than progress regression (96.7% avg with full plan-observation calibration).

Why it matters / caveats: Provides an architecture that decouples expensive long-horizon visual memory processing (used only at planning time) from action execution (kept at fixed context length), solving the efficiency/history-coverage trade-off that limits causal world-action models. The approach currently relies on segment boundaries provided by existing benchmark annotations, and the paper notes extending to automatic segment discovery on unsegmented demonstrations is a needed next step; the plan-observation alignment calibration is also a lightweight, training-free heuristic that the authors suggest could be improved with learned similarity measures.

Problem: State-of-the-art optical flow methods rely on hand-crafted, flow-specific inductive biases (correlation/cost volumes, feature warping, iterative refinement, convex upsampling) that constrain model expressivity and complicate pipelines, and even recent "generic" transformer approaches (WAFT, GeoViT, CroCo-Flow) still retain some of these biases or are limited to low training resolution.

Method: FreeFlow is a Siamese ViT-style encoder–decoder (following the CroCo/DUSt3R/MASt3R paradigm) with no correlation volumes, warping, iterative refinement, or convex upsampling — just an encoder producing features F1, F2 for the two frames and a decoder alternating self-attention and cross-attention between them, followed by a simple 3-layer convolutional flow head (no DPT-style multi-layer aggregation). Each layer applies three attention block types in fixed order — Window (4×4 non-overlapping windows), Shifted-Window (half-window offset, Swin-style), and Global (attention at 2× downsampled resolution via strided conv) — using RoPE and an unnormalized log-token-count attention-logit scaling for resolution generalization. Training follows a CroCo-style cross-view-completion pretraining stage (masking ratio tuned to 0.95, on ARKitScenes/MegaDepth/3DStreetView, 346k steps) followed by optical-flow finetuning on a TaTSKH mixture (TartanAir, Things, Sintel, KITTI, HD1K) with variable-resolution/fixed-token-budget crops and a Mixture-of-Laplace loss (à la SEA-RAFT), then per-benchmark finetuning (Sintel-ft, KITTI-ft, Spring-ft). Three model scales (S/M/L, 35M/102M/231M params) are trained by co-scaling depth/width/heads.

Key results:

• State-of-the-art on Spring: FreeFlow-L achieves 1px=3.192, EPE=0.278, Fl=1.048 — best EPE and Fl among all compared methods, improving EPE by 9% and Fl by 14% over WAFT-DAv2-a2, while using far less 1080p inference memory (2.58 GB vs. 56.93 GB for WAFT-DAv2-a2).
• State-of-the-art on Sintel: FreeFlow-L gets Clean=0.68 (14% better than GeoViT's 0.79) and Final=1.48 (10% better than VideoFlow-MOF's 1.65), and FreeFlow-M is already competitive (Clean=0.80).
• On KITTI-2015, FreeFlow-L reaches Fl-all=3.23, best among non-stereo, non-multiframe methods.
• Ablations: raising CroCo's default masking ratio (0.9) to 0.95 with all three attention blocks improves 1px by 9.3% and EPE by 7.6%; removing Shifted-Window attention clearly hurts, and Global attention becomes important specifically at the higher masking ratio.
• Model scaling from S→M→L gives consistent, predictable accuracy gains (Sintel Final EPE) with smaller variants still competitive.

Why it matters / caveats: Demonstrates that a fully generic, single feed-forward transformer (no flow-specific machinery) can match or beat specialized architectures at high resolution while being markedly more memory-efficient at 1080p inference, suggesting flow-specific inductive biases may not be necessary given sufficient data/scale and the right attention hierarchy. The analytical FLOPs comparisons in ablations exclude memory traffic/kernel-launch overheads, so real-world runtime costs of the residual/attention design may be somewhat understated.

Problem: How should post-training and test-time inference be designed so that a natural-language LLM (no formal prover, external tools, or internet access) can generate, verify, and refine olympiad-level mathematical proofs well enough to reach IMO gold-medal performance?

Method: Starting from the Nemotron-3-Ultra-GA (550B-A55B MoE) checkpoint, the authors train two specialist checkpoints: Nemotron-3-Ultra-SFT via long-context (426K-token) supervised fine-tuning on a 414,890-example proof/refinement/verification/meta-verification corpus synthesized with DeepSeek-V4-Pro, and Nemotron-3-Ultra-RL via reinforcement learning (DeepSeekMath-V2-style rewards, an asynchronous PipelineRL-like framework built on NeMo-RL, dynamic sampling, truncated importance sampling) on 9,597 filtered problems. The submitted system runs a two-stage pipeline: (1) a high-compute iterative generate-verify-refine search using all three checkpoints (GA, SFT, RL) as generators and RL+SFT as an unanimous 16-judgment verification panel across up to 8 rounds per problem, and (2) a final-selection stage that re-scores finalists with a 48-judgment (3 checkpoints x 16 judgments) reference-free IMO-style 0-7 rubric judge adapted from MathArena/Dekoninck et al.

Key results:

• Scored 30/42 at the official IMO 2026, above the gold-medal cutoff of 29, with full credit (7/7) on Problems 1, 2, 4, 5 and 1/7 each on Problems 3 and 6.
• All six proofs found within ~707M generated tokens and 1,464 GPU-hours (GB200); full run to submission deadline ~2.31B tokens / 4,800 GPU-hours.
• On the 30-problem dev set (independent jury of GPT-5.5, Gemini 3.1 Pro, Claude Opus 4.8), single-checkpoint end-to-end scores were GA 162, RL 180, SFT 165 (out of a max per-problem-sum scale), while the full ensemble reached 188 — better than any single checkpoint.
• Verifier audit on 300 proofs: single-checkpoint false-accept rates were GA 31.6%, RL 12.4%, SFT 4.5%; the submitted RL+SFT unanimous 16/16 panel cut false-accept to 1.1% (vs. 81.3% false-reject, a much less costly error type).
• Continuing the search 8h25m past the contest cutoff found a Problem 6 proof that scored 4/7 in an unofficial human regrade (would raise total to 33/42), and doubling round-1 generation attempts from one checkpoint added little vs. spending the same budget on a second checkpoint (18 vs ~14-15 problems accepted).

Why it matters / caveats: Demonstrates a fully open, reproducible (released checkpoints, data, code, submitted proofs, and a new 200-problem Nemotron-IMO-Bench) natural-language route to IMO gold, showing that complementary post-trained checkpoints and verification-guided refinement—not raw generation scaling—drove the gains; the internal verifier still shares a "blind spot" with independent model juries on 2 of 6 problems, since both overestimated the final score by ~2 points relative to official human grading.

Problem: There is no benchmark testing whether language models can replace a transit kiosk's hard-coded policy layer — correctly routing, pricing fares, handling disruptions/accessibility, and emitting a machine-renderable, auditable terminal state — rather than just acting as a conversational or trip-planning assistant.

Method: MetroLLM-Bench comprises 955 cases across six real metro systems (MARTA, Doha Metro, BART, Taipei MRT, CTA, Beijing Subway; 37–414 stations) and eleven categories (routing, fare, disruption, accessibility, cultural, policy, multi-turn, adversarial, temporal, tool-hallucination, compound stress). Each case is a ReAct-style loop (≤20 rounds) over six tools (route_planner, fare_calculator, station_info, line_info, disruption_feed, knowledge_base) ending in a Pydantic-validated submit_assistant_state call. Scoring has 14 deterministic Tier-1 components (route/fare correctness, tool accuracy, etc., also used as the PEFT reward) and 8 semantic Tier-2 components, six judged by Claude Haiku 4.5. A system-stratified 75/25 split (717 train / 238 held-out) supports four QLoRA (rank 16, 3 epochs) PEFT students at 2B/4B/9B/27B distilled from Qwen3-ASR-style teacher traces (Qwen 3.5 27B/35B-A3B teachers filtered to ≥90% Tier-1 traces).

Key results:

• A 4B Qwen 3.5 PEFT student (2.6 GB Q4_K_M) scores 91.32 on held-out Tier 1, exceeding GPT-5.6 luna (90.63) and sol (90.00), and matching GPT-5.4 full at xhigh effort (91.37).
• PEFT gain over base model shrinks monotonically with size: +7.03 pts at 2B, +2.00 at 4B, +1.65 at 9B, −0.91 at 27B (i.e., PEFT hurts the largest model); consistent across seeds and across the full 955-case matrix.
• A deterministic rule-based baseline reaches 84.6 Tier-1 / 77.1 composite on held-out; the LM advantage is concentrated in temporal reasoning, policy adaptation, accessibility, and compound scenarios (gains of 10–23 composite points), not routing/fare.
• Muse Glimmer 30B leads the overall composite ranking (92.03); serving configuration (output token budget, decoding temperature) alone accounts for ~2.7 of a 3.6-point apparent Qwen3.8-vs-Qwen3.5 regression.
• Judge–human agreement (κw=0.53) exceeds human–human agreement (κw=0.25) on the Tier-2 rubric calibration set.

Why it matters / caveats: Suggests a small, open-weight, locally-deployable model can match frontier APIs on a bounded, deterministic operational task, but frontier models retain a clear edge on adversarial and temporal-reasoning categories; results rest mostly on single runs (no repeated seeds for most models), and held-out partition size limits statistical power for close comparisons.

Problem: Reconstructing a complex 3D world as executable code from a single image requires resolving structure at multiple scales while preserving cross-part relationships, but existing code-based scene reconstruction pipelines use fixed scene-decomposition or sequential factor-based stages rather than a construction process that adapts recursively to arbitrary structural depth.

Method: Recursive Code World Models (RCWM) produce Recursive Scene Programs (RSPs) — executable Three.js scene code organized as nested subworld programs with explicit child references — via a construction solver F that recursively calls itself following a "global–local–global" cycle: (1) establish the whole by comparing a rendered subworld against a reference-view crop, (2) recursively invoke the same solver F on unresolved child subworlds (each receiving an inherited camera projection via matched crop-and-magnify windows, i.e., CropW,s and CropCamera operations preserving camera pose), and (3) compose returned child programs and revisit/refine the assembled whole to fix boundaries and shared errors. The solver is driven by a frozen vision-language coding agent (GPT "gpt-6-astra" via Codex CLI) with each recursion node run as one Codex session, up to 5 levels deep, and is evaluated against three image-to-scene-program baselines (SEIG, VIGA, img2threejs) using the same base model.

Key results:

• Across 5 whole-scene references (city-full, snow-village, island-harbor, medieval-village, japan-island) and 5 local crops, RCWM achieves the highest PSNR and lowest LPIPS on every single reference (e.g., medieval-village: PSNR 18.7 vs. 10.5-15.4 for baselines; LPIPS 0.200 vs. 0.325-0.601).
• Highest SSIM on 9 of 10 references (loses only on valley-village: VIGA 0.41 vs. RCWM 0.38).
• Ablation on medieval-village: free-depth recursion (3 levels, 33 nodes) improves whole-frame PSNR from 16.8 to 19.0 and local SSIM from 0.52 to 0.60 compared to fixed 2-level recursion, and outperforms flat+zoom, local→global, and global→local construction orders.
• Recorded call trees show recursion scaling with scene complexity: japan-island reaches depth 4 with 54 nodes/163 sessions/92 calls, versus school-block at depth 2 with 9 nodes.

Why it matters / caveats: Demonstrates that recursion — rather than just decomposition or parallel scheduling — is the key organizing principle for building code-based worlds with both fine local detail and whole-scene consistency, and that deeper recursive calls can improve both local and global fidelity. Limitations acknowledged by the authors: single-view input leaves hidden geometry/scale ambiguous, visual inspection can miss errors, convergence is not guaranteed, and evaluation covers only 10 scenes with single runs and no human evaluation of spatial relationships.

Problem: Autoregressive video world models support interactive long-horizon exploration but flexible control (following a new camera path while staying synchronized with a recorded event, correctly placing content, completing newly exposed regions, and recovering previously seen states) typically requires task-specific modules or additional training for each new type of control.

Method: World in World (WiW) is a training-free, inference-time interface built on a frozen causal video model (instantiated on the public causal-fast checkpoint of LingBot-World 2.0) that converts heterogeneous control evidence into camera- and time-labeled clean visual states readable through the model's native self-attention. It constructs four evidence types: source-video observations, target-view scene projections (via DepthCrafter-based depth projection), rendered geometry evidence for newly exposed subject surfaces (via LHM++ avatar reconstruction + SMPL-X body parameters for humans), and retrieved generated history states beyond the rolling KV cache. Two mechanisms regulate use of this evidence within attention: correspondence-guided attention routing (CGAR), which uses persistent point tracking + camera geometry to route queries to matching source-video tokens by adding a log-correspondence-weight term to attention logits; and evidence-wise attention CFG (EWA), which independently amplifies each evidence channel's complementary (non-native) attention-response component using cosine similarity between native and evidence-conditioned responses, reusing the same denoising forward pass (adding no extra NFEs).

Key results:

• On DAVIS/OpenVid-1M camera-controlled rerendering, WiW achieves the best VBench Overall score (85.192) versus ReCamMaster (83.836), TrajectoryCrafter (82.984), WorldForge (82.384), InSpatio-World (83.447), UniWorld-View (84.295), and CameraAnything (83.036).
• WiW achieves the lowest camera trajectory errors: TransError 0.068622 and RotError 2.8326° (best among all baselines; next-best RotError is CameraAnything's 3.19° and next-best TransError is UniWorld-View's 0.0687).
• Best image quality among compared methods: PSNR 23.1511, SSIM 0.787205 (both highest), LPIPS 0.121664 (tied-best with UniWorld-View's 0.121668).
• Ablations: removing target-view warping causes the largest degradation, with RotError rising ~3.4x and TransError ~10.9x versus the full method; removing CGAR/EWA or source-camera Plücker conditioning also degrades camera accuracy and consistency metrics, confirming each component's contribution.

Why it matters / caveats: Shows a shared, training-free visual-evidence interface can extend a frozen world model to camera control, long-horizon revisits, and human-motion transfer (plus bullet-time, stabilization, editing, and cross-model KV sharing) without retraining or task-specific adapters, outperforming methods that use dedicated trained conditioning modules. The approach is demonstrated on one frozen backbone (LingBot-World 2.0) and depends on auxiliary 3D vision models (depth estimation, point tracking, human body reconstruction) whose errors could propagate into the generated evidence.

Problem: Existing evaluations of discrete image tokenizers rely on isolated reconstruction metrics (rFID) or single-axis generation-only/understanding-only pipelines, leaving unclear how a tokenizer's design actually shapes joint image–text modeling once it is embedded in a unified autoregressive (AR) multimodal model.

Method: The authors build a controlled pure-AR testbed that extends pretrained Qwen3 language models (0.6B, 1.7B, 4B) into unified multimodal models by adding B new embeddings for a tokenizer's image vocabulary and continually pretraining on mixed text/image-text data (60M samples: DataComp-LM text plus LAION-Aesthetics, JourneyDB, and BLIP3o-Pretrain data), followed by SFT on 4.9M instruction-following samples. They track four task-specific validation losses — text, unconditional image, text-to-image (T2I), and image-to-text (I2T) — across three single-codebook tokenizer families (IBQ at vocab sizes 1024/8192/16384, GigaTok with PatchGAN vs. DINO discriminator, and UniTok with/without CLIP-based semantic supervision) to study scaling behavior, loss-performance correlation, and design-axis ablations (discriminator type, semantic supervision, vocabulary size).

Key results:

• All four task losses scale with data/model size as power laws, but rank tokenizers inconsistently (e.g., UniTok has the highest text loss but lowest T2I loss in one comparison; GigaTok the reverse).
• Within a fixed tokenizer, T2I loss correlates strongly with generation quality (GenAI-Bench Pearson r=-0.954, MJHQ-30K r=+0.956); I2T loss also correlates (r=-0.917/+0.885) and generalizes more consistently across tokenizers, while T2I loss's relationship with quality shifts across tokenizers (vocabulary normalization L*=L/log2(B) partially fixes this).
• I2T loss correlates with post-SFT VQAv2 and GQA performance across tokenizers (moderate correlation, R²≈0.35–0.38).
• Better reconstruction does not guarantee better joint modeling: swapping GigaTok's PatchGAN discriminator for a DINO-based one improves rFID from 0.81 to 0.51, but VQAv2 drops from 52.25 to 51.31 and GenAI-Bench is unchanged (0.720).
• Adding semantic supervision (UniTok-sem vs. UniTok) worsens rFID (1.86→2.23) but improves all three validation losses and both downstream metrics (GenAI 0.670→0.690, VQAv2 57.21→61.28), driven by stronger object-level image-token–word alignment (verified via PMI and per-token-type loss improvement analysis on COCO objects vs. stopwords/colors).
• The image tokenizer's vocabulary/design choice measurably affects pure-text modeling loss under joint training (e.g., IBQ-1024 attains lower text loss than IBQ-8192); ablating the image-generation objective (training on Text+I2T only) closes this gap, showing the interference stems from image-token prediction, not captioning.

Why it matters / caveats: The paper shows reconstruction-based tokenizer benchmarks (rFID, ImageNet accuracy) can be misleading proxies for unified multimodal performance, and that tokenizer choice has cross-modal side effects on text modeling not visible from generation- or understanding-only evaluation. The recipe is validated only up to 8B/60M samples against Liquid-7B (comparable GenAI-Bench/WISE/VQA but trailing MJHQ-30K by a wide margin: 10.55 vs 5.47 gFID), and the study is restricted to single-codebook tokenizers at fixed image resolution/token count, leaving multi-codebook and variable-resolution tokenizers unexamined.

Problem: Existing video temporal-reasoning benchmarks are language-mediated (textual options/captions), letting Video-LLMs exploit linguistic shortcuts (option wording, answer correlations, language priors) rather than truly reasoning over visual temporal evidence.

Method: TempCloze is a video cloze benchmark: given a video's beginning and ending clips, models must pick the true missing middle clip from four candidates (1 correct + 3 same-source distractors) constructed along three dimensions — Semantic (S, distractor is a non-overlapping same-duration clip testing "what happens"), Alignment (A, Advanced/Deferred/Expanded variants shifting or expanding the true interval, testing "when"), and Progression (P, Reversed/Reordered/Repeated variants of the true clip, testing "how it unfolds"). The dataset is built from seven public sources (LVD-2M, EgoLife, MiraData, FAVOR-Bench, CaReBench, Video-Thinking-Test, Daily-Omni) via duration filtering, GPT-o3-based caption screening for cloze-suitability, and Farnebäck optical-flow filtering to remove static segments, yielding 1,521 videos. The authors evaluate 10 proprietary and 21 open-source Video-LLMs, and build two auxiliary diagnostic subsets: TempCloze-Mixed (distractors mixed across dimensions) and TempCloze-Hard (most-often-missed instances), used for error-pattern and behavioral-sensitivity analyses (candidate-order permutation, context-direction ablation, visible-span/frame-density scaling, test-time scaling/pass@k).

Key results:

• Dimension accuracy: proprietary models average S=70.73%, A=48.13%, P=67.72% (best overall model Seed1.8 at 88.58% mean); open-source models average S=34.00%, A=26.54%, P=36.97% (best: Qwen3.5-397B-A17B at 68.27% mean). Human baseline is 97.00% mean (98% on Alignment) and Random is 25%.
• Alignment is the consistent bottleneck across all models — proprietary average drops to 48.13% vs. Human's 98.00%, far below Semantic/Progression scores.
• Cumulative accuracy (all 3 dimensions correct, "3/3"): proprietary average only 33.24% (best model 70.81%) vs. Human 92.00%; open-source average just 7.15% (best 35.77%).
• Error analysis: Expanded is the dominant Alignment failure mode (e.g., Seed1.8-I picks Expanded in 75% of its Alignment errors); Reversed dominates Progression failures (GPT-5.4 picks it in 67% of Progression errors).
• Candidate-order permutation on TempCloze-Hard shows accuracy is fairly stable (variance <4 points) but choices are unstable — Clip Flip Rate ranges 32.4–60.7% across models.
• Context-direction ablation shows models rely more on beginning-only context than ending-only (e.g., Seed-1.6: 80% Progression accuracy with beginning-only vs. 46% with ending-only).
• Test-time scaling (pass@k up to k=5) raises accuracy substantially for some models (~30 points for Gemini2.5-Pro and Qwen3.5-397B-A17B) but never changes the relative ranking of dimensions — Alignment remains hardest.

Why it matters / caveats: TempCloze exposes that current Video-LLMs (even strong proprietary ones) are far from human-level "complete" video understanding and specifically struggle to judge precise temporal alignment rather than just event content or local motion direction, suggesting a need for video-native architectures with better temporal-boundary sensitivity. The authors note it is a controlled diagnostic benchmark (fixed 4-way candidates, same-source distractors) rather than a general measure of open-ended video understanding, and does not cover audio-grounded or dialogue-based reasoning.

Problem: On-Policy Self-Distillation (OPSD), which uses ground-truth-conditioned teachers for dense supervision, forces students to imitate artificially confident, overly linear reasoning traces, suppressing uncertainty expression and self-correction behaviors needed for complex reasoning.

Method: Negative Self-Distillation (NSD) is a fully label-free framework that first prompts the student model to generate a question-specific "negative condition" (e.g., act as a "careless reasoner") conditioned on its own initial rollout, instantiating a negative teacher π_neg from the same frozen base weights. A token-level adaptive gating function G_t = max(0, π_neg − π_ref) compares this negative teacher against a benign reference model π_ref to isolate only tokens whose likelihood is abnormally boosted by the negative condition (filtering out ordinary linguistic/style tokens). The isolated tokens are penalized via a Sigmoid-bounded Gated Unlikelihood (GU) loss (avoiding gradient explosion on high-confidence tokens), combined with a point-wise forward-KL regularization term anchored to π_ref; trained on Qwen3-1.7B/4B/8B using the MATH dataset without gold labels.

Key results:

• Average gains (Avg@8) across 7 math benchmarks (AIME 24/25/26, HMMT, AMC, OlympiadBench, MATH-500): +2.3% (1.7B), +7.5% (4B), +6.0% (8B), outperforming OPSD, Intuitor, and TTRL baselines at all scales, with p<10⁻⁴ for 4B/8B.
• On Qwen3-4B: AIME 2024 jumps from 23.8 to 35.8, AIME 2025 from 20.4 to 31.3, AMC 2023 from 68.8 to 76.3.
• Reflection-token frequency (Qwen3-4B, "Wait" tokens per response) rises from baseline 3.6 to 7.5 under NSD, versus drops to 2.2 (OPSD) and 0.8 (Intuitor).
• Training efficiency: 68s/step (NSD online) vs. 105s (OPSD) and 187s (Intuitor) on 6-8 A100s; a lightweight "wiki-irrelevant" negative-conditioning variant cuts this to 54s while achieving comparable gains (6.6% vs 7.8% average improvement).
• Style-task token ratio (lower=better filtering): NSD gating achieves 2.6-3.5× versus 3.9× (entropy-based OPSD weighting) and 5.4× (vanilla OPSD).

Why it matters / caveats: NSD removes reliance on ground-truth answers or external teachers entirely while avoiding the overconfidence/reflection-collapse problem of OPSD and confidence-based RLIF methods (Intuitor, TTRL), and is more computationally efficient since it needs only a single rollout and scalar (not full-vocabulary) supervision. The authors note NSD depends on the student's own capacity to generate meaningful negative conditions, so it may be less effective for very small/weak models.

Problem: Low-bit quantization of the attention module in long-context LLM inference introduces large errors because uniform, token-agnostic precision allocation fails to account for a small number of highly sensitive, persistently attended token positions.

Method: HyQuant is a hybrid-precision quantization framework that partitions key/value positions per layer/head into three disjoint sets: vertical-line tokens (identified via a lightweight running column-wise attention-mass score, top-ρ≈5% of the non-window prefix), a fixed local sliding window (W=128), and the remaining majority — keeping the first two in full precision (FP16/BF16) and quantizing the rest to low-bit (INT8/FP8 or 4-bit K/V). In the Prefill stage it uses a fused hybrid-precision attention operator that runs a segmented FlashAttention-style online softmax over the quantized, vertical-line, and window regions in a single kernel; in the Decode stage it stores a low-bit KV cache (K4V4) for the quantized majority while retaining vertical-line/window entries in full precision, and fuses on-the-fly KV dequantization with attention computation ("dequantize-in-attention" rather than "dequantize-then-attend"). Vertical-line identification adds negligible overhead (a matmul every 64 tokens).

Key results:

• Evaluated on Qwen3-8B, Qwen3-32B, Llama-3.1-8B-Instruct, and GLM-4-9B-0414 on LongBench v1, GSM8K, and MATH500.
• Achieves 1.32× to 3.58× decode-kernel speedup and 1.04× to 1.17× end-to-end decode speedup over FlashAttention-2 (FA2), with speedup rising with prefix length (3.58× at 32K).
• LongBench v1 average on Qwen3-8B: HyQuant 45.04 vs. FA2 44.59, vs. KIVI (K4V4) 37.68, SageAttention 38.13, KVTuner (4bit) 40.45 — HyQuant nearly matches or exceeds full precision while beating strict low-bit baselines.
• On Qwen3-8B math reasoning: HyQuant 96.52 GSM8K / 78.73 MATH500 vs. FA2 95.88/80.14, vs. KIVI 92.48/72.89, SageAttention 94.99/77.60.
• At batch size 16 on a single H100, HyQuant achieves 231.6 tokens/s while FA2, KIVI, and KVTuner all OOM; vertical-line identification overhead is only 3–5% of runtime; keeping 5% vertical-line tokens increases non-window KV cache size by ~15%.
• Prefill-stage MSE (vs. FA2 reference): retaining top-5% high-score positions in full precision approaches 8-bit quantization error levels and yields large MSE reduction over SageAttention across layers.

Why it matters / caveats: By exploiting the observation that vertical-line/attention-sink-like positions concentrate the majority of attention mass across model families (Qwen3, Gemma4, Llama3, Qwen3.5), HyQuant offers a way to get near-lossless accuracy with aggressive 4-bit KV quantization and strong decode speedups, particularly benefiting long chain-of-thought inference and high-batch serving. Caveats: benefits are most visible in long-context settings (less improvement for short-context tasks), evaluation is limited to models up to 32B on H100 GPUs, and effectiveness in agentic/coding settings is untested.

Problem: Reasoning language models overwhelmingly reason in English even when prompted in other languages, creating a multilingual reasoning gap ("L2 reasoning" failure) that risks losing prompt intent, forgoes target-language knowledge, and excludes non-English-speaking users from inspecting reasoning traces.

Method: Starting from the 3.35B-parameter multilingual Tiny Aya base model (context-extended from 8K to 32K tokens), the authors build Tiny Aya L2-Thinker via SFT on a dual-mode mixture of three data sources: English reasoning (ER) traces (from AM-Thinking prompts with gpt-oss-120b-generated traces, plus Dolci-Think-SFT-32B and Open-Thoughts-114K for the final model), multilingual reasoning (MR) data created by translating English reasoning traces into 44 target languages using command-a-translate and DeepSeek-V3 (capped at ~5K samples/language, "translate-train" approach with heavy filtering of translation-unfriendly examples), and multilingual non-reasoning (NR) instruction data (~4.9M samples across 67 languages, tagged with empty reasoning blocks) to prevent catastrophic forgetting of non-reasoning-supervised languages. All three sources are jointly trained (multi-task) rather than sequentially adapted or merged.

Key results:

• Tiny Aya L2-Thinker achieves >93% L2 reasoning rate across 60 languages on 6 benchmarks (MGSM, PolyMath, MIST-OEG, Marco-Bench-MIF, GlobalPIQA, Macaron-MCQ), covering 45 trained reasoning languages.
• Outperforms language-forcing on Qwen3.5-4B (thinking-prefix LF) on every benchmark's L2 rate and beats M-Thinker-7B (87.7–96.5% L2 rate) on 5 of 6 benchmarks despite being half the size; exceeds Magistral-Small-24B (a 24B model) on all tasks by a considerable margin.
• Switching from English to in-language reasoning costs at most 2–3% accuracy on 5 of 6 tasks (the exception: PolyMath, 11.1% vs. 18.6% for the English-reasoning counterpart).
• On low-resource language tiers, L2 rate stays 94.3–94.5% (tiers 3–4) vs. Magistral-Small-24B collapsing from 72%→5% and M-Thinker-7B falling from 99.6%→71.6% (with task accuracy dropping from 48.8%→23.5%).
• Model uses under 2,000 average thinking tokens with markedly lower 4-gram repetition ("doomlooping" proxy) than Qwen3.5-4B with language forcing.
• Broadening language coverage (1-lang specialists → 2-lang regional → all-10-lang joint model) increases unseen-language L2 reasoning rate monotonically without hurting seen-language accuracy or L2 rate ("no interference," contradicting the expected curse of multilinguality).

Why it matters / caveats: Demonstrates that in-language reasoning can be achieved at small scale (3.35B) with only a small amount of translated reasoning data per language, largely through careful multi-task data mixing rather than reasoning supervision in every language — suggesting reasoning is a largely language-agnostic, transferable behavior. A caveat is the lack of an RL refinement stage, which the authors note limits competition-level math performance (PolyMath) relative to models like Qwen3.5-4B.

Problem: In neurosymbolic systems that translate natural-language problems into formal logic for a solver (e.g., Z3), a candidate encoding can be syntactically valid and return the same solver verdict as the correct reference while still being logically non-equivalent to it — a failure the authors call Verdict-Preserving-Unfaithfulness (VPU), which binary solver checks are provably unable to detect (proven to be exactly 0.5 AUROC on verdict-matched pairs).

Method: The authors introduce Generative Verification (GenV), which distills an offline, bidirectional Z3-equivalence oracle (checking mutual implication between candidate and reference assertions) into a reference-free verifier: a 27B LM with frozen base and LoRA adapters is fine-tuned via masked causal cross-entropy to output a single "Yes/No" token judging whether a candidate SMT-LIB encoding faithfully formalizes a problem, and the continuous verification score is computed as renormalized next-token probability mass (P(Yes)/(P(Yes)+P(No))) rather than via an appended classification head. The deployed model, GenV+HN, is further trained on oracle-guided hard negatives generated by mutation operators (flipping relational operators, perturbing constants, reversing implications) that are validated by Z3 to be genuinely VPU. Mechanistic analysis uses a "decision-projected gradient lens" (gradient-times-activation attribution) and a TopK sparse autoencoder on layer-48 activations to probe whether error localization is recoverable from hidden states.

Key results:

• GenV+HN achieves 0.961 AUROC on a 950-row authentic translator-output benchmark (0.955 on a 652-row text-disjoint subset), versus 0.500 for solver-verdict-only checks, 0.762/0.756 for matched-capacity outcome/process reward models, and 0.863 for 5-sample self-consistency.
• Zero-shot OOD generalization across six logic-style benchmarks: 0.964 (ProverQA), 0.925 (MALLS), 0.915 (ProntoQA), 0.842 (ProofWriter), 0.830 (FOLIO), 0.642 (LogicNLI) — consistently beating token-head PRM/ORM baselines.
• Ablation: generative P(Yes) readout reaches 0.983 AUROC vs. 0.920–0.921 for 2-class classification heads and 0.633–0.827 for per-step token heads with PRM/ORM labels.
• Beats GTED tree-edit distance (0.835), FormalAlign (0.752), and round-trip back-translation (0.578) on an expanded 488-row alignment benchmark (GenV: 0.950 AUROC).
• In agentic test-time compute allocation (Proof of Thought), GenV+HN drives accuracy from 0.655 to 0.768 (+11.3 points), with gains replicated across 12 different generator backends (e.g., +42.6 points for gpt-oss-20b, +21.4 for Qwen3-Next-80B).
• A frozen, detection-only model's internal states (via gradient lens and SAE probes) recover VPU/error-localization signal with 0.960 AUROC without explicit localization training.

Why it matters / caveats: This provides a cheap, reference-free safeguard for solver-based reasoning pipelines that closes a blind spot standard structural checks (typing, self-consistency, solver verdicts) cannot address. Limitations: it targets strict Z3-equivalence rather than subjective human intent (a competent-reader panel judge outperforms it on "panel-majority intent" alignment, 0.778 vs 0.679 AUROC), relies on synthetic single-edit mutations that may not capture correlated multi-error patterns, and providing its score as advisory feedback alone does not improve accuracy without added sampling budget.

Problem: Late-interaction retrieval (e.g., ColPali/ColBERT-style models using MaxSim over ~1,000 patch vectors per page) gives state-of-the-art visual document search accuracy but at large storage cost, and existing compression methods (pooling, pruning, quantization) degrade sharply below roughly 16 vectors per page, while alternatives that reach smaller budgets require retraining the encoder and re-encoding the whole corpus.

Method: The authors first show empirically (via the TwoNN intrinsic-dimension estimator) that page token clouds from three frozen encoders (ColPali, ColQwen2, Nemotron v2) sit on the unit sphere with intrinsic dimension only ~5–6, and prove that standard k-means centroids of unit vectors lie strictly inside the sphere, systematically underestimating MaxSim (Proposition 1) — a free fix is to renormalize centroids to the sphere ("spherical anchoring"). Building on this, they introduce Generative Late-Interaction Embeddings (GLIE): a 415K-parameter, zero-initialized cross-attention refiner adjusts normalized centroids by reading the full token set (starting exactly at normalized k-means), and a shared decoder with count-proportional slots, an exact-anchor guarantee (each cluster's slot-0 output reproduces its stored vector verbatim, so MaxSim can only improve, never degrade, under regeneration), and bounded angular displacement (≤0.75 rad step) regenerates the full N-vector set for the top-L=20 candidates at query time. Training uses five losses (per-query-token MaxSim matching, listwise KL ranking, a one-sided overshoot penalty, within-cluster Chamfer distance, and a support-function/extreme-point matching term), fit on just 1,000–5,000 pages in under 3 GPU-minutes.

Key results:

• On ViDoRe v1 at k=4 vectors/page, GLIE reaches 79% of uncompressed nDCG@5 (0.657 vs. 0.836 uncompressed) vs. 70% for the best prior post-hoc method (token pooling: 0.584); at k=2, GLIE gets 0.597 vs. 0.464 (raw k-means) and 0.553 (token pooling).
• Spherical anchoring alone is worth +0.031 to +0.093 nDCG@5 over raw centroids, shrinking as k grows.
• At matched training budget (~1.5 GPU-hours, 4,000 pages), LoRA fine-tuning the encoder (Light-ColPali reproduction) does not even reach the free normalized-clustering baseline (e.g., 0.544 vs. 0.605 at k=4), while GLIE (frozen backbone, 415K params, <3 GPU-min) beats fine-tuning by +0.074 to +0.132 at every budget.
• Results transfer to ViDoRe v2 (GLIE reaches 64% of uncompressed at k=4 vs. 24% for raw k-means) and to a second encoder, ColQwen2 (82% of uncompressed at k=4, winning at 5 of 6 budgets over spherical anchoring alone).
• Storage: k=4 needs 1,040 bytes/page vs. 257.8 KB uncompressed (a ~248x reduction; 1M pages shrink from 258GB to 1GB).
• Decomposition shows most residual error at k=4 is "decode fidelity" (0.657→0.782 oracle) rather than shortlist recall (0.782→0.836 ceiling), identifying the decoder as the main remaining lever; decoder capacity ablation (184K to 13M params) changes nDCG@5 by at most 0.009, showing the small size is not undertrained.

Why it matters / caveats: GLIE offers a corpus-independent, frozen-encoder alternative that beats far more expensive fine-tuning approaches at aggressive storage budgets and requires no re-encoding when budgets change. Limitations: gains shrink or vanish at very low k=2 (below the manifold's intrinsic dimension) and at high budgets (k≥32) where clustering already nears the ceiling on saturated benchmarks; the approach is evaluated only on document image retrieval with single-codebook late-interaction encoders, and the authors note substantial headroom remains in decoder design.

Problem: Existing all-in-one medical image restoration (MedIR) methods focus on modeling inter-task heterogeneity but ignore both the shared anatomical homogeneity across tasks/modalities and fine-grained intra-task heterogeneity (e.g., scanner/center/patient variation), limiting generalization as more tasks are added.

Method: UniH3 is a U-shaped restoration backbone built from Homogeneity-Guided Transformer Blocks (HGATBs) that combine two innovations: (1) a Hierarchical Homogeneity Memory (H2M) module with a momentum-updated memory bank (task-specific + task-shared slots) that distills HQ anatomical priors via EMA during training and retrieves them via cross-attention at inference, injected into the network through a Homogeneity-Guided Attention (HGA) mechanism that anchors attention on retrieved HQ priors rather than degraded LQ features (implemented via transposed self-attention following Restormer); and (2) a Hierarchical Heterogeneity Balancer (H2B) that extends uncertainty-based loss balancing with a per-task learnable term plus a per-sample correction predicted by a lightweight Uncertainty Estimation Block, jointly addressing inter- and intra-task conflicts. The model is trained with the Muon optimizer on two new benchmarks the authors construct: MedIR-2D-500K (509,200 pairs, 7 tasks: PET/CT/MRI/X-ray/OCT/ultrasound/pathology) and MedIR-3D-3K (3,522 volume pairs, 3 tasks), with a 3D variant (UniH3-3D).

Key results:

• On MedIR-2D-500K all-in-one setting, UniH3 (28.96M params, 26.33 GFLOPs) outperforms all 12 compared methods on all 7 tasks, beating the second-best AdaIR by 0.21 dB average PSNR (36.77 vs 36.56 dB).
• On MedIR-3D-3K all-in-one setting, UniH3-3D beats the second-best Restore-RWKV-3D by 0.55 dB average PSNR (44.50 vs 43.95 dB).
• Single-task setting: +0.15 dB PSNR over second-best MambaIR (2D) and +1.48 dB over second-best Spach Transformer (3D).
• Component ablation: H2M alone +0.14 dB, H2B alone +0.12 dB, both combined +0.25 dB PSNR over baseline (36.52→36.77 dB); H2M and H2B each also improve other backbones (Uformer, Restormer, PromptIR, AdaIR) when added.
• HGA outperforms SFT-based and cross-attention-based guidance alternatives (36.77 dB vs 36.74 dB and 36.67 dB respectively) at lower parameter/FLOP cost.

Why it matters / caveats: Demonstrates that explicitly modeling cross-modality anatomical homogeneity alongside fine-grained heterogeneity yields consistent, non-trivial gains for general-purpose medical image restoration models, and the released MedIR-2D-500K/3D-3K benchmarks (500K+ pairs) could become a standard testbed. Gains per task are moderate (fractions of a dB in many cases), and the approach adds complexity (memory bank, uncertainty block) relative to simpler backbones.

Problem: Research-idea specifications handed to human or AI implementers can be novel and scientifically plausible yet still leave core method-defining choices omitted, ambiguous, or inconsistent, causing coding agents to silently implement the wrong method rather than seek clarification.

Method: The authors introduce IdeaAMBIG, a benchmark of 660 evidence-grounded, single-defect instances built from three sources: 163 real-world gaps mined from GitHub issues (4,106 closed issues across 50 paper-linked repos, filtered/classified/decomposed with DeepSeek-V4-Pro and validated with GPT-5.5) and reproducibility reports (ML Reproducibility Challenge, ECIR, TMLR), plus 497 controlled synthetic instances created by altering exactly one implementation-critical detail in a codification-ready reference (derived from papers with verified successful reproductions, and from 43 executed projects in the AI-Researcher study, 19 human- and 24 LLM-generated ideas). Each instance is labeled with a Level-1 type (Ambiguity, Incompleteness, Inconsistency) and one of 10 Level-2 categories, and pairs a NOT_READY specification with a READY counterpart and a gold clarification action. The benchmark evaluates three tasks: (1) readiness assessment (READY vs. NOT_READY), (2) defect localization without any hint (Level-1/Level-2 labels + defect description), and (3) clarification action generation given the annotated defect (a clarification question or evidence-seeking instruction).

Key results:

• Across 13 LLMs (GPT-5.6-Sol, Claude Sonnet 5, Gemini 3.1 Pro Preview, DeepSeek-V3.2, Qwen3.5-397B-A17B, DeepSeek-R1-0528, GLM-5.2, Kimi-K3, GPT-OSS-120B, Gemma-4-31B-IT, Qwen3.5-9B, Qwen3-8B, Qwen3-32B), the best model (GPT-5.6-Sol) achieves only 9.6% Macro Defect Recovery Rate (Task 2) on real-world instances, vs. 80.6% Macro Clarification Action Success Rate (Task 3) when given the annotated defect — a large gap showing localization is the bottleneck, not clarification.
• Readiness assessment (Task 1) Macro-F1 ranges from ~30% (Kimi-K3) to 67.5% (GPT-5.6-Sol) on real-world instances, and up to 96.2% Macro-CAS on synthetic instances for the top model.
• Oracle study: supplying the gold resolution raises the downstream codification-ready rate from 14% to 98%, completeness from 30% to 98%, and missing-detail recovery from 14% to 98% (all statistically significant).
• Small-scale executable validation: code generated from clarification-assisted specifications is runnable 95.0% of the time vs. 70.0% for direct generation, passes all instance-specific tests 85.0% vs. 45.0%, and target fidelity rises from 30.0% (direct) with clarification.
• Human validation: blind review of 50 real-world and 50 synthetic instances shows 92–98% positive judgments for gap validity, implementation criticality, clarification sufficiency, and realism; inter-annotator agreement is high (readiness κ=0.84/0.92, Level-1 κ≥0.89, Level-2 κ=0.92/0.85 for real/synthetic).

Why it matters / caveats: The results show today's LLMs (including frontier models) are far better at resolving a known specification gap than at discovering it, suggesting research-automation pipelines need explicit gap-localization mechanisms before code generation to avoid silently implementing the wrong method; the study's oracle and executable-validation experiments use small samples (50 instances) and single-defect instances, so findings on multi-defect or higher-stakes specifications remain an open question.

Problem: Multilingual multimodal entity linking systems degrade sharply on rare entities, but prior work measures rarity only through popularity proxies (e.g., pageviews), which misses many culturally niche entities that are unpopular for different structural reasons.

Method: The authors introduce a multidimensional rarity characterization using Wikipedia-based metrics (pageviews, backlinks, article size, revision count, etc.) and Wikidata-based structural metrics (incoming/outgoing links, language editions, statement count, qualifier count, entity age) to define bottom-5% "rare" entity slices on the MERLIN benchmark (Hindi, Indonesian, Japanese, Tamil, Vietnamese). They then propose a training-free, two-module pipeline built on Qwen3-VL (Thinking and Instruct variants, 2B/4B/8B): Module 1 is a reasoning-capable VLM that iteratively issues search queries (up to 20 iterations) against an English Wikipedia retrieval corpus (via BM25 lexical search over the wikimedia/structured-wikipedia dataset, or semantic retrieval using intfloat/multilingual-e5-large-instruct embeddings + FAISS), and Module 2 re-prompts the model on its own reasoning trace to extract the final Wikipedia title. A factorial design (model size × Thinking/Instruct × No-RAG/BM25/Embedding) isolates the contributions of reasoning, retrieval, and scale.

Key results:

• Best system (8B-Think+Embed) reaches 87.9% average accuracy on MERLIN, +6.9% over the SOTA baseline Cultural Pangea (81.1%), with per-language gains up to +10.0% (Hindi, Indonesian).
• Gains grow much larger on rare-entity slices: +23.3% on qualifiers, +22.1% on statements, +21.7% on Wikidata outgoing links (vs. +6.9% on the full set); Cultural Pangea itself drops 15.4–39.9% on bottom-5% rarity slices.
• Cultural Pangea's bottom-5% rarity sets overlap by only 37% on average across metrics, showing popularity-based rarity misses many structurally rare entities.
• Reasoning alone (Think vs. Instruct, no RAG) is not statistically significant on rare splits (p>0.5), but retrieval's benefit for the 8B-Think model grows from +3.8% (full set) to +18.8% (language-editions rare slice), a 5.0× increase — reasoning and retrieval are complementary, not independently sufficient.
• BM25 retrieval hurts Instruct models by −4.9% on the full set but helps by +8.1–12.6% on rare slices (instruct models flood context with 3.2–3.7 unfiltered searches/example vs. 1.0–2.2 deliberate searches for Thinking models).
• A 4B-Think+Embed model matches 8B-Instruct on the full set (83.7% vs. 83.5%) and beats it by +5–7% on rare entities, at ~2.8× more inference tokens.
• Error analysis: retrieval failure (correct entity never surfaced) accounts for 72% of residual errors; rare-entity error rate is 31.1% vs. 8.4% for head entities.

Why it matters / caveats: The work shows popularity-based rarity metrics substantially underestimate difficulty on the "cultural long tail," and that combining reasoning with iterative retrieval — rather than either alone — is what closes much of the gap, offering an alternative to simply scaling models. Caveats: evaluated only on Qwen3-VL (cross-family generalization only partially checked via GLM), limited to five languages where all entities have English Wikipedia articles, and retrieval failure (especially cross-lingual/transliteration mismatch) remains the dominant unresolved bottleneck.

Problem: AI systems for interpreting invasive coronary angiography (CAG) either remain narrowly discriminative or generate free-text diagnoses without auditable spatial evidence linking conclusions to image regions, limiting clinician trust and adoption.

Method: CARDEA is a single large vision-language model (built on Qwen3-VL-30B-A3B-Thinking) that runs an end-to-end two-pass CAG pipeline: pass 1 does per-video keyframe selection and view classification to curate a compact multi-view frame set; pass 2 performs study-level Chain-of-Box (CoB) reasoning—embedding bounding boxes as spatial anchors inside the reasoning trace—for dominance classification, complexity assessment, and report generation. Training uses three stages on five reformulated public datasets (ARCADE, CADICA, CoronaryDominance, CardioSyntax, plus PubMedVision for negatives): (1) visual feature alignment SFT on vessel/stenosis detection and keyframe/view tasks, (2) a self-distilled CoB "cold start" where the untuned base model generates reasoning traces from Stage-1 boxes that are kept only if they reach the correct answer, and (3) RLVR with a conditional CoB reward (extra reward for using bounding boxes, but only when the final answer is correct) restricted to study-level tasks; report generation is deliberately excluded from all training and evaluated zero-shot on the held-out AngioCAD cohort.

Key results:

• Trained closed-ended tasks: stenosis detection F1@IoU≥0.5 0.37 (vs. 0.36 DCA-YOLOv8); vessel detection 0.50 (vs. 0.47 DeepCoro Algorithm 4); view classification MacroF1 0.99; dominance classification accuracy 0.94 (Real, vs. 0.97 ConvNeXt baseline) but 0.91 under Domain Shift (vs. 0.89 baseline, statistically comparable); complexity assessment accuracy 0.90 vs. two cardiologists' 0.90 and 0.88.
• Zero-shot on external AngioCAD: RCA stenosis Lesion-F1 0.85 vs. 0.81 for the Adaptive Feature Fusion baseline; view classification F1 0.90 vs. 0.95 for VGG19+LSTM.
• Report generation (vessel-severity macro-F1, VS-F1, 2-class): untuned base model 0.513, degraded under supervised Stage 1 (0.452) and Stage 2 (0.373), then RLVR raised it to 0.686 (final, thinking enabled) — more than double the always-normal floor of 0.312 and above the base model; only RLVR improved this zero-shot, untrained capability.
• Ablations show the CoB reward is needed to sustain grounding usage (drops to ~5% without it) while the cold start controls box scale/quality (median box area 0.01 of frame vs. 0.76 without cold start), with negligible effect on diagnostic accuracy either way.

Why it matters / caveats: Shows that RLVR on verifiable closed-ended tasks can surface open-ended clinical reasoning ability that supervised imitation actually erodes, and delivers a single auditable model spanning an entire CAG pipeline rather than a cascade of black-box modules. Caveats: no prospective clinical validation against expert cardiologists, some test sets are small (n=60, n=48 videos), CoB grounding usage falls to 65-75% out-of-distribution, and inference takes ~6 seconds/study on 4×B200 GPUs.

Problem: Conventional flat multi-agent reinforcement learning (MARL) architectures for cooperative air combat lack structured relational modeling of time-varying interactions among battlefield entities and lack explicit tactical role modeling, leading to ambiguous task allocation and poor emergence of coordinated tactics (e.g., leader-wingman decoy maneuvers).

Method: DRG-MAPPO builds on MAPPO with CTDE (centralized critic, decentralized actors) and adds three components: (1) a per-agent entity graph (self/ally/enemy/missile nodes with heterogeneous relative-feature vectors) processed by a scaled dot-product graph attention encoder producing self, agent-level, and team-level representations; (2) a hierarchical policy where a high-level role policy assigns discrete tactical roles (e.g., "leader"/"supporter") via a learned role-embedding table, gated by a temporal commitment mechanism that only re-samples roles every T_role steps to prevent oscillation, and a low-level policy that selects one of 12 discrete maneuver/weapon actions conditioned on the role embedding and graph features; and (3) a target-priority auxiliary task, trained with cross-entropy against a heuristic priority-scoring label (based on distance, radar-lock status, and already-tracking-missile count), that shares the graph encoder to encourage emergent focus-fire without explicit reward shaping. The full objective combines PPO clipped surrogate losses for both action and role policies, a critic MSE term, the auxiliary CE loss, and entropy bonuses.

Key results:

• DRG-MAPPO achieves an 87% win rate in a 2v2 Beyond-Visual-Range simulation (200km×100km theater, C++ engine with GTacview visualization), the peak among tested methods, versus MAPPO+GAT and HAPPO at moderate improvement levels and QMIX/IPPO performing worst.
• Converges to the highest asymptotic average episodic reward (~950) versus mid-tier baselines plateauing between 500–650.
• Round-robin cross-play tournament (200 episodes/pairing) gives DRG-MAPPO a 69.9% average win rate against all baselines, with head-to-head win rates against MAPPO+GAT/HAPPO/MAPPO/QMIX/IPPO of 0.608/0.654/0.735/0.812/0.876 respectively.
• Ablation study shows all four components (graph-based modeling, dynamic role assignment, target-priority auxiliary task, temporal commitment) contribute; removing temporal commitment causes destabilizing role oscillation and performance fluctuation.
• Qualitative case studies show emergent bait-and-flank and focus-fire tactics, including a supporter agent dynamically transitioning from bait/defensive posture to offensive strike.

Why it matters / caveats: The framework demonstrates that decoupling macro-level tactical role assignment from micro-level maneuver control, combined with graph-based relational encoding, meaningfully improves both performance and interpretability of emergent cooperative tactics in a demanding air-combat MARL setting. Evaluation is limited to a single 2v2 scenario in a custom simulator; scalability to larger swarms and validation against real or higher-fidelity flight dynamics is left to future work, and no statistical significance testing (e.g., confidence intervals across seeds) is reported for the headline win-rate numbers.

Problem: LLM-generated peer review feedback tends to be descriptive (identifying problems) rather than prescriptive, failing to give authors concrete, grounded guidance on how to revise their papers.

Method: The authors formulate "Actionable Peer-review Generation" as a dual-task problem (diagnostic claim generation + actionable suggestion generation) and build ActReview-40K by mining OpenReview review-rebuttal threads across ICLR/NeurIPS/EMNLP (15,819 papers, ~40K weakness-response instances), using a four-stage pipeline (atomic weakness extraction/labeling, weakness-rebuttal alignment, GPT-5.4-based rebuttal-guided feedback enhancement, and localized top-k chunk evidence retrieval) that treats rebuttals as latent supervision rather than direct training targets. They post-train Qwen3-8B-Base with multi-task supervised fine-tuning (ActReview-SFT) followed by GRPO (ActReview-RL) using candidate-aware, weakness-specific rubric rewards synthesized by GPT-5.4 from diverse SFT-sampled candidates plus human/GPT references. They also construct ActReview-Bench, a 1,000-instance human-curated benchmark with the same rebuttal-grounded methodology.

Key results:

• ActReview-RL improves over the best baseline by up to +7.27 ROUGE-L and +8.05 BLEU (Task 2), and +4.35 ROUGE-L (Task 1), versus GPT-5.1, Gemini-3.1-Pro-Preview, DeepReviewer-14B, OpenReviewer-8B, RbtAct-8B, and Qwen3-32B.
• Pairwise LLM-judge (GPT-5.4) and human evaluation (200-instance subset, 93% inter-annotator agreement) both show ActReview-RL clearly preferred over specialized review-generation baselines (e.g., adjusted win rate up to 84.4 vs. OpenReviewer-8B on Task 2 Actionability), while remaining closer to parity against frontier LLMs like GPT-5.1/Gemini.
• Reward-design ablation: candidate-aware rubric GRPO reaches 69.3/73.4 (T1/T2 Overall) vs. 65.1/68.7 for direct judge reward and 60.7/61.0 for a fixed task-level rubric.
• On 175 held-out 2025-2026 papers, ActReview-RL has the lowest severe technical-error rate (6.29%) among all systems and an overall technical-error rate (28.00%) no higher than baselines; it correctly abstains on 78.3% of 360 non-supported weakness-paper pairs while keeping a 95.4% answer rate on supported ones.
• Two-task SFT formulation beats end-to-end SFT by +0.42 on Task 2 Overall and +0.35 on Claim-Suggestion Alignment.

Why it matters / caveats: Shows that author rebuttals are an underused, scalable supervision signal for training review models toward actionable, grounded feedback, achieving competitive results with an 8B model against much larger proprietary LLMs. The authors note the benchmark is restricted to "rebuttal-resolvable" weaknesses (excluding novelty disputes or irreparable flaws), technical accuracy still lags frontier LLMs, and GPT-5.4 is reused across data construction, reward, and evaluation, raising judge-model coupling concerns.

Problem: In ROS 2/DDS systems, a single network-impaired or throttled RELIABLE subscriber can fill the publisher's writer history and cause backpressure that degrades throughput and latency for all subscribers sharing that writer, including safety-critical ones.

Method: Adaptive Bridge is a middleware-layer proxy inserted between publisher and subscribers with four components: a Proxy Node that subscribes to the original topic and republishes it through two independent DDS writers (RELIABLE/KEEP_LAST-10 for critical subscribers, BEST_EFFORT/KEEP_LAST-5 for noncritical ones) — i.e., "topic splitting" that structurally isolates writer history queues; a Classifier Node that sends 5 Hz active RTT/loss probes over a dedicated BEST_EFFORT topic and runs a per-subscriber hysteresis state machine (demote at RTT>50ms or loss>1.5% for 3 consecutive evaluations, promote at RTT<35ms and loss<0.5%) to label subscribers CRITICAL/NONCRITICAL/UNKNOWN; a Policy Engine that applies token-bucket rate limiting (10 Hz normal, 3 Hz degraded), stale-message dropping (>200ms), and queue-overflow protection only on the noncritical path; and a Safety Supervisor that watches proxy health and enters DEGRADED/EMERGENCY modes. Evaluated on a reproducible four-container Docker testbed with Linux tc netem applying a Gilbert-Elliott bursty loss model to only the slow subscriber's path, across Fast DDS and Cyclone DDS RMWs.

Key results:

• Baseline (no bridge): under impairment, publisher throughput collapses 29–36% (to 19.2–21.4 Hz from 30 Hz) and critical-subscriber p95 latency reaches 11.7–15.0 s.
• With Adaptive Bridge: publisher throughput stays at 30.0 Hz across all impairment levels (rate std 0.0 Hz) and critical p95 latency never exceeds 1.57 ms — a ~9,700x reduction under strong impairment (15,043 ms → 1.55 ms).
• Cross-RMW validation (Fast DDS vs Cyclone DDS): critical-subscriber p99 latency stays below 2 ms and throughput at 30.0 Hz on both, despite the two RMWs handling backpressure differently (non-blocking backlog vs. blocking write).
• Ablation isolating topic-splitting from the adaptive classifier: topic splitting alone gives nearly identical critical-path latency (p95 1.57 ms vs 1.55 ms with classifier), so the classifier's benefit is confined to cutting noncritical bandwidth (~70% reduction, 10 Hz→3 Hz) during impairment, not to critical-path protection.
• Bridge adds only ~0.4 ms of extra latency in clean conditions (p50 0.65 ms → 1.07 ms).

Why it matters / caveats: Provides an application-layer, non-invasive fix (no DDS/RMW/publisher changes needed) for a known ROS 2 backpressure coupling problem, portable across RMW implementations. Limitations acknowledged by the authors: proxy CPU/memory overhead wasn't measured, the proxy is a single point of failure, classification is reactive (~20s detection latency) so short intermittent impairments may be missed, and the Gilbert-Elliott parameters are illustrative rather than validated against real Wi-Fi traces.