AI papers — 2026-09-18

Problem: Long-horizon agentic workloads make prefill compute and KV-cache storage/bandwidth (HBM and SSD) the primary bottleneck to lowering deployment costs for long-context LLMs.

Method: DeepSeek-V4.1-Flash is a multimodal Mixture-of-Experts Transformer with 552B backbone parameters (plus 196B Engram parameters) and up to 1M-token context, activating only 8B parameters per token during prefill and 16B during decode via a Causal Encoder-Decoder (CED) architecture (40 causal layers: 20-layer causal encoder + 20-layer decoder, first two layers SWA-only). It combines Compressed Sparse Attention 2 (CSA2) — three static modes (Full/Reindex/Reuse) that share global KV and indexer K across layers and reuse Top-K indices — with FP4 KV caching, plus Single-Pass mHC, the Engram conditional-memory module, and DSpark speculative decoding. Training: pretrained from scratch on a 45T-token multimodal corpus with sparse attention trained at 64K sequence length (no dense-attention warmup), followed by post-training via standard SFT → RL → on-policy distillation (OPD), with large-scale automated agent-task synthesis and asynchronous RL infrastructure (DSec).

Key results:

• Global KV cache footprint drops to 890 bytes/token, about 1/4 of DeepSeek-V4-Flash and 437x lower than DeepSeek-V1; persistent (SSD/host) KV cache footprint is reduced to roughly 1/8 of DeepSeek-V4-Flash via "SWA Bounded Replay."
• DeepSWE v1.1 pass rate reaches 74.2%, up from 54.4% for DeepSeek-V4-Flash, surpassing Opus-5 (74.0%) and GPT-5.6 Sol (73.0%); Terminal-Bench 2.1 reaches 90.6%, beating Opus-5 (89.1%) and GLM-5.3 (88.2%).
• Codeforces rating of 3471 (vs. 3289 for DeepSeek-V4-Flash, 3348 for DeepSeek-V4-Pro); MathArena Apex Pass@1 of 65.6% (matching Kimi-K3 and DeepSeek-V4-Pro); GPQA Diamond 90.9% (up from 89.9%).
• Extending context 256-fold (4K→1M tokens) increases single-token Decode FLOPs by only 1/4, versus much steeper growth for DeepSeek-V4-Flash.
• Raising reasoning effort from 25 to 100 improves average Pass@1 across eight reasoning benchmarks from 67.1% to 76.3%, DeepSWE v1.1 from 66.0% to 74.2%, and Terminal-Bench 2.1 from 82.4% to 90.6%, at roughly 2.5x more output tokens.

Why it matters / caveats: Despite being larger than its predecessor, the model needs far less KV cache storage while matching or beating several closed-source frontier models on agentic benchmarks, substantially lowering serving cost for long-horizon agents; the authors note a remaining performance gap versus giant closed-source systems on science-oriented agentic tasks (e.g., Terminal-Bench 4.0) and multimodal visual agent tasks.

Problem: Existing video-generation/world-model benchmarks (VBench, WorldModelBench, etc.) use explicit text prompts that describe the target output directly, so they cannot tell whether an omni-modal generative model actually reasons across modalities rather than just rendering what it is told.

Method: The authors build an evaluation framework of implicit multimodal prompts, where target event semantics are deliberately omitted from the text prompt and distributed across other input modalities, forcing the model (tested on MiniMax-H3, an open-weight omni-modal video-audio generation model) to integrate cross-modal evidence to complete the video. Four task types are defined: Multi-view Spatial Reasoning (MSR, multiple image viewpoints), Audio-based Disambiguation Reasoning (ADR, image + audio), Video-based Decision Reasoning (VDR, prefix video continuation), and Audiovisual Integrated Reasoning (AVIR, video + audio). The evaluation set comprises 517 expert-verified instances across 29 subcategories (MSR 200, VDR 100, ADR 146, AVIR 71), built via source collection from real/synthetic video, image and audio datasets (e.g., HiFi-UMI-2K, LLaVA-Video-178K, FSD50K, ESC-50), implicit-prompt construction (aided by ChatGPT/Qwen3), and a 10-loop iterative expert review; three independent human experts score success/failure per instance.

Key results:

• Overall success rate across all 517 instances is 41.97%.
• Video-based Decision Reasoning (VDR) is the strongest scenario at 56.00% success; Audio-based Disambiguation Reasoning (ADR) is the weakest at 27.40%.
• Subcategory results vary widely, e.g., Traffic (VDR) reaches 100% while Machinery (ADR) is only 17.60% and Alerts (ADR) 23.10%.

Why it matters / caveats: The results reveal a gap between an omni-modal model's ability to accept multimodal inputs and its ability to reliably reason over and integrate them into correct generations, especially for audio-based disambiguation; the evaluation relies on human judgment (three experts per instance) rather than fully automatic metrics.

Problem: In on-policy distillation (OPD), student responses often inflate in length and exhaust the generation budget, and the paper investigates termination-token (EOS) mismatch between base students and post-trained teachers as an under-examined cause.

Method: Using sampled-token OPD (student rollouts scored by a fixed teacher via a per-token reverse-KL-style advantage), the authors study Qwen3-1.7B-Base distilled from Qwen3-4B (non-thinking) on DAPO-Math-17K, plus cross-family checks on Llama-3.2-3B (Base/Instruct) and Gemma-3-4B (PT/IT), and a stage-wise study using K2-Horizon-7B checkpoints (pretrain, midtraining, SFT, final post-trained model treated as teacher). They compare four termination-handling corrections: Fix 1 (shared-set decoding, aligning only the rollout stopping set), Fix 2 (teacher-side EOS probability mapping to a canonical student EOS token), Fix 3 (semantic EOS class, aggregating all EOS-equivalent tokens' probability into one shared "stop" action for both student and teacher), and Fix 4 (canonical single-EOS action space, removing non-canonical EOS tokens from the student's sampling distribution).

Key results:

• Under vanilla OPD on Qwen3, the student's probability on its native EOS (<|endoftext|>) falls from roughly 0.8 early in training to near zero, while the teacher-preferred <|im_end|> token receives only about 10^-11 probability from the student near terminal states.
• Fix 1 (decoding-level stopping-set alignment alone) follows nearly the same response-length/clipping trajectory as vanilla OPD and fails to fix length inflation; only probability-level corrections (Fixes 2–4) substantially mitigate mismatch-induced inflation, tested across Qwen3, Llama 3.2, and Gemma 3.
• Gemma 3's PT/IT models already share the identical declared EOS set (<eos>, <end_of_turn>) yet still mismatch at the probability level (student favors <eos>, teacher favors <end_of_turn>), showing the failure mode is not just about declared stopping sets.
• On K2-Horizon-7B, a distinct late-stage ("Phase 3") re-inflation occurs after training progresses further, where termination probability collapses again and most rollouts hit the generation budget, even under the semantic EOS correction — showing termination mismatch is an important but not complete explanation of length inflation.

Why it matters / caveats: The findings give a concrete, implementation-level diagnosis (differing learned EOS-token preferences) and a practical fix (semantic EOS aggregation) for a widely reported OPD pathology, applicable across Qwen3/Llama/Gemma; however, the authors explicitly note residual late-stage length-inflation dynamics remain unexplained, and experiments are limited to single-turn mathematical reasoning tasks.

Problem: As coding agents run long, unattended trajectories, token efficiency of the agent harness (not just the underlying model) becomes a first-order cost concern, but manually optimizing a harness (tool use, context management, delegation, termination) is labor-intensive and hard to scale, and prior automated harness-search methods have been shown to overfit to their search tasks.

Method: SoL-Pi uses an RSI-inspired "Scaling Auto-Research Loop": a research AI inspects execution traces from a base harness (built on "Pi"), proposes harness-modification hypotheses, and tests them under a broad-to-deep funnel with capability/efficiency gates, strictly separating development feedback from held-out evaluation (candidates are frozen before EdgeBench evaluation, with no feedback back into search). The outer search explores 152 proposed directions across six proposal families (context, progress, tools, delegation, prompt/policy, improvement/evaluation) over 535 executable environments (495 GitHub issue–PR repository tasks + 40 verifier-driven synthetic tasks), totaling roughly 3,000+ runs and 60,000+ agent–environment interactions. Four mechanisms survive selection and form SoL-Pi: Action Fusion (merges a file edit and its follow-up test/build command into one tool call), Online Context Compact (triggers context compaction at plan-step boundaries via a cost-gated estimate of savings vs. cache-rewrite cost), ObservationPack (archives tool outputs over 10 KiB and replaces them after two requests with a stable handle + excerpt), and Evidence-Preserving Reducer (uses GPT-5.6 Luna at high setting to compress ≥4 KiB build/test logs into a verified receipt, with deterministic schema/hash/exit-status checks and fallback to the original on failure).

Key results:

• On the 51-task public EdgeBench split with GPT-5.6 Sol, SoL-Pi [Efficiency] uses 1.10B total tokens (49.0% fewer than Pi's 2.15B) at $894 token cost (33.2% lower than Pi's $1,339), retaining 93.7% of Pi's average score (42.0 vs. 44.8).
• SoL-Pi [Performance] (single best mechanism, ObservationPack for GPT-5.6 Sol) raises average score from 44.8 to 47.2 (+5.3%) while cutting token traffic by 6.1% and improving token efficiency by 9.8% ($0.528 vs. $0.586 per score point).
• Transferred without further search/adaptation to Opus 5, SoL-Pi [Efficiency] retains 94.3% of Pi's average score while reducing token traffic by 44.7% and API cost by 33.5% relative to Pi.
• Relative to native harnesses, SoL-Pi cuts API cost by 50.0% vs. Codex on GPT-5.6 Sol and by 54.3% vs. Claude Code on Opus 5; reported estimated hourly savings are $8.75–$13.50 vs. native Codex/Claude Code harnesses and $4.36–$5.71 vs. Pi.

Why it matters / caveats: The work shows that harness-layer (not just model- or infrastructure-layer) optimization can yield large, transferable token/cost savings for long-running coding agents without any model retraining, and that automatically discovered mechanisms generalize to an unseen backend (Opus 5) and held-out benchmarks; evaluation on EdgeBench uses only the 51 of 134 tasks that are publicly released, and gains are compared against the "Pi" harness baseline rather than a broader field of production agent harnesses.

Problem: Coding harnesses for LLM agents are usually evaluated as monolithic systems, so it is unclear which individual components (planning, action space, context management) actually drive performance differences, or how their value depends on model capability and context budget.

Method: The authors build a lightweight ReAct-loop coding harness (LangGraph-based, tasks driven via the Harbor framework) with a fixed execution loop and three independently ablatable components: planning (an update_plan tool plus persistent plan injection), action space (a predefined 8-tool set — read_file/write_file/edit_file/list_files/glob_files/grep_text/bash/web_fetch — vs. a bash-only interface), and context management (five tiers T0–T4 combining elision M1, external-store recall M2, and LLM summarization M3, gated by soft/hard token thresholds). They evaluate 4 models (Nemotron-3 30B/120B/550B and Mistral-Medium-3.5-128B, served via SGLang in BF16) across SWE-Bench Verified (500 tasks) and Terminal-Bench 2.1 (89 tasks), sweeping 4 context budgets (32k/64k/96k/128k) x 5 context-management tiers plus separate planning and action-space ablations, for 176 total experimental settings, using two-sided McNemar tests with Benjamini-Hochberg correction.

Key results:

• At 32k context, context management raises SWE-Bench success dramatically (e.g., Nemotron-3-120B: T0=11.4% vs. T1=43.0%; Mistral-3.5-128B: T0=12.6% vs. T2=66.2%); the gap shrinks by 128k (e.g., Nemotron-3-120B: T0=40.2% vs. T4=44.0%).
• Tier 4 (staged elision-then-summarization) matches the accuracy of other managed tiers while controlling cost (e.g., Nemotron-3-550B at 32k: T4 costs $1.45 vs. T2's $2.70 for similar success ~55-56%).
• Disabling planning hurts the weakest model sharply (Nemotron-3-30B SR drops from 25.2% to 13.6% at 128k/T4) but has little effect on stronger models (Nemotron-3-550B: 65.8% to 67.8%) while lowering their cost.
• Removing predefined tools for a bash-only interface drops Nemotron-3-30B SR from 25.2% to 10.2% and Mistral-3.5-128B from 68.6% to 45.4%, but for Nemotron-3-550B it improves SR (65.8% to 69.4%) while cutting cost from $2.33 to $1.11.

Why it matters / caveats: The results show harness design effects are conditional on model capability and budget rather than universal — context management mainly prevents overflow failures, planning shifts from an accuracy scaffold to a cost saver as models get stronger, and bash-only interfaces suit bash-capable models but hurt weaker ones. Findings are drawn from four specific models (Nemotron-3 family plus one Mistral model) and two benchmarks, so generalization to other model families is not directly tested.

Problem: Predictive world models remain domain-specific, and standard joint-embedding predictive architectures (JEPAs) represent a requested target through a single monolithic embedding and one prediction pathway, letting easily-predicted or high-variance structure dominate optimization when multiple entities, scales, or intervention types share that target.

Method: The paper introduces orthogonal predictive factorization (OPF): a set of K learned projector matrices P_k (with Kr = d) analyze a stop-gradient EMA target embedding into K orthogonal factors, each predicted by a dedicated predictor branch from the shared context encoder, then recombined via the Moore-Penrose pseudoinverse of the analysis map into a complete latent state. Training adds an additive OPF loss (Lpred + orthogonality loss Lorth + factor-activity floor Lfac + encoder-variance term Lenc) on top of each domain's original base loss, with no changes to encoder architecture, tokenization, or context/target sampling. The same core is instantiated across seven domains using different backbones (DINOv3 ViT-S, SigLIP2 Base, scGPT, GPT-2 small, TrajCast-style O(3)-equivariant nets, latent-dynamics/CEM planner) with K typically 4 (and 5 for Interventional Pong), each domain combining its own base loss with LOPF.

Key results:

• Against matched dense standard-JEPA baselines on CITRIS Interventional Pong, JEPA-Anything reduces single-intervention one-step MSE by 34.83% (0.009541 to 0.006218), combined-intervention MSE by 12.90%, and 6-step free-rollout MSE by 8.58%.
• Improves reported metrics on all 10 matched dynamics tasks (CausalWorld, DMC, PDEBench, WeatherBench2, etc.) versus standard JEPA baselines, and achieves the lowest one-step and 100-step molecular rollout errors among compared methods across all four molecular systems (water, quartz, paracetamol, benzene).
• On single-cell tasks, JEPA-Anything attains the best PBMC-10K clustering (AvgBIO 0.8301 fine-tuned, 0.7752 zero-shot, vs. scGPT's 0.7531/0.5288) and best perturbation-prediction Pearson correlation on Norman (0.814) and Adamson (0.942) datasets.
• A factor-nominated biological intervention received experimental support across cell co-cultures, patient-derived organoids, tumor fragments, and mice; latent orbital modes recovered the Keplerian scaling exponent with a fitted slope of -1.4991.

Why it matters / caveats: The results support a single factorized predictive-learning principle transferring across seven very different domains (vision, biology, clinical trajectories, control, molecular dynamics, physical fields, weather), connecting world modeling to intervention analysis and wet-lab-validated scientific discovery. Evaluation combines standard held-out/OOD metrics with a small number of externally validated biological experiments and one analyzed orbital-mechanics run, so some scientific-discovery claims rest on limited replicate counts (e.g., "one analyzed run" for the orbital scaling law).

Problem: Evaluating LLM assistants' social reasoning in realistic consultation settings is hard because assistants learn about social situations only through a user's subjective, possibly biased retelling, and properties like others' true intentions typically lack verifiable ground truth.

Method: The authors build Fuse (Framework for User-mediated Social Evaluation), a multi-agent simulation framework where a target agent with a hidden motive interacts with other agents (including one representing the user) across scripted scenario templates built on the ATOMS mental-state taxonomy (desire, intention, belief, emotion, knowledge), simulated using the Concordia multi-agent framework with Gemini 3.1 Flash-Lite driving all personas and serving as the LLM judge. The evaluated assistant only sees the user's subjective debrief (not the raw simulated events) and must predict the target's hidden motive from a forced-choice set; an aggregate Mediated Social Reasoning (MSR) score is computed with d=0.75 credit for abstention. The dataset spans 30 scenario templates (6 per ATOMS category), 2 contrasting motives each, 20 realizations per scenario/motive (1,200 simulations total), with 3 debriefs sampled per combination of 2 bias conditions x 3 narrative detail levels, yielding 21,600 user messages; 12 models across 7 families (Gemma-4 12B/31B, Mistral 4 Small 119B MoE, Mistral 3.5 Medium 128B, GPT-OSS 20B/120B, GPT 5.6 Luna/Terra, Claude 5 Sonnet/Opus, Gemini 3.7 Flash, Grok 4.5) are evaluated on the first user message.

Key results:

• Human studies (24k annotations total) validate the simulations: raters matched the ground-truth motive in 97% of raw-event cases, and a 10-rater majority vote on the first user message alone reached 88% correct predictions (MSR 89.8).
• No evaluated LLM exceeds 83.7 MSR (Gemini 3.7 Flash, the best model), leaving a gap of over 6 MSR points versus the human majority baseline of 89.8.
• Many models exceed a 20% error (Incorrect) rate on first-message predictions, and abstention behavior varies sharply — some models (Mistral, GPT 5.6) almost always attempt a prediction while four models across Gemma and Claude families abstain much more often.
• Across all 12 models, MSR scores on first-message-only predictions range roughly from 68.0 (Mistral Small 4) up to 83.7 (Gemini 3.7 Flash).

Why it matters / caveats: The framework isolates concrete failure modes — user-mediation compounds inherent reasoning difficulty, models show systematic sensitivity to biased user framing, sometimes need more narrative detail than humans to reach a correct prediction, and longer multi-turn conversations do not consistently improve accuracy. The study's first-message focus is an explicit limitation; a full validated multi-turn benchmark would require a live, stable user simulator, which the authors leave to future work while providing only an initial multi-turn analysis.

Problem: Retrieval index quality depends on how well index keys expose document knowledge, but effective index representations vary across corpora and retrievers, and evolving an index to fit its retrieval environment currently requires humans to manually diagnose retrieval failures and rewrite the optimization strategy.

Method: The paper proposes SELF-INDEX, which runs an Optimizer through an iterative three-stage loop over a query set Q: Self-Diagnosis (built on retrieval outcomes and a pseudo-relevance-feedback-inspired co-retrieval profile per key, with no relevance annotations needed), Self-Revision (jointly rewrites each targeted document's full key set K(d) rather than individual keys, to avoid redundancy), and Self-Validation (checks each proposed key against three criteria — faithfulness, specificity, and separation — discarding failing keys). A separate Query Simulator performs Self-Exploration, sampling documents and generating new candidate queries filtered by a Jaccard-similarity dissimilarity filter to proactively probe retrieval demands beyond the observed query set, and feeds them back to the Optimizer. Both the Optimizer and Query Simulator are built on Qwen3.6-35B-A3B, and in the main experiments the index is evolved solely from Query-Simulator-generated queries (test queries stay unseen).

Key results:

• On the BRIGHT benchmark, SELF-INDEX gives the largest overall relative gain over the base index among all methods tested: +40.4% (BM25 sparse, final avg 14.5 to 20.4), +57.0% (BGE dense, avg 13.9 to 21.8), and +38.8% (Qwen3-Emb-8B, avg 18.8 to 26.1), each beating the strongest baseline (RL-Index, Doc2Query, or SPIKE).
• On table retrieval (Spider2, FIBEN, BEAVER), SELF-INDEX achieves the best average nDCG@10 under every retriever: BM25 49.5 (+49.1%), BGE 53.1 (+17.9%), Qwen3-Emb-8B 57.0 (+16.2%), outperforming EnrichIndex and other baselines.
• On the BrowseComp-Plus search-agent benchmark, SELF-INDEX improves GPT-OSS-120B+BM25 accuracy by +89.53% (31.08 to 58.92) while cutting search calls by 21.46% and calibration error by 37.69%; gains hold across GPT-5.4-nano and Qwen3-Emb-8B backbones too (e.g., GPT-5.4-nano+BM25 accuracy +77.87%).
• SELF-INDEX also improves agent memory retrieval on LongMemEval-V2 (evaluated with Qwen3.5-9B as memory controller/reader), though specific numeric results for this experiment were not captured in the excerpted text.

Why it matters / caveats: SELF-INDEX removes the human-in-the-loop bottleneck of manually diagnosing and rewriting index optimization strategies, consistently beating both fixed heuristic index-optimization methods (Doc2Query, SPIKE) and a learned strategy baseline (RL-Index) across sparse and dense retrievers and across natural-language, code, math, and table corpora, while also improving downstream search-agent accuracy/efficiency. Reported gains rely on an LLM-driven Optimizer/Validator (Qwen3.6-35B-A3B) and an LLM judge for validation, so some quality control is itself model-dependent.

Problem: Existing benchmarks evaluate obfuscated-text restoration and risky-webpage investigation separately, so it is impossible to measure how a small message-restoration error propagates into and corrupts downstream web-based evidence acquisition and risk judgment.

Method: RISKCHAINBENCH pairs 3,600 synthetic token-text restoration inputs (600 source sessions × 6 obfuscation-recipe variants using emojis, homophones, character decomposition, and redundant platform tokens) with 600 human-labeled local web environments built offline from a frozen pool of 2,500 real websites. In Task 1, a model restores the canonical message, operational intent, and a ranked entry list from the obfuscated text alone; in Task 2, the same underlying model acts as a VLM-driven web agent (BrowserGym + Playwright, 30-action/600-second budget) that investigates only the correctly-associated site with no access to the source message, and produces a frozen, evidence-cited risk report. A fixed primary-variant entry prediction is applied offline as a gate to compose the two frozen stages into an end-to-end score, and a fixed multimodal evidence judge separately scores faithfulness, sufficiency, completeness, and consistency. Four trained annotators built the three-way website gold labels (violation/non-violation/insufficient) and nine violation types under a shared codebook; ten frontier models (e.g., GPT-5.x, Opus, Kimi, Qwen, Sonnet, Doubao variants) were evaluated as baselines.

Key results:

• Entry Top-1 exact-match restoration accuracy ranges from 35.2% to 95.2% across the ten evaluated models.
• Web-only three-way decision accuracy ranges from 26.3% to 62.8%.
• Entry-gated end-to-end accuracy on the 600 websites spans from 16.7% up to 60.8% for the leading system.
• Execution failures account for 31.9% of web-agent runs, versus only 0.9% for post-decision type errors, identifying unstable exploration and risk judgment (not fine-grained typing) as the main bottleneck.
• Human annotation quality: first-pass decision agreement 82.50%, joint decision-type agreement 80.17% (Krippendorff's α of 0.6553 and 0.7425), with 97.9% decision agreement on hidden repeats.

Why it matters / caveats: The benchmark shows the same models rank differently across entry recovery, full reconstruction, web decisions, and type classification, exposing a cross-stage evaluation gap that separate text/web benchmarks miss. It is fully synthetic (reserved .test domains, no live sites or real user data), so it measures capability rather than real-world prevalence of platform abuse.

Problem: On-policy distillation (OPD) from a privileged skill-conditioned teacher is meant to densify the sparse, trajectory-level reward used in RL for multi-turn agents, but it silently assumes the teacher stays reliably better than the student and that matching it remains useful for the whole training run — the paper shows both assumptions break down in agentic tasks.

Method: RetireOPD trains in three stages. (1) Teacher construction: a skill-conditioned teacher, initialized from the same base model, is optimized purely with GRPO under privileged skill context (from the SkillRL SkillBank, retrieved via keyword matching) so it actually learns to exploit the skills before it supervises anyone. (2) Joint GRPO-OPD: a skill-free student is trained with a combined loss L = L_GRPO + λL_OPD (λ0 = 0.01, following SDAR), where GRPO uses the standard clipped group-relative advantage objective and OPD uses a reverse-KL loss estimated via a sampled-token Monte Carlo approximation of the teacher-student log-probability gap Δt on student-generated trajectories. (3) Adaptive Retirement: every H=5 evaluation steps the method tracks windowed alignment progress ρm (whether the teacher-student gap has stopped shrinking) and relative competence ηm (student vs. teacher success rate), and drops the OPD term once ρm ≥ δ=0 and ηm ≥ γ=0.9, continuing with GRPO alone. Experiments use Qwen2.5-1.5B/3B/7B-Instruct on ALFWorld and WebShop, compared against GRPO, GiGPO, PPO, RLOO, Skill-GRPO, OPD, OPSD, and hybrid GRPO+OPD/GRPO+OPSD baselines.

Key results:

• ALFWorld success rate improves over the GRPO baseline by 14.1–18.8 points across the three scales, e.g. 93.8% vs. 75.0% for GRPO on the 3B model (+18.8).
• WebShop accuracy improves over GRPO by 11.8–19.0 points, e.g. 75.8% vs. 56.8% for GRPO on the 1.5B model (+19.0).
• RetireOPD surpasses its own skill-conditioned teacher (Skill-GRPO) in every model/task setting and also outperforms GiGPO across all scales and tasks.
• A 7B model merely prompted with the same privileged skills (no training) reaches only 23.4% success on ALFWorld, showing privileged context alone does not make a reliable teacher.

Why it matters / caveats: Removing the teacher automatically, based on observed training dynamics rather than a fixed annealing/two-stage schedule, avoids withdrawing guidance too early or too late (the paper finds the natural retirement point varies from step 50 to step 90 across settings). Evaluation is limited to Qwen2.5 models up to 7B on two agentic benchmarks (ALFWorld, WebShop).

Problem: GUI agents operate on non-stationary interfaces where pop-ups, delayed loads, and relocated widgets routinely invalidate pre-fixed plans, but existing agent-skill frameworks store skills as unstructured, static artifacts built before deployment rather than procedural knowledge that can be revised from execution feedback.

Method: EvoSkill-GUI represents each skill as a structured multi-file package S = (D, A, P, B, C, F) — retrieval metadata, accessibility-tree utilities, an executable plan, backup localization strategies, failure-recovery rules, and stored failure cases — manipulated only through a restricted tool interface (read, write, append, list, search, create_failure). It runs a training-free reflect-revise-reuse loop: during rollout the executor makes instant in-rollout edits to fix local mismatches; after a failed rollout, the same backbone model acts as an isolated critic under strict information isolation (its input set excludes the skill package, the executor's chain-of-thought, and ground truth) to diagnose the failure, and the executor then edits the specific skill files indicated by the critique. New instructions are matched against the skill library with a weighted lexical+semantic retrieval score (0.6·token-overlap/query + 0.4·Jaccard overlap, plus app/keyword bonuses and a divergence penalty) against a reuse threshold θr; verified packages are added to the library for future reuse. Evaluation covers Claude-Sonnet-4.6, Qwen3.6-Plus, Qwen3.6-35B-A3B, GUI-Owl-1.5-8B, and MAI-UI-8B on MobileWorld, AndroidWorld, and OSWorld, with up to 50 interaction steps per task and at most 2 skill-revision rounds after a failure.

Key results:

• On the MobileWorld GUI-only subset: Claude-Sonnet-4.6 improves from 57.1% to 67.6%, Qwen3.6-Plus from 53.3% to 69.5%, Qwen3.6-35B-A3B from 32.4% to 44.8%, and MAI-UI-8B from 29.5% to 37.1%.
• Maximum reported gains across the three benchmarks: +16.2% on MobileWorld, +6.0% on AndroidWorld, and +10.5% on OSWorld.
• On AndroidWorld, success rate rises by +2.6 points under seed 30 and +6.0 points under seed 42.

Why it matters / caveats: The approach improves multiple base models — both general-purpose and GUI-specialized — with no additional training, and evolved skill libraries reportedly continue to benefit related tasks instead of being rebuilt from scratch each time. It relies on the same backbone model to play both executor and critic roles (no external supervisor), and each failed attempt consumes extra revision rounds within a fixed step budget.

Problem: Document-parsing training corpora are biased toward common document types and clean digital pages, and simply expanding data coverage does not by itself specify how to fix a trained parser's remaining, residual weaknesses.

Method: WeVisDoc is a two-stage data-centric training framework instantiated on Qwen3-VL-Instruct backbones at 2B and 4B scales, using a token-normalized autoregressive training objective (loss computed per supervised target token rather than per record). Stage I builds a ~40-million-record coverage pool (roughly 40% full-page, 25% text/mixed-region, 25% isolated-table, 10% isolated-formula supervision) from heterogeneous real sources plus "page program" synthesis (dual compilation of semantic HTML/CSS into both a rendered image and exact Markdown/HTML/LaTeX targets) and structure-preserving appearance-degradation augmentation (paper/print/scan/photograph effects); annotation reliability is adjudicated by agreement among three expert parsers (MinerU2.5-Pro, PaddleOCR-VL-1.6, dots.mocr) via normalized edit distance, producing checkpoint θ1 under a fixed token budget B1. Stage II uses a held-out diagnostic probe (disjoint from training, hard-mining, and final evaluation) to measure θ1's residual errors within fixed visual-structural clusters, separates annotation errors from verified model errors, and forms a ~5-million-record refinement pool (validated additions + Stage I replay + audited hard examples) that reallocates a second token budget B2 to retrain into θ2, freezing the visual encoder and updating only the language model.

Key results:

• WeVisDoc-4B achieves an Overall score of 95.38 on OmniDocBench v1.6 and a mean (Avg3) Overall score of 75.54 across the three PureDocBench tracks, ranking first among compared end-to-end parsers in all four reported settings.
• WeVisDoc-2B reaches 95.06 Overall on OmniDocBench v1.6 and 73.86 Avg3 on PureDocBench, remaining competitive with roughly half the parameters of the 4B model.
• Stage II improves Overall scores over Stage I for both the 2B and 4B models on both benchmarks, with larger gains on the degraded PureDocBench tracks than on clean pages, including a 4.03-point gain for the 4B model on the Real Degraded track.

Why it matters / caveats: The framework separates "does the parser lack data support" from "does it need more exposure to existing data," giving a principled way to allocate a fixed supervised-token budget rather than just scaling data volume, and the gains are largest precisely on degraded/real-world acquisition conditions rather than clean scans. The authors note Stage II combines several interventions together, so the paper's stage-wise results cannot isolate the effect of residual-aware allocation in isolation.

Problem: Softmax attention dominates (>85% of denoiser runtime) and scales quadratically in long-sequence video diffusion, but directly swapping in linear attention degrades generation quality because a fixed-size compressed state cannot preserve the fine-grained interactions Softmax provides.

Method: Video DeltaNet (VDN) is a hybrid attention layer that keeps sliding-window Softmax attention (a 15-frame bidirectional window plus two four-way-connected boundary anchors at the first/last latent frames) for local/global-anchor interactions, while a bidirectional linear branch called Video Delta Attention (VDA) — a frame-wise delta rule that jointly solves a closed-form update over all spatial tokens in a frame (St = (S̄t + Bt)(I + At)⁻¹) rather than per-token — handles distant video context; branch outputs are RMS-normalized, sigmoid-gated, and combined via separate output projections. It is instantiated on MiniMax H3 via a three-stage adaptation recipe (Stage A1: 200-step per-layer alignment with backbone frozen; Stage A2: 500-step end-to-end alignment; Stage B: 2,000-step LoRA co-adaptation of Q/K/V/O with Linear pathway and Softmax gates), followed by DMD2-style few-step distillation (without the GAN term) from 50 to 8 denoising steps, trained on 10,015 curated 1344×768, 345-frame (24 fps) video clips.

Key results:

• VDN-H3 completes DiT denoising for a 14.3-second, 768p video in 6.70 seconds on 8 NVIDIA B200 GPUs, a 14.5× speedup over the 50-step dense H3 baseline on the same GPU count (up to 119.3× vs. single-GPU dense H3).
• Eight-step VDN-H3 matches or exceeds 50-step Dense H3 across five no-reference video-quality metrics (differences +0.06 to +1.00), while 4-step FastH3 scores 2.70–12.74 points lower than Dense H3.
• VDN-H3 preserves motion magnitude close to Dense H3 (RAFT mean flow 11.71 vs. 11.55 pixels), versus FastH3 dropping to 9.19.
• Progressive acceleration on a single B200: dense H3 50-NFE denoising takes 799.6s, dropping to 307.9s with VDA, 49.3s with 8-step distillation, and 6.70s with 8-GPU distributed inference.

Why it matters / caveats: The approach shows pretrained dense video diffusion models can be converted to efficient hybrid-attention models without training a new foundation model from scratch, enabling near-real-time long-video generation; results are reported on a single fixed third-party 103-prompt benchmark and one backbone (MiniMax H3), so generality to other video DiTs is not directly demonstrated in the excerpted text.

Problem: Existing spatial-reasoning and manipulation benchmarks evaluate evidence acquisition, spatial inference, and execution separately (often with privileged object poses, fixed camera views, or learned action heads), so it remains untested whether a general-purpose MLLM can close the full observe-reason-act-revise loop on its own.

Method: VA-Bench is a physics-simulated benchmark (built on RoboTwin with a fixed, model-agnostic inverse-kinematics/trajectory executor) in which a general-purpose MLLM watches an RGB-only demonstration video, actively selects camera viewpoints (a bounded discrete set of gripper-centered semantic views plus translation/zoom/yaw/pitch adjustments), issues metric Cartesian robot commands (1–100mm translations, 1–90° rotations, gripper aperture), and revises actions from execution feedback, with no privileged poses, oracle trajectories, or learned action heads supplied. It covers 14 base task families (11 single-arm, 3 dual-arm) with 20 physically verified seeds each, 7 held-out geometry/layout transfer variants, and a five-object long-horizon composition track, scored by terminal task success plus nine human-annotated trajectory-level behavioral diagnostics (target localization, active exploration, spatial relations, manipulation semantics, planning, pre-contact analysis, error detection, online correction, post-failure adjustment) across 3 independent runs (840 run-seed episodes) over 12 primary model conditions (e.g., Qwen3.8-max, Opus-5, GPT-5.6 variants, Doubao-2.1, Gemini-3.6).

Key results:

• The best-performing model scores 100.0% on target localization and 78.9% on spatial relations, yet its three-run macro-average task success across 14 tasks is only 53.93 ± 3.17%.
• Active camera control substantially improves task success over passive multi-view observation: in one matched comparison, success rises from 27.86% to 57.50%; the best active-exploration diagnostic score across all 12 conditions is 83.2%.
• Held-out geometric/layout transfer causes large degradation: across seven matched families, one condition drops 32.14 points (80.00% → 47.86%) while another drops 10.00 points (77.86% → 67.86%).
• On the long-horizon five-object basket task, the strongest conditions complete 61/100 and 53/100 object placements respectively, but no model completes a single strict long-horizon episode.

Why it matters / caveats: The results show a clear gap between spatial-perception competence (localization, relations) and reliable executable action, and expose brittleness to geometric transfer and compositional long-horizon tasks — useful for diagnosing where embodied MLLM pipelines fail rather than just whether they succeed overall.

Problem: Large reasoning models overthink easy problems and underthink hard ones, and existing uniform length-penalty or rigid-routing efficiency methods impose an "efficiency tax," trading reduced computation on easy instances for accuracy loss on hard ones.

Method: When2Think is a post-training RLVR framework built on a hybrid THINK/NOTHINK mode-token policy (following AdaptThink's importance-sampling exploration scheme and PPO-style clipped surrogate objective) that adds Instance-level Difficulty-Aware Control (IDAC): a reward-shaping term λi,k = exp(−T(oi,k)·αi/τi) computed from offline, epoch-wise pre-computed reference statistics — instance difficulty αi (reference policy accuracy, γ=0.9 scaling) and expected reasoning cost τi (reference trajectory length) from a reference policy πref — combined with a correctness-gated reward ri,k = V(xi,oi,k)(1+λi,kδ) − αi and a batch-wise standardized advantage (BWS, inspired by REINFORCE++) for critic-free optimization requiring no learned reward model or online reference-model queries. It is trained on R1-Distill-Qwen-1.5B (distilled from DeepSeek-R1 on Qwen2.5-Math-1.5B via ~800k SFT samples) using the DeepScaleR dataset (~40k competition-level math problems from AIME 1984–2023, AMC pre-2023, Omni-MATH, and Still).

Key results:

• On AIME24, When2Think achieves 56.0% Pass@3 (+10.0 points over the R1-Distill-Qwen base's 46.0%) while reducing average tokens from 14,195 to 10,236 (a 27.9% reduction).
• On AIME25, When2Think achieves 40.0% Pass@3 (+8.0 points over base's 32.0%), with tokens reduced from 12,616 to 9,549.
• On GSM-Plus, Pass@3 rises to 85.7% (+6.3 over base) using only 1,052 tokens (vs. base's 590, though this is a modest increase from base — the paper frames it as near-LLM-level efficiency on easy problems); on OlympiadBench-Math, 62.4% Pass@3 (+3.6) with tokens cut from 8,634 to 5,909.
• When2Think's AIME25 result (40.0%) outperforms compression baselines (LC-R1: 32.0%, ThinkPrune: 36.0%, LASER: 37.3%) and routing-only/hybrid baselines (AdaptThink: 30.7%, Thinkless-RL: 33.3%).

Why it matters / caveats: By conditioning the efficiency bonus on per-instance difficulty rather than a global length target, the method mitigates the efficiency tax where static compression baselines gain speed on easy problems but lose accuracy on hard ones (e.g., LC-R1 drops AIME24 accuracy by 10.0 points). The evaluation is limited to a single 1.5B math-specialized backbone and math reasoning benchmarks.

Problem: Existing evaluators for subject-driven image customization (embedding-based like CLIP/DINO, or MLLM-based like VIEScore/DreamBench++) score textual and visual condition alignment in isolation, which contradicts the simultaneous-alignment objective of multi-modal generation and causes false positives/negatives that disagree with human judgment.

Method: UFO is an Atomized Chain-of-Evaluation framework with four stages: (1) a VLM decomposes omni-condition alignment into fine-grained Atomic Evaluation Units (AEUs) across local-concrete and global-abstract levels; (2) each AEU is classified by modality-relevance (image-only, text-only, or text-and-image); (3) each AEU is scored either via a binary VQA query (Yes/No mapped to 1/0) or a dedicated function call, e.g., ArcFace for facial identity (score = 1 − normalized ArcFace distance); (4) AEU scores are aggregated via VLM-assigned adaptive importance weights (wi ∈ {1,2,3,4,5}) into a weighted-average holistic score. The accompanying UFO-Bench benchmark contains 86 reference images across 7 subject categories (Rigid Object, Soft Object, Human, Full-body Character, Animal, Logo, Scene), with four editing paradigms (Non-Editing, Local, Global, Complex Editing) across three difficulty tiers, yielding 660 cases with 81.97% conflicting condition pairs; evaluation uses GPT-4o (version 2024-05-13) as the judge MLLM.

Key results:

• UFO achieves the highest correlation with human evaluation preferences among tested metrics, improving average Spearman correlation by 15.25% over existing methods.
• On UFO-Bench (2,640 instances per model, 4 samples per reference-prompt pair), the closed-source Doubao (2025-12) attains the top total score of 0.7439, while open-source Qwen-Image (2025-12) scores 0.7252, ahead of Nano-Banana (0.6816) and other open-source models (OmniGen2: 0.4235, BAGEL: 0.3866, UNO: 0.4549).
• Human-alignment (Spearman correlation, Table 2): UFO substantially outperforms CLIP-T (-0.1996), CLIP-I (0.3910), DINO (0.3084), and VIE-Score SC (0.5752); MLLM-based baselines VIE-Score and DreamBench++ reach only ~0.58 correlation on the local-editing subset due to lacking mechanisms to decouple edit regions from preserved background.
• Human evaluation was conducted on 100 sampled test cases (600 generated images from six models) with per-case ranking-based Spearman correlation.

Why it matters / caveats: By decomposing evaluation into atomic, modality-tagged units with specialized scoring (e.g., ArcFace for identity), UFO better captures conflicting text-vs-identity edit requirements than holistic scoring, offering a more human-aligned automatic metric and a benchmark (UFO-Bench) with far more conflicting text/image condition pairs than prior datasets; results depend on GPT-4o as judge, which may itself introduce evaluation biases not fully characterized in the excerpted text.

Problem: In LLM test-time scaling (e.g., self-consistency, best-of-N), studies typically report only the candidate count N, but N does not specify how those candidates are generated (one large batched call vs. several smaller sequential calls), which can hide large differences in systems cost.

Method: The authors formalize a candidate-generation schedule S = (b1,...,bC), where C is the number of sequential generation calls and bc is the batch size per call, and compare four fixed-budget (N=8) schedules — 1×8, 2×4, 4×2, 8×1 — on Phi-3-mini-4k-instruct and Qwen2.5-1.5B-Instruct. They measure latency, throughput, GPU-hours, utilization, and gross GPU-device energy (via NVML cumulative-energy readings) on A100 GPUs (GSM8K, 100 prompts × 3 repetitions, plus 3 independently scheduled nodes per model) and V100 GPUs (SciQ, 500 prompts × 3 repetitions, short-output validation), using plurality voting over candidates with no verifier/reward model.

Key results:

• Increasing N from 1 to 8 improves accuracy by 8.4 percentage points for Phi-3-mini and 18.4 points for Qwen2.5-1.5B on 500 GSM8K prompts.
• At fixed N=8 on A100 GPUs, eight serial generation calls (8×1) use 4.64–4.86× as much gross GPU-device energy as one batched call (1×8) with eight candidates.
• The 8×1 serial schedule also has 5.77–6.12× the P95 latency of the 1×8 batched schedule, with the pattern consistent across three independently scheduled A100 nodes per model and in the short-output SciQ/V100 experiments.

Why it matters / caveats: Reporting candidate count N alone is insufficient to characterize the systems cost of multi-candidate test-time scaling; the authors recommend also reporting generation schedule (calls per query, candidates per call) and GPU-level energy metrics, and note that when candidates are independent and memory allows it, fewer calls with larger batch sizes are more efficient. The study is limited to two small/medium models and specific A100/V100 hardware configurations.

Problem: Existing feed-forward methods for articulated-object modeling infer joint structure from a single point cloud observation and thus rely heavily on learned category-level shape priors, generalizing poorly to unseen geometries, while optimization-based and video-based methods require dense multi-view or temporally-ordered captures that are expensive or error-prone.

Method: FAMOS is a feed-forward Multi-state Articulation Transformer that takes a sparse, unordered set of partial point clouds (variable number of input states S, including S=1), encodes each with a frozen PartField backbone plus sinusoidal geometric embeddings, and jointly refines K=16 learnable part queries and point tokens through L=6 transformer layers (hidden dim D=768, 12 attention heads) alternating state-wise self-attention with global attention over all queries and points concatenated (length K+SN). It is trained with a novel "observed articulation span" auxiliary loss (supervising the range of joint values covered across input observations via Hungarian matching) alongside segmentation, joint-type, revolute (Plücker), prismatic, and span losses, using AdamW (peak LR 3×10⁻⁵, cosine schedule, batch size 128, bfloat16, gradient clipping 1.0) on 4× A100 40GB GPUs, in two stages: 50k steps of procedural-data-only pretraining, then 80k steps on a 1:1 mixture of procedural assets with PartNet-Mobility (1,020 objects, 25 classes) and GRScenes (968 objects, 15 classes). A procedural generator assembles objects from 6 analytic primitives into 15 object families for unlimited self-annotated training data.

Key results:

• On movable-part segmentation F1 (IoU@0.5), FAMOS scores 98.4 (PartNet-Mobility), 71.9 (ACD), and 92.5 (ArtiCraft-10K), beating the strongest feed-forward baseline (Particulate, retrained) by 28.2 F1 points on ACD and 15.9 F1 points on ArtiCraft-10K.
• The abstract reports relative improvements over the strongest feed-forward baseline of up to 64.5% in segmentation and 75.7% in motion-estimation F1.
• On PartNet-Mobility motion estimation (strict M+MA+MAO F1), FAMOS reaches 98.4% versus 90.3% for Particulate and ≤39.7% for optimization-based baselines (ReArt, ArtGS), while running nearly 3,000× faster than optimization-based methods.

Why it matters / caveats: By grounding predictions in observed cross-view motion rather than shape priors alone, and supporting a variable number of casual, unordered captures (down to a single view), FAMOS generalizes to real-world casual captures despite training solely on synthetic/procedural data. Optimization-based baselines were given denser inputs (e.g., ArtGS received 16 views per state plus ground-truth part count) as a concession for fairness, so direct comparisons should be read with that caveat.

Problem: On-policy self-distillation (OPSD) lets a frozen teacher copy of a model score a student's own rollouts while seeing extra privileged information (PI) such as a reference solution, but it is unclear how much benefit actually comes from the privileged reference itself versus from cross-mode (thinking-enabled teacher scoring direct-response student) distillation alone.

Method: The authors build AMPLE-MATH, a suite of 5,319 math problems from OpenThoughts-114k, each with six answer-matched reasoning views (Answer Only, Gist, Key Points, Clean Solution, Summary, Full Trace; mean lengths 13–4,916 Qwen3 tokens) sharing one verified answer, plus a reference-free control. They train Qwen3-1.7B with LoRA adapters (r=64, α=128) for 100 optimizer steps and SmolLM3-3B as a cross-family test, using a frozen thinking-enabled teacher to score direct-response student rollouts via a forward-KL OPSD loss (clipped per-vocabulary-term at 0.05) applied only at supervised positions, evaluating primarily with thinking enabled (Avg@4, and Avg@12 on AIME 2024/2025 and HMMT 2025). They also compute "correctness alignment" (Cv) and "correction pressure" (Fv) diagnostics on fixed student prefixes to probe what different references encourage token-by-token.

Key results:

• In Qwen3-1.7B, the reference-free (no-PI) student already captures most of the improvement; at step 100 Answer Only and Full Trace sit only about 0.6 points above the reference-free student, with confidence intervals including zero.
• Clean Solution gives the clearest additional benefit in Qwen: a step-100 advantage of 1.30 points [0.20, 2.41] over reference-free training (averaged over three seeds), though this does not survive Holm correction across the six views.
• In SmolLM3-3B, Full Trace adds 2.0 percentage points over reference-free training at step 50 (with thinking enabled), and by step 100 it degrades less than the reference-free and Answer Only conditions.
• Switching student rollouts from direct-response to thinking-enabled during training reverses transfer: at step 50 all three tested views (Answer Only, Clean Solution, Full Trace) turn gains over the base model into losses, e.g., -7.6 to -8.4 points for Qwen3-1.7B in-domain.

Why it matters / caveats: The results suggest OPSD's gains largely come from cross-mode transfer through shared parameters (thinking-enabled teacher scoring direct-response prefixes) rather than from the privileged reference content itself, and the value of a reference depends heavily on the student's own rollout/training configuration, not just how much solution detail it reveals. The added benefit of privileged information is modest and model/view-dependent, with several comparisons not reaching statistical significance after correction.

Problem: Standard supervised fine-tuning (SFT) for LLM agents applies the training loss only to agent-authored action tokens, treating environment observations purely as context, and it is untested whether this convention gives the best initialization for subsequent reinforcement learning (RL).

Method: The paper introduces ActObs, which changes only the SFT loss mask to also supervise the observation tokens already present in trajectories, via a weighted loss Lλ combining action-token and observation-token cross-entropy (λ=0 recovers standard ActionSFT; default ActObs uses λ=1), with prompts always masked. All methods share one corpus of 50k multi-turn terminal trajectories (0.71B tokens, ~45% observation tokens) from Nemotron-Terminal-Corpus generated by DeepSeek-V3.2, fine-tuning Qwen3-4B and Qwen3-8B for one epoch (781 steps, batch size 64, cosine schedule, peak LR 1e-5), followed by GRPO for 135 steps on 2,392 containerized tasks from Endless Terminals (16 rollouts/task, batch size 32, LR 1e-6, binary verifiers). A timing-control baseline, Obs→Act, does one epoch of observation-only SFT then one epoch of action-only SFT for comparison.

Key results:

• After SFT alone, ActionSFT, ActObs, and Obs→Act perform similarly on Terminal-Bench 2.0, but after GRPO they diverge substantially.
• At 4B, ActObs→GRPO beats ActionSFT→GRPO at pass@1/4/8/16 by 1.6/1.4/1.5/1.1 percentage points (29%/13%/11%/6% relative advantage), a 29% relative gain at pass@1.
• At 8B, ActObs trades some pass@1 reliability for higher pass@k, with its lead over ActionSFT growing from 0.6 points at pass@4 to 2.6 at pass@8 and 3.4 points (14% relative) at pass@16, and solving 24 distinct tasks versus 21 for ActionSFT.
• On cross-domain aider-polyglot (225 multilingual code-editing tasks, unseen during SFT/RL), the 4B ActObs→GRPO policy exceeds ActionSFT→GRPO by 43% relative at pass@1 and 24% at pass@4, despite starting from a weaker code-editing checkpoint pre-RL.

Why it matters / caveats: ActObs adds no new data, parameters, sequence tokens, or forward passes — it is a one-line loss-mask change — yet it changes SFT gradient geometry (action and observation gradients become nearly orthogonal) and preserves environment-prediction ability that ActionSFT degrades, letting GRPO retain more entropy and explore more effectively; the effect is an SFT initialization effect that only manifests after RL, not in SFT-only evaluation.

Problem: Improving fine-grained visual perception in multimodal large language models (MLLMs) by raising resolution inflates vision-encoding and LLM prefilling costs, even though localization (finding the region of interest) and recognition (reading its content) actually tolerate very different amounts of token compression.

Method: The authors first run a controlled diagnostic on ZoomBench with Qwen3.5-4B showing localization tolerates ~3-4x stronger token compression than recognition. Building on SD-RPN (a Self-Distilled Region Proposal Network attached to the first B frozen MLLM blocks), they introduce Vision-RL2, a region-level reinforcement learning method: coherent visual regions are treated as discrete actions, and a frozen MLLM "reader" scores each region by the change in teacher-forced gold-answer likelihood when it is removed (a leave-one-out contribution, clipped to [-5,5]). A subtractive policy objective (with noise-calibrated margin from control regions) prunes low-contribution proposed regions, and an additive objective (using response-to-image attention from six MLLM layers) recovers missed evidence; only the RPN parameters are updated, with a KL anchor to the frozen initial SD-RPN. At inference, a sparse visual encoding step re-encodes only the predicted foreground at a magnified spatial zoom η=min(√(1/ρfg), ηmax), reusing the source image's KV cache.

Key results:

• On Qwen3.5-4B, the method matches SD-RPN's accuracy using 4.2x fewer visual tokens, and localization survives ~25x token reduction vs. ~9x for recognition at matched accuracy.
• Across six fine-grained benchmarks (V* Bench, ZoomBench, HR-Bench 4K/8K, MME-RW EN/CN) and four MLLM backbones, Vision-RL2 improves accuracy over the base model at every token budget and surpasses the base model's largest-budget accuracy with about 4x fewer visual tokens.
• On the Qwen2.5-VL-7B backbone under a 16,384-token limit, Vision-RL2 reaches 91.6 (V* Bench) and 59.8 (ZoomBench), average 71.0, versus base-model competitors ZwZ (69.9 avg), DeepEyes (68.1 avg), Thyme (67.6 avg), and DeepEyesV2 (68.0 avg).
• The method outperforms prior state-of-the-art methods that fully finetune the base model under the same token limit, while training roughly an order of magnitude fewer parameters (updating only the lightweight RPN).

Why it matters / caveats: The approach gives a cheap, decode-free way to route high resolution only to evidence-bearing regions without full-model finetuning or reasoning trajectories/response sampling, which could substantially cut inference cost for fine-grained MLLM tasks; it still depends on the quality of a frozen base MLLM as reader and on SD-RPN initialization.

Problem: No existing benchmark systematically measures whether enterprise LLM assistants keep following embedded compliance rules (in regulated domains like hiring, healthcare, and finance) when a benign but pressuring user or manager makes a rule-violating shortcut convenient, as opposed to merely testing whether models can state the rule.

Method: The authors build PACT (Pressure-Applied Compliance Testing), a benchmark of 3,364 items spanning 12 regulated enterprise domains and 48 realistic multi-turn scenarios (privacy/GDPR, finance, HR, HIPAA, AML, export controls, etc.), each pairing a standing rule against a rule-violating shortcut offering a tangible benefit. Items are generated component-by-component by three open-source LLMs (Kimi-K2.6, Nemotron-Ultra, GLM-5.2) and cross-audited by the other two models against a checklist (scope and authenticity), with a battery of nine psychology-grounded pressures (deadline, manager authority, descriptive norm/peer example, weak deterrence, loss aversion, false authorization, sunk cost, empathy, diffused responsibility) and an optional second-turn user pushback. Each sample runs three times per model; a GPT-OSS-120B extractor classifies responses as comply/violate/unclear, and a 3-model judge ensemble scores violation transparency. Six metrics (Default Compliance, Pressure Resistance, Pushback Resistance, Steerability, Transparency, Rule-Scope Discernment) are computed via a pass^3 reliability criterion and aggregated into PACTScore (0.75 weight on turn-1 compliance, 0.25 on multi-turn follow-up), evaluated across 22 LLMs (18 open-weight, 4 closed).

Key results:

• The top model, Kimi-K2.7-Code, achieves a PACTScore of 0.944 (still unreliable on ~6% of decisions); no model reaches 0.95. Grok 4.3 (18th of 22) scores 0.870, and Mistral-7B scores 0.484.
• Ordinary user pressure raises the average violation rate from 4.41% to 7.29% of decisions (about a 65% relative increase); even Claude Haiku 4.5, which never violates an unpressured rule, fails one pressured situation in 43.
• Rule-Scope Discernment is lower than Default Compliance for all 22 models — across 13,817 base-mode decisions where the rule does not apply, models enforce it anyway 19.6% of the time on average; Claude Haiku 4.5 combines the lowest violation rate with one of the highest over-application rates (21.9%), scoring 1.000 on Default Compliance but only 0.855 on Rule-Scope Discernment.
• Turn-1 compliance ranges from 0.883 (under "false clearance" pressure) to 0.952 (under "peer escaped" pressure), so even the mildest tested pressure produces violations on 4.8% of requests; 80.5% of pairwise model comparisons are statistically significant.

Why it matters / caveats: The results show model knowledge of a rule does not predict behavior under pressure, and that compliance dimensions (robustness, transparency, scope discernment) trade off independently, so no single model is safe for unsupervised deployment in regulated workflows; the benchmark relies on LLM-based item generation, auditing, and judging (inter-reviewer agreement only 66.9% on components), which the authors partially validate but is itself a potential source of noise.

Problem: Generative font models for Brahmic (Indic) scripts typically only produce glyph images, not installable fonts, because a text-ready Indic font requires an intact OpenType shaping-engine contract (hundreds to thousands of mutually consistent conjuncts, half forms, and matra variants via GSUB substitution) that raster glyph generators do not preserve.

Method: Srijika restyles the glyph outlines of a shaping-complete template font rather than generating a font from scratch: it retains the template's cmap and GSUB substitution closure unchanged and reuses its GPOS positioning data under a documented metric policy, so every output is a valid font by construction, for nine scripts (Devanagari, Tamil, Bengali, Telugu, Kannada, Malayalam, Gujarati, Gurmukhi, Odia). Style is retrieved via Lipika, an index over ~650 open-license font families built from a ConvNeXt-V2-tiny recognizer (trained with a sub-center ArcFace head) and a CLIP-L text/image tower with a LoRA-adapted image tower, which grounds free-text prompts in six reference donor tiles. A reference-conditioned latent diffusion UNet (134M parameters: 132.9M UNet + 1.2M trained style-projection layer) over 128×128 glyph tiles redraws each template glyph conditioned on the donor style via cross-attention, using classifier-free guidance (scale 3-4.5, 50 sampling steps). A four-stage defect-tolerant serving pipeline (content gate + retry ladder, weight harmonization with a coherence cap, baseline snap, shaped-cluster verify-and-repair via HarfBuzz) reverts any glyph that fails verification to the template outline. New scripts are added via warm-start grafting: resuming the latest checkpoint and training for a ~20-48k step window with a cosine LR restart (peak ≈2.3×10⁻⁵), with per-script routing used to avoid cross-script "dilution" degradation observed under sequential grafting.

Key results:

• The system ships 66 installable TTFs (57 curated presets + 9 open-vocabulary showcase fonts); all pass the OpenType Sanitizer, and HarfBuzz/CoreText reproduce the template's glyph-ID sequences on conjunct-heavy probes for every font (audit spans 80,915 glyphs and 54,812 anchors).
• On diffusion-training-family-held-out SSIM gates, unrestyled template copy beats generation on 50 of 56 faces; style movement (gap closure vs. template, measured by the Lipika embedding) is small for most families (median gap closure 0.05) but one out-of-distribution family (Alkatra) reaches 0.85-0.94, indicating strongly family-specific style transfer.
• The shaped-cluster verify-and-repair stage converges to cluster accuracy of 0.981-1.000 fleet-wide, with 7-110 glyphs per font reverted to the template outline.
• New scripts grafted from a shared checkpoint reach competitive zero-shot SSIM quickly: Gurmukhi and Odia entered at 0.7861 and 0.7622 zero-shot SSIM after ~7 GPU-hours each on a single H100.

Why it matters / caveats: The layout-reuse approach sidesteps the hardest part of Indic font generation (shaping correctness) by construction, addressing a real typographic gap (e.g., Google Fonts has 1,800+ Latin families but only six Odia families), but the paper is explicit that it evaluates only against no-learning baselines (template copy, morphology, geometric transform) — no learned few-shot baseline, independent style metric, or human study is included, and style transfer quality is uneven and family-specific.

Problem: Spoken question answering (SQA) has no benchmark for Telugu, and it is unknown how reliable automatic (especially LLM-as-a-judge) evaluation is for this low-resource, spoken setting.

Method: The authors build VākQA, a Telugu SQA benchmark of 2,001 factoid question-answer pairs (2.53 hours of audio, 4.55s average clip length) across six domains (Science, General Knowledge, Politics, History, Culture, Geography), collected from Telugu quiz-style YouTube videos via a semi-automatic pipeline: Pyannote VAD segmentation into 7-second chunks, transcription with a fine-tuned Seamless-large-v2 Telugu ASR model (trained on ~900 hours from IndicVoices, Kathbath, Google FLEURS, SyspIn TTS, and IndicTTS), Gemini-based QA-pair extraction, Whisper-timestamped/IndicWhisper word-level alignment (Levenshtein ratio ≥85%), and human verification plus manual English translation by five annotators. They validate evaluation metrics (EM, F1, BLASER-2.0, and LLM-as-a-judge using Gemini and Gemma-3 4B/12B/27B) against 400 human-rated triplets (five native speakers, 1-5 rubric, Krippendorff's α=0.836 after excluding 20 outlier items), then benchmark QA models (Gemini-2.5-Flash and open-weight Gemma-3 4B/12B/27B, Llama-3.1, Hex-1, Sarvam-m, Qwen-3-4B) across input modality (speech/text), input language (Telugu/English), and cascaded ASR→MT configurations.

Key results:

• Gemini-as-a-judge best approximates human judgment (Spearman ρ=0.86, Kendall τ=0.77) vs. Gemma-3-27B (ρ=0.80), Gemma-3-12B (ρ=0.81), and Gemma-3-4B (ρ=0.57, the weakest); lexical/embedding metrics correlate much worse (EM ρ=0.37, F1 ρ=0.49, BLASER-2.0 ρ=0.36).
• Switching the judge from Gemini to Gemma-3-12B changes 46.23% of scores for the worse vs. only 21.14% improved, showing Gemma judges systematically penalize correct Telugu answers with different surface form.
• On oracle Telugu text input, Gemini scores 3.63 (out of 5) vs. open-weight models: Gemma-27B 2.55, Gemma-12B 2.01, Sarvam-m 1.98, Gemma-4B 1.43, with several other models near or below 1.5.
• Switching Gemini's input from oracle Telugu to oracle English text degrades its score slightly (3.63→3.52); pairwise comparison shows Telugu→English input degrades performance on 18.8% of questions, improves it on 16.5%, and leaves 64.7% unchanged.
• Moving from oracle Telugu text to Telugu ASR transcripts drops Gemini's score from 3.40/3.09 (across two ASR paths) and Gemma-27B from 2.34/2.22, with further drops under cascaded ASR→MT translation into English.

Why it matters / caveats: VākQA is presented as the first Telugu SQA benchmark with native spoken questions (not translated or TTS-synthesized) and shows LLM-as-judge reliability is judge-dependent, cautioning against uncritical use of open-weight judges for low-resource-language evaluation; results also show large proprietary-vs-open-weight performance gaps and compounding ASR→MT error effects, though the benchmark itself is modest in scale (2,001 items, single-language pair).