AI papers — 2026-07-03

Problem: Long-horizon LLM agents lack a bounded, inspectable memory interface for isolating which components of accumulated context (observations, tool calls, reflections) actually drive success or failure.

Method: The authors introduce AgenticSTS, an agent built on a "bounded-memory contract" in which every decision prompt is freshly composed by typed retrieval from five slots (L1 fixed protocol instructions, L2 state-specific schemas/legal actions, L3 retrieved game rules, L4 episodic summaries, L5 triggered strategic skills) rather than appending a raw cross-decision transcript. It is instantiated in the roguelike deck-building game Slay the Spire 2, with a dispatcher routing decisions to four model tiers (fast, strategic, analysis, evolution), a fixed-A0 five-cell ablation design (baseline-strict, prompt-only, mode-a, mode-b-frozen, full-frozen), a cross-backbone probe swapping the underlying LLM (Gemini 3.1 Pro, Qwen 3.6 27B, DeepSeek V4 Pro), and an auto-mode ascension ladder protocol. Statistical analysis uses Wilson 95% confidence intervals for win rates, 5,000-sample bootstrap intervals for scores, and Fisher exact tests.

Key results:

• Public AGI-Eval benchmark: zero A0 wins across five frontier-model configurations; developer-reported human win rate at A0 is 16% (Mega Crit, 240M community runs).
• Fixed-A0 matrix (N=10/cell): no-scaffold baseline wins 3/10 (score 70.4); prompt-only wins 4/10 (score 69.6); all three L5-skill-scaffolded cells win 6/10 (scores 85.5, 83.3, 82.1).
• Fisher exact test on 3/10 vs 6/10: p ≈ 0.37 (directional, not statistically significant).
• Cross-backbone transfer of Gemini-trained L4+L5 stack (N=5/cell): Qwen 3.6-27B score rose 14.6→26.9 (+84.5%) but wins stayed 0/5; DeepSeek V4-Pro score fell 41.3→33.8 (−18.1%).
• Accumulating-context agents need ~4× the wall-clock per floor reached and spend 66–90× more fresh LLM tokens per score point (up to >450× under raw ingested context).
• Released archive: 298 completed trajectories with condition tags, frozen memory/skill snapshots, prompt records, and analysis scripts.

Why it matters / caveats: The bounded, typed-retrieval contract makes long-horizon agent memory auditable and individually ablatable, and the released dataset enables reproducible study of which memory layer drives performance; however, headline win-rate differences are directional rather than statistically decisive at N=10/cell, frozen skill transfer is backbone-sensitive, and evaluation is limited to one character, one game, and a training-free architectural scope.

Problem: Many everyday programming tasks (e.g., alerting on important log lines, repairing malformed JSON, ranking search results by intent) are "fuzzy functions" that resist clean rule-based implementation and are increasingly outsourced to costly, non-reproducible, non-local LLM APIs.

Method: The paper proposes Program-as-Weights (PAW), a two-stage compiler pipeline built on 4B Qwen3 models: a frozen Qwen3-4B-Instruct-2507 "pseudo compiler" rewrites a natural-language specification into a paraphrased pseudo-program with input-output examples, and a trained 4B Qwen3 "LoRA compiler" reads the spec plus pseudo-program and emits a LoRA adapter (rank r=64, N=64 shared bases per module type, ~38.5M parameters) via a LoRA mapper that mean-pools compiler hidden states and projects them into mixing coefficients over shared learnable bases. This LoRA is hot-attached to a frozen, lightweight interpreter (e.g., Qwen3 0.6B) for inference; the LoRA compiler is trained with supervised NLL on FuzzyBench, a 10M-example dataset generated with gpt-5.2 across 29 thematic versions and 800+ task categories.

Key results:

• PAW with a 0.6B Qwen3 interpreter achieves 73.78% exact match on FuzzyBench, outperforming direct prompting of Qwen3-32B (68.70%) while using ~50x less inference memory (~1.2 GB vs. ~60 GB).
• Quantized system runs at 31.6 tokens/s on a MacBook M3, from a ~430 MB GGUF base plus a ~23 MB per-program LoRA adapter.
• Text-to-LoRA (r=64) reaches 65.7% accuracy vs. prefix-tuning's 50.4% and the no-compiler prompting baseline's 9.8%.
• PAW exceeds full fine-tuning of the same 0.6B base by 15.4 percentage points.
• Under heavy combined noise (typos, grammar errors, formatting drift) PAW accuracy drops only ~3.7 points (0.6692 to 0.6326).
• On image-conditioned tasks (Qwen3-VL-4B compiler), PAW-LoRA outperforms VLM baselines up to 4B parameters on three CoSyn diagram tasks.
• A 10-PAW-function tool-calling pipeline scores 93% on TOOLCALL-15.

Why it matters / caveats: PAW reframes foundation models from per-input problem solvers into one-time "tool builders," enabling small, cheap, offline, reproducible local execution of fuzzy functions instead of repeated LLM API calls; however, on long-form structured generation (Im2LaTeX) the LoRA instantiation underperforms its prefix-tuning precursor because long examples crowd the small interpreter's context budget.

Problem: Existing evaluations of autonomous coding/self-improving agents collapse iterative policy improvement into a single final score or confound it with open-ended software-engineering progress, making it hard to isolate an agent's ability to convert bounded environment feedback into generalizable policy improvements.

Method: The paper formalizes "Autonomous Policy Evolution," where a harness-model agent repeatedly edits an executable Python policy (Policy class with reset/act methods) under a fixed episode budget, submitting candidates for visible train-episode rollouts while validation/held-out evaluation stay hidden. This is instantiated as the EvoPolicyGym benchmark's "Core16" suite (16 Gymnasium-compatible environments across Box2D, MuJoCo, MiniGrid, Robotics/Driving) with a shared 128-episode training budget. Four harness-model agents are evaluated: GPT-5.5 (Codex harness), Claude Opus 4.7, MiniMax-M3, DeepSeek-V4-Pro (Claude Code harness), scored by validation-selected held-out mean return and an aggregate rank score, plus AST-based classification of edits into "structural synthesis" vs. "parametric tuning."

Key results:

• GPT-5.5 achieves the highest Core16 aggregate rank score (0.891), 9 environment wins, top-two on all 16 environments.
• Claude Opus 4.7 ranks second (0.750), 5 wins, 12 top-two placements.
• MiniMax-M3 and DeepSeek-V4-Pro score only 0.531 and 0.359, each winning 1 environment.
• Uniform random policy baseline scores 0.109.
• On synthesis-dominant tasks, GPT-5.5/Opus 4.7 score 0.98/1.00 vs. MiniMax-M3/DeepSeek-V4-Pro at 0.19/0.03, solving none of three locked-door MiniGrid tasks.
• Synthesis-edit "hit rates": GPT-5.5 41%, Claude Opus 4.7 48%, MiniMax-M3 10%, DeepSeek-V4-Pro 3%.
• On BipedalWalker, only GPT-5.5 reached a positive high-return gait (held-out return 248.874); others stayed at negative timeline-best scores.

Why it matters / caveats: Strong autonomous policy evolution requires discovering task-appropriate structural mechanisms, not just tuning existing controllers. The authors note their AST-based diagnostics are conservative proxies rather than semantic proofs, since different topologies can implement similar behavior.

Problem: Existing hybrid attention layer-selection methods for Transformer-to-hybrid conversion rely on heuristic strategies that treat layer importance independently, overlooking interdependent effects under a global hybrid configuration, and are costly to scale.

Method: The paper proposes FlashMorph (Fast LAyer Selection for Hybrid MORPHing), which first distills an all-linear "morphable model" from a pretrained full-attention Transformer via layerwise hidden-state alignment, pairing each layer with a trained linear-attention branch (Lightning Attention, GLA, or Gated DeltaNet). It then freezes both branches and jointly optimizes a single learnable scalar gate per layer on synthetic long-context passkey retrieval data, using an alignment loss plus a linearization regularizer (λ=0.1); gates are discretized via Top-K selection under a full-attention budget, followed by KL-divergence logits distillation and long-context finetuning. Experiments use Qwen3-0.6B and Qwen3-1.7B backbones against Uniform, PostNAS, KL-LS, and HALO baselines.

Key results:

• FlashMorph requires only 20M layer-selection tokens versus 50B (PostNAS), 20B (KL-LS), 234M (HALO).
• On Qwen3-1.7B, layer selection costs 2.1 GPU hours vs. 2561.3 (PostNAS), 1071.8 (KL-LS), 15.4 (HALO) — a 1219.7× reduction vs PostNAS.
• On NIAH, the 1.7B FlashMorph model reaches 100% accuracy on NIAH-Single-1 across 32K–256K context, and 73.2% on NIAH-Single-3 at 256K vs. 22.8% for HALO.
• Inference: prefill speedups of 2.24× at 128K and 2.81× at 256K tokens; decode speedups of 1.56–2.07× at 256K–512K; scales to 512K-token prefill and 1M-token decode on a single GPU where Qwen3-1.7B OOMs.

Why it matters / caveats: By formulating hybrid layer selection as a joint, budget-constrained optimization over lightweight gates rather than heuristic scoring, FlashMorph substantially lowers the cost of converting pretrained Transformers into efficient long-context hybrid models. Results are demonstrated only on Qwen3-series 0.6B/1.7B backbones with specific linear-attention variants.

Problem: The field of LLM-based data agents lacks a comprehensive benchmark with realistic, diverse, fine-grained-labeled tasks needed to rigorously evaluate agent performance across real-world data science scenarios.

Method: The authors build AgenticDataBench using a hierarchical skill-extraction algorithm that decomposes 6,510 Stack Overflow data-science solutions into 29,602 stepwise skill descriptions via LLM prompting, embeds them with Qwen3-Embedding, reduces dimensionality with UMAP, and clusters (GMM + DBSCAN merging) refined recursively by LLM-based cluster splitting/merging to yield 433 representative skills. Real-world tasks are selected via greedy submodular maximization covering the most previously-uncovered skills; additional tasks for public datasets are synthesized via an LLM pipeline (skill-graph path sampling, data profiling, workflow generation). The resulting 344-task, 27.3 GB benchmark is evaluated against four agent harnesses (DA-Agent, Smolagents, Claude Code, CodeX) paired with three LLMs (Qwen3.5-397B-A17B, Kimi-K2.5, Claude Sonnet 4.6).

Key results:

• Benchmark spans 15 domains, 433 skills, 344 tasks (102 from real Ant Group business data, 242 generated), 123.1M rows, 35.0K attributes.
• Top overall performers (total score): CodeX (Kimi-K2.5) 48.8%, Smolagents (Qwen3.5) 47.1%, Smolagents (Claude 4.6) 46.7%.
• Claude Code (Claude 4.6) scored 46.6% vs. Claude Code (Kimi-K2.5) 43.3%, at only 1.5x the cost (vs. 4–6x elsewhere).
• Per-trajectory cost ranged from $0.06 to $1.66; token usage ranged from 123.7K to 1,091.2K tokens.
• Constructing the benchmark required over 1,560 person-hours (600 by 30 domain experts, 960 by 8 experts annotating generated tasks).

Why it matters / caveats: Skill-level analysis shows agents consistently struggle with heterogeneous/non-relational data regardless of harness or LLM, indicating current data agent harnesses have substantial, unevenly distributed gaps that aggregate benchmarks fail to expose.

Problem: Existing training-free multi-resolution acceleration strategies for text-to-image diffusion/flow-matching models perform upsampling in latent space and selectively modify partial regions, causing noticeable blurring or artifacts.

Method: The paper proposes MrFlow, a training-free staged low-to-high-resolution sampling pipeline for pretrained flow-matching models (FLUX.1-dev, Qwen-Image-20B): it samples a low-resolution latent via rectified-flow ODE Euler discretization (~12 steps), decodes with the pretrained VAE, applies pixel-space super-resolution via the pretrained Real-ESRGAN network, re-encodes with the VAE and injects low-strength flow noise (σt ∈ [0.1, 0.15]), then performs a single high-resolution Euler denoising step before final VAE decoding. MrFlow can be combined orthogonally with pretrained timestep-distillation weights (Pi-Flow, FLUX-schnell) without additional training.

Key results:

• Achieves more than 10x end-to-end speedup while keeping OneIG-Bench score within a 1% gap relative to native generation.
• On FLUX.1-dev (12+1 steps): 8.25x speedup, Geneval 0.63 (vs. native 1x: 0.66).
• On Qwen-Image (12+1 steps): 10.3x speedup, Geneval 0.86 (vs. native 0.88).
• Combined with Pi-Flow: up to 25.1x speedup on Qwen-Image with OneIG-Bench loss ≤1%.
• Competing training-free methods degrade far more at high speedup (e.g., Teacache/DB-Taylor Geneval collapses to 0.26/0.09 at ~9x on Qwen-Image).
• Real-ESRGAN outperforms interpolation, SwinIR, and OSEDiff for the SR stage on clarity/semantic-accuracy/efficiency balance.

Why it matters / caveats: MrFlow requires no training and is directly composable with distillation methods for compounded acceleration up to 25x. A caveat: if the SR output has diffuse blur rather than mainly high-frequency errors, the low-strength noise-injection premise breaks down, requiring more steps and reducing efficiency.

Problem: Existing video world models entangle physical dynamics with pixel rendering, causing dynamic objects to freeze, vanish, or lose visual identity when they exit the camera's field of view and later reappear, failing to sustain object permanence.

Method: WorldDirector decouples semantic motion orchestration from visual generation: an LLM (Gemini) plans 3D bounding-box and camera trajectories, projected into 2D Location Conditions that condition a diffusion transformer (built on pre-trained LingBot-World-Base) via channel-concatenation with the noisy latent. It adds an Appearance Binding mechanism injecting RGB features of dynamic objects as identity anchors, a Temporal Drop Mechanism (dense sampling for 16 frames post-entry, then sparse every 6 frames), Spatial-Aware Weighted Cross-Attention, and Plücker-coordinate camera embeddings. Training uses flow matching with causal chunk-based autoregressive generation and dual static/dynamic frame-retrieval for context memory.

Key results:

• Trained for 3,000 steps, batch size 64, on 64 A100 GPUs (~72 hours).
• On a 100-sample novel-scene test set: PSNR 18.127 (vs. next-best 14.782 for HY-World), SSIM 0.502, LPIPS 0.359 (vs. 0.398 for HY-World).
• Dynamic Subject Consistency: DSC_DINO 0.769, DSC_CLIP 0.917 (best or near-best among compared methods).
• Ablation: removing the Appearance Condition drops PSNR to 16.764 and DSC_DINO to 0.693, confirming its necessity.

Why it matters / caveats: Demonstrates a scalable, explicitly controllable approach to persistent dynamic-object memory enabling long-horizon, LLM-directed scene simulation with identity preservation after occlusion. Reliance on synthetic game-engine training data introduces a domain gap causing occasional unnatural locomotion or blurry faces.

Problem: Existing post-training pipelines for medical multimodal LLMs are outcome-centric, relying on final-answer correctness, which suffers from sparse credit assignment and fails to prevent early-stage reasoning errors from cascading into incorrect final answers.

Method: The paper proposes Medical Reasoning-aware Policy Optimization (MRPO), a GRPO-based RL algorithm combining an answer reward (ROUGE-1/BLEU-1/BERTScore via BiomedBERT), a step-wise reasoning process reward (scored by GPT-5-mini on Gold Alignment and Answer Contribution), and a length reward. When the final answer is judged incorrect, MRPO reshapes token-level advantage to assign exponentially larger penalties to earlier invalid reasoning steps, within the standard GRPO/PPO-clip objective with a KL penalty. Trained on 13K samples from VQA-RAD, SLAKE, and PathVQA augmented with MedThink gold reasoning annotations.

Key results:

• Applied to Qwen2.5-VL-7B, Qwen3-VL-8B, InternVL3-8B, MRPO achieves highest average score across five OOD benchmarks.
• On Qwen3-VL-8B, MRPO raises average from 25.61 to 28.94 (+3.33 points), including a +7.05-point gain on RadImageNet-VQA.
• Outperforms HuatuoGPT-Vision-34B (26.15 avg) by 2.79 points despite using only an 8B backbone and 13K samples.
• Reduces early-stage reasoning failures (First Failure Point 0.0–0.4) from 64.0% (baseline) to 13.0%, vs. 21.2% for GRPO.

Why it matters / caveats: Targeted step-wise reasoning supervision can rival large-scale medical instruction tuning for generalizable clinical reasoning, but depends on an external LLM judge (GPT-5-mini) and gold reasoning annotations, and has only been evaluated on medical VQA.

Problem: Reinforcement fine-tuning of visual generative models with sample-wise reward functions is prone to reward hacking, which degrades image diversity and introduces visual artifacts.

Method: The authors propose a distribution-wise reward RL framework using a subset-replace strategy: a small subset (e.g., 50 images) of a class-balanced reference set is periodically replaced with newly generated samples, and the negative FID of the updated set serves as a dense reward for a lightweight policy-gradient variant (GRPO/PPO-style clipped objective) fine-tuning diffusion models like SiT-XL/2. To avoid train-inference inconsistency from SDE-based rollouts, they also apply RL (via a 3-layer MLP "EMANet") to optimize post-hoc model merging coefficients for checkpoint pools (e.g., EDM2), enabling ODE-based deterministic rollouts during training.

Key results:

• On ImageNet 256×256, RL fine-tuning reduces SiT-XL/2 FID-50K from 8.30 to 5.77.
• Post-hoc model merging with RL improves EDM2-XS FID (512×512) from 3.74 to 3.52.
• Sample-wise RL reward (ImageReward) caused severe reward hacking, worsening FID to 34.26.
• Reference set size of 5,000 is optimal; replacing 50 images per rollout outperforms 100 or 200; best result after ~20 hours on 16 Hopper GPUs.

Why it matters / caveats: The distribution-wise reward mitigates reward hacking and mode collapse seen with sample-wise rewards while preserving diversity; however, it requires generating and periodically refreshing a large reference set, and pure RL-from-scratch outperformed a rejection-sampling-then-RL pipeline, indicating sensitivity to training recipe.

Problem: Data augmentation strategies borrowed from natural-image tasks are applied to vein recognition without a systematic understanding of how they affect fine-grained vascular topology and model reliability, and no standardized benchmark exists.

Method: The authors build AGVBench, a PyTorch/MMCV codebase evaluating 30 augmentation methods (single-image, multi-image mixing, and label-enhancement types) across seven backbones (MobileNetv2, ResNet18, ViT-S, Swin-T, FVRASNet, AMPVNet, StarLKNet-S) and five vein datasets. Evaluation spans six dimensions: recognition accuracy, calibration (ECE), corruption robustness (19 types plus two new low-severity levels), adversarial robustness (FGSM/PGD), occlusion robustness, and computational efficiency, plus a Pareto-based "APEX" ranking.

Key results:

• Multi-image mixing methods give strongest recognition: StarMixup/MixUp reach ~95.5–95.9% accuracy on VERA220 with ResNet18 (vs. 71.45% Vanilla).
• On SCUT1100, MixUp reduces EER from 0.30% to 0.07%.
• Despite high accuracy, mixup methods are poorly calibrated (ECE up to 47.88% for ResNet18 on TJU600) and adversarially fragile (MixUp accuracy drops to 4.87% under PGD).
• Geometric augmentations (Flip, Rotate, YOCO) consistently degrade performance.
• Effectiveness is dataset-dependent: on SDUMLA-HMT, MixUp underperforms Vanilla (79.87% vs. 84.51%).

Why it matters / caveats: Accuracy-centric evaluation is insufficient for biometric augmentation because top-accuracy methods trade off calibration and adversarial security, and no single method is universally optimal — future designs must jointly optimize accuracy, robustness, and calibration.

Problem: The paper investigates whether Self-Flow's performance gain over SRA (self-representation alignment for diffusion transformers) actually stems from stronger self-supervision via cross-noise-level token interaction, or is better explained as a data augmentation effect.

Method: The authors introduce Attention Separation, which preserves Self-Flow's dual-timestep scheduling (tokens assigned two different noise levels via a linear flow-matching path) but applies a block-diagonal attention mask so tokens at different noise levels cannot attend to each other, isolating token interaction from noise-augmentation effects. Controlled ablations run on ImageNet 256×256 with SiT-B, followed by a final recipe combining SRA with dual-timestep scheduling and Attention Separation (mask ratio 0.25, plus 25% full-image single-timestep samples), evaluated on SiT-XL/2.

Key results:

• Attention Separation under dual-timestep scheduling does not hurt performance: FID improves from 25.19 to 25.06 at 800K iterations vs. full attention.
• Under single-timestep training (no cross-noise interaction), Attention Separation alone still improves results: FID 26.34→25.81.
• On ImageNet 256×256 (SiT-XL/2, 4M steps): final method FID 1.44, IS 315.3, improving over SRA (FID 1.58) and Self-Flow (FID 1.47), comparable to REPA (FID 1.42).
• On ImageNet 512×512 (1M steps): matches REPA's best FID of 2.08.

Why it matters / caveats: Reinterprets Self-Flow's improvement over SRA as a data augmentation effect along the noise dimension, rather than improved self-supervision from token interaction — changing how future self-alignment training schemes should be designed. Overly aggressive Attention Separation creates a training-inference mismatch unless mitigated by mixing in full-image samples.

Problem: In realistic, overlapping skill repositories for LLM agents, final-verifier task success is too coarse to reliably evaluate or train agentic skill-use, since agents can pass tasks via trial and error or distractor-skill selection rather than genuinely reusable skill-use behavior.

Method: SkillCoach decomposes agentic skill-use into four trajectory-level dimensions (skill selection, following, composition, grounded reflection), built via a three-stage cycle: a rollout stage collecting trajectories in a distractor-augmented skill library, a judge stage scoring evidence against the current rubric, and an arbitration stage proposing validation-gated rubric patches. The evolved rubric is used both for diagnosis and as an offline process-quality filter to select high-quality trajectories for SFT of Qwen3.5-4B/9B models.

Key results:

• Rubric quality (R0 → Rbest, human-gold validation): gold-keypoint coverage 71.56 → 83.70; hallucination rate 2.00 → 0.00.
• Skill-dependency: gold-skill success 74.8%/67.6% (train/test) vs. no-skill 19.6%/16.8%.
• SFT final accuracy (Gold+Distractors): baseline Qwen3.5-4B/9B = 8.0/14.0; rubric-filtered SFT with Rbest = 24.0/32.0.
• Distractor-boundary stress test (50k library): degradation boundaries around 26–27 distractors (DeepSeek V4 Flash) up to 194–195 (Opus 4.7).

Why it matters / caveats: Separating process quality from outcome success exposes skill-use failures that final accuracy alone hides and provides a stronger training signal than outcome-only filtering. Limited to a relatively small selected task set and offline SFT without on-policy RL or long-term deployment feedback.

Problem: Current VLM evaluation for Spatio-Temporal Video Grounding (STVG) relies almost exclusively on zero-shot testing over general, daily-life benchmarks, leaving unclear whether VLMs can adapt to specialized domains with rare visual concepts.

Method: AnyGroundBench is a benchmark of 2,040 videos and 3,522 query-annotation pairs across five specialized domains (animal, industry, sports, surgery, public security), annotated via a detection-then-tracking pipeline (Grounding DINO + SAM2) with manual refinement. It decomposes evaluation into STVG, Spatial Video Grounding (SVG), and Temporal Video Grounding (TVG) tasks, evaluating 15 VLMs under zero-shot and 2-shot ICL using a SentenceBERT+InternVideo2 retrieval function.

Key results:

• Best zero-shot STVG (vIoU@0.3): Gemini-3.1-Pro at 22.8 (Public Security), 16.5 (Animal); many open-source VLMs scored 0.00 on STVG in multiple domains.
• ICL (2-shot) gave inconsistent gains, sometimes degrading performance (e.g., SVG scores consistently dropped as demonstrations increased for Gemini-3.1-Pro).
• Temporal scale sensitivity: TVG rose from 6.82 (events <1s) to 34.0 (events ≥3s).
• Spatial scale sensitivity: SVG rose from 2.61 (small objects) to 18.8 (large objects).

Why it matters / caveats: Even the strongest proprietary VLMs lack practical zero-shot spatio-temporal grounding in specialized domains, open-source models collapse almost entirely, and simple ICL is unreliable and often hurts spatial grounding — spatial grounding is the primary bottleneck for real-world deployment.

Problem: Existing search-agent benchmarks assume user queries are complete and explicit, ignoring that real-world queries are often vague, underspecified, or factually incorrect, which can derail deep search agents through multi-step reasoning chains.

Method: DISCOBENCH is built via a two-phase pipeline: Phase 1 builds multi-hop seed QA chains via LLM generation and graph-structured expansion with human verification; Phase 2 injects ambiguity (Entity, Version, Criteria, Factual Inaccuracy types) and generates discriminative user clues, manually verified. Evaluation uses a checkpoint framework where an agent chooses SEARCH, ASK, or ANSWER, interacting with an LLM-based user simulator (Gemini-3-Flash-Medium) under Neutral and Guided prompting, with SEARCH backed by Tavily.

Key results:

• 211 samples, 463 ambiguity instances across 11 domains and four ambiguity types.
• Under Neutral prompting, best model (Doubao-Seed-2.0-Pro) achieves only 43.1% end-to-end accuracy; most models stay below 40%.
• Guided prompting raises average end-to-end accuracy from 28.6% to 33.7% across 10 models.
• Removing search tool drops accuracy drastically (e.g., Doubao-Seed-2.0-Pro from 43.1% to 2.4%); removing ambiguity raises accuracy by 26.8–40.2 points.
• SearchThenAsk behavioral profile achieves 93.4% average pass rate vs. DirectGuess's 56.5%.

Why it matters / caveats: Reveals a critical gap between retrieval/reasoning ability and interactive problem-solving — ambiguity detection and clarification are distinct capabilities, and repeated searching often performs worse than direct guessing. Limited to four objective ambiguity types and an LLM-simulated user rather than real humans.

Problem: One-step image generators trained by matching feature distributions under frozen pretrained encoders lack clarity on which design choices (comparison metric vs. representation space) drive quality, and existing evaluation metrics can be gamed.

Method: The paper formalizes Representation Distribution Matching (RDM) along comparison and representation axes, deriving "improved RDM" (iRDM): squared MMD with a Gaussian kernel via exact within-batch repulsion plus Nyström kernel mean embedding attraction (4096 landmarks); trains with large fresh generation batches (>2048); matches joint image-text feature law for conditional tasks; balances up to ten pretrained encoders via a proportional Lagrangian controller. Evaluated with a new metric, SWr14 (Sliced-Wasserstein averaged over 14 encoders).

Key results:

• iRDM sets new one-step SOTA on ImageNet-256 at SWr14 = 1.30 (real data floor = 1.00), improving on prior best of 2.05.
• Preferred by PickScore over held-out real photographs on 63.6% of matched samples (claimed first one-step generator to pass real-image PickScore).
• Post-training four-step FLUX.2 [klein] into a one-step model with iRDM surpasses the four-step version on GenEval (0.826 vs. 0.794), using ~90 H200 GPU-hours.
• Matching only DINOv2 features drives its own distance near the real floor after 1000 steps, yet images remain visibly flawed for some classes — demonstrating single-encoder gaming.

Why it matters / caveats: Shows a decades-old technique (MMD) can be SOTA for one-step generation once properly estimated, and that single-encoder evaluation is fundamentally gameable. A measurable gap to real data remains (SWr14 = 1.30 vs. floor of 1.00).

Problem: The paper investigates whether on-policy self-distillation (specifically SDPO) reliably mitigates catastrophic forgetting in continual post-training of LLMs, as prior work has optimistically assumed.

Method: The authors study SDPO (self-teacher, generalized Jensen-Shannon divergence at every generated token) versus sequence-level GRPO, and propose StableSDPO, a restart-and-freeze teacher update strategy as an alternative to continuous EMA teacher updates. Experiments use Qwen3-4B and Olmo-3-7B variants trained sequentially across MATH, SCIENCE, TOOLUSE, and CODING domains, with SVD-based parameter drift diagnostics and an excess-KL theoretical analysis.

Key results:

• Single-domain SDPO0 raises AIME from 32.71% to 56.42%.
• Teacher EMA rate matters non-monotonically; no single α is globally optimal.
• StableSDPO fixes destructive EMA behavior: AIME improves from 34.38% to 55.00%.
• After the full continual sequence (MATH→SCIENCE→TOOLUSE→CODING), SDPO0 drops to 34.38% on MATH and 9.93% on TOOLUSE; SDPO5% collapses entirely (0.00% on multiple benchmarks) by the third stage.
• GRPO shows more conservative, monotonic improvement and retains gains reliably; GRPO's principal-mask overlap stays near 99.9% (minimal parameter drift).

Why it matters / caveats: On-policy sampling alone does not guarantee resistance to forgetting — the training objective determines whether forgetting is mitigated, so dense self-distillation should not be treated as a default stabilizer for continual post-training.

Problem: Existing medical foundation models for radiology report generation are almost exclusively autoregressive, leaving untested whether a diffusion language model can be accurate enough while supporting interactive, any-order drafting operations that autoregressive models structurally cannot perform.

Method: The authors adapt DiffusionGemma-26B (25.2B-parameter/3.8B-active MoE uniform-state discrete diffusion LM with a SigLIP-lineage vision encoder), comparing it against its same-family autoregressive sibling Gemma-4-26B using an identical LoRA recipe (rank-64) that varies only the generative paradigm. They finetune on medical VQA datasets with an LLM judge (Claude Sonnet 4.6), and introduce "any-order infill," a sampler modification letting a radiologist fix report fragments at arbitrary positions with bidirectional gap-filling, evaluated on MIMIC-CXR.

Key results:

• Finetuned diffusion equals or exceeds finetuned AR on LLM-judge accuracy across all three VQA datasets tested.
• SLAKE finetuning gains: diffusion +0.163 (0.700→0.863) vs. AR +0.143.
• Inference speed (H100): DiffusionGemma is 3.5–4.4× faster in latency and 5.7–7.1× higher throughput than AR.
• Any-order infill on MIMIC-CXR: adding right-side context raises diffusion's token-F1 by +0.109 (p<10⁻¹⁰); AR shows no significant gain even when prompted with both sides.

Why it matters / caveats: Discrete diffusion is a viable, competitive substrate for medical foundation models with faster decoding and a unique any-order infill capability suited to terse, real-world radiology reporting. Several diffusion-vs-AR VQA comparisons were not statistically significant, and the study is limited to chest X-ray/medical VQA at matched 26B scale.

Problem: Existing controllable image generation methods (e.g., ControlNet-based) suffer from attribute confusion in complex multi-instance scenes, and prior fixes require labor-intensive manual instance labeling at inference time.

Method: InstanceControl uses a two-stage pipeline: a Sa2VA-based VLM (integrating SAM as mask decoder) automatically parses instance descriptions from the text prompt and predicts instance masks, using a Shared SEG Token strategy for multiple tokens referring to the same instance; an Instance-aware Controllable Generation stage built on FLUX.1-Canny/Depth and XLabs HED ControlNet injects these correspondences into image-text cross-attention, refined at each timestep by a U-Net-based Mask Refinement Module. Trained with LoRA fine-tuning on curated data from SAM, COCO, and UniWorld-V1.

Key results:

• On MIG-Eval (canny): ~12.3% gain in Accuracy and Local CLIP Score over FLUX ControlNet; MIoU 0.8250 vs. 0.6526.
• Outperforms instance-labeled DreamRenderer on hed condition (MIoU 0.8504 vs. 0.7060).
• Against unified models (Nano Banana, Qwen-Image ControlNet) on 300 sampled images: InstanceControl MIoU 0.8834 vs. 0.8127/0.8307.
• Mask Refinement Module improves Accuracy from 87.97% to 90.10%, and to 93.19% with interactive user correction.

Why it matters / caveats: Removes the need for costly manual instance labeling while matching or exceeding instance-labeled methods, making fine-grained multi-instance control more practical. Slightly lower ImageReward under depth conditions than FLUX ControlNet, and severe Stage 1 mask errors can still cause incorrect generation.

Problem: In multi-domain RLVR for LLM reasoning, existing curricula decide which domain to sample based only on local learnability, ignoring whether training on a given domain actually helps performance on other domains.

Method: The paper proposes Transfer-Aware Curriculum (TAC), a bandit-style online curriculum for multi-domain GRPO training formulated as a multi-armed bandit with UCB-augmented Boltzmann sampling. TAC combines a local learnability term (z-scored mean absolute GRPO advantage) and a gradient-based transferability term computed via TRAK-style random projection of GRPO gradients, maintaining per-domain EMAs and pairwise cosine similarities. Experiments use GRPO on Qwen3-1.7B-Base and Llama3.2-3B-Instruct across the six-domain GURU suite.

Key results:

• TAC achieves best macro-averaged accuracy on both backbones: +1.8pp over strongest baseline (SEC) on Qwen3-1.7B, +1.6pp over M2O on Llama3.2-3B.
• Ranks first on 10 of 14 evaluation benchmarks on both models.
• Cross-domain transfer example: RL on "table" domain improves simulation accuracy by 14.6pp vs. only 5.0pp from "math."
• Performance peaks near β≈0.2 mixing coefficient and degrades sharply at β=1 (pure learnability).

Why it matters / caveats: Uses cross-domain gradient alignment (at negligible extra cost) as a curriculum signal to generalize reasoning training beyond math/code more sample-efficiently. Restricted to the RLVR setting; extending to non-verifiable or model-judged rewards is left to future work.

Problem: Evaluating LLM agents on agentic benchmarks (e.g., SWE-Bench, GAIA) is expensive, slow, and infrastructure-heavy, making frequent or broad agentic evaluation impractical.

Method: PACE selects a compact subset of instances (e.g., C=100) from 19 non-agentic source benchmarks spanning 11 capabilities, combining two SVD-based selection signals (a "Local" Spearman-correlation signal and a "Global" leverage-score signal). It fits a bootstrap-stabilized linear regression (absolute score prediction) or a Bradley-Terry logistic regression (pairwise preference) mapping proxy scores to target agentic benchmark performance, evaluated under strict LOOCV across 14 models on GAIA, SWE-Bench Verified, SWE-Bench Multimodal, and SWT-Bench.

Key results:

• With C=100 proxy instances: average LOOCV MAE = 3.80%, average Spearman = 0.81, average pairwise-preference accuracy = 84.37% (vs. 50% random).
• Matches the prediction quality of a random target-sampling baseline at roughly 100× lower cost.
• Bootstrap resampling ablation: removing it worsens average MAE by 0.77pp and Spearman by 0.15.
• Reveals interpretable capability profiles per benchmark (e.g., GAIA emphasizes Instruction Following/Verification).

Why it matters / caveats: Lets practitioners cheaply rank and monitor candidate models without running full agentic evaluations. Accuracy depends on calibration models being representative of future models, requiring periodic refresh of the calibration set.

Problem: Vision-Language-Action (VLA) models are bottlenecked by the scarcity and high cost of expert demonstrations, since current training conflates learning physical competence ("how to move") with semantic task alignment ("what to do").

Method: The paper proposes Task-Agnostic Pretraining (TAP), a two-stage framework on a Qwen2.5-VL (3B) backbone with a SigLIP visual encoder. Stage 1 trains a self-supervised Inverse Dynamics objective — predicting action from an observation pair treating the future frame as an implicit visual goal — on cheap, unlabeled task-agnostic data (discarded off-task Bridge trajectories plus autonomously collected "random play" via Constrained Procedural Trajectory Generation). Stage 2 finetunes the same backbone via standard behavior cloning on a minimal set of language-annotated expert demonstrations.

Key results:

• On SIMPLER (WidowX), TAP-20k achieves Avg-All success of 33.32% vs. 23.15% for Standard BC — a +10pp gain — and vs. 7.75%/3.03% for OpenVLA/RT-1-X (pretrained on 1M+ trajectories).
• Monotonic improvement with more Stage 1 data: 24.47% (8k) → 30.21% (14k) → 33.32% (20k).
• Real-world WidowX 250 trials (only 200 expert demos/task): under camera viewpoint perturbation, TAP retains 15–25% success while Standard BC and NORA collapse to 0%.
• ~75% of real-world failures are semantic/reasoning failures (correct execution on wrong target) rather than physical execution errors.

Why it matters / caveats: Shows costly, language-labeled expert demonstrations can be substantially reduced by first learning "physical common sense" from cheap, unlabeled interaction data. Large-scale VLA baselines are approximate upper-bound references (pretrained on 1M+ trajectories) rather than direct competitors, and semantic/reasoning failures remain the dominant bottleneck.