AI papers — 2026-09-21

Problem: Existing methods for synthesizing reusable agent skills are limited because trajectory-based synthesis is coupled to the generating agent's environment/experience while document-based synthesis lacks concrete executable evidence for grounding and verification.

Method: Code2Skill is a fully automated pipeline that ranks procedural source units (functions, methods, CLI entry points, file-level components) from GitHub repositories via an LLM tagger, then extracts them into three typed skill records—atomic-operation, composite-workflow, and recurring-pattern—capturing applicability, steps, invariants, failure handling, anti-goals, and provenance. Grounding is verified through source-body-blind reconstruction (an LLM regenerates code from only the skill record) followed by source-aware judge comparison against the original implementation, with unresolved cases routed to an adjudicator; accepted records are organized into a provenance-rich, feature-tagged, purpose-indexed evidence archive for retrieval. Applying this pipeline to 19,769 GitHub repositories (>500 stars, as of April 14, 2026) produces CodeSkillBank.

Key results:

• CodeSkillBank contains 1,006,822 accepted skill records mined from 19,769 repositories (median 3,133 stars, 82 merged PRs; 78.3% ≥1,000 stars).
• Across 72 protocol-matched evaluations (9 model settings × 8 benchmarks), skills improve the macro-average score from 42.90 to 47.90 (11.7% relative gain), winning 57 of 72 comparisons; per-model/reasoning-mode average gains range 2.26–7.39 points (6.0%–20.7% relative).
• All 9 SWE-bench Verified comparisons improve with CodeSkillBank.
• Against trajectory-derived baselines (Trace2Skill, ExpeL, SkillRL-Bank) under a shared interface, Code2Skill scores 49.5 averaged over 7 benchmarks vs. 31.0, 27.9, and 32.8 respectively, and beats the best baseline per benchmark by 6.6–13.3 points (oracle best-of-baselines only reaches 40.1).
• In human evaluation, 92% of retained skill descriptions are judged accurate and 80% judged worth retaining; 84% of directly accepted records support correct reconstruction (vs. 32% accuracy/28% retention/0% correct reconstruction in the rejected sample).
• Retrieval design: at k=3, summary rendering cuts average context by 88.9% (6,352→707 characters) while preserving/improving accuracy; increasing k from 1 to 10 expands context (2.1K→17.8K chars) with little added utility.
• In coding RL (Qwen3-32B SWE-World, step 150), all four skill-integration interfaces beat the 24% no-skill resolve rate: full/summary policy prompting and reward-side reference reach 31–32%, and post-generation review reaches 38%.
• Skills synthesized from tested AI-generated code (via GPT-5.1/Codex) achieve a 93.50% pass rate on a 400-task LiveCodeBench subset vs. 93.00% for human-code-derived skills, though the two sources disagree on 16 tasks (human bank uniquely solves 7, AI bank uniquely solves 9).

Why it matters / caveats: The results suggest source code is a scalable, auditable, and verifiable substrate for building procedural skill libraries that can benefit agents even before they accumulate their own task experience, and that the same pipeline can keep expanding as AI-generated code becomes more prevalent. Caveats noted in the paper include mixed/inconsistent benefits under some settings (e.g., BigCodeBench under reasoning mode, some purpose-indexing configurations), and the RL experiment reports only a single checkpoint without repeated seeds or learning curves, so it does not establish differences in learning speed or final convergence.

Problem: Training coding agents with reinforcement learning requires diverse tasks with reliable verifiers, but existing pipelines tie task construction to the limited coverage of development artifacts (issues, PRs, commits, existing tests, or documentation).

Method: CodeMidas is an agentic pipeline that constructs executable RL environments using only source code as input, via four stages: (1) task design and codebase adaptation, where an agent identifies implemented functionality with public entry points, removes the core implementation, and adapts the surrounding codebase into a development starting point while retaining the original as a reference solution; (2) execution-grounded test construction, where tests are built from executing the reference implementation and reviewed to remove restrictions unsupported by the task statement; (3) environment preparation with execution consistency checks (two fresh-container runs on the starting code must fail, four on the reference must pass); and (4) post-rollout filtering combining adversarial leakage checks, solution-review agreement checks, and rollout outcome filtering (keeping only tasks with mixed pass/fail attempts). The resulting 5,545-task dataset is used to train MiMo-V2.5 with GRPO (binary execution rewards, batch size 32, 32 rollouts per task).

Key results:

• Dataset: 5,545 verifiable training tasks from 3,185 open-source codebases spanning 23 programming languages and 15 technical domains (Python 21.4%, TypeScript 18.3%, Go 16.2%, C++ 12.5%, JavaScript 11.3%); median reference solution size 142 lines (IQR 66–305); 65.9% of tasks touch ≥2 source files.
• Benchmark gains after GRPO training of MiMo-V2.5: DeepSWE pass rate 10.0% → 21.7% (+11.7pp); ProgramBench Almost Solved 4.5 → 21.5 (+17.0pp); Terminal-Bench v2.1 pass rate 63.7% → 72.2% (+8.5pp); SWE-bench Pro 50.3% → 54.4% (+4.1pp); RepoZero C2Rust 40.5% → 51.8% (+11.3pp).
• CodeMidas Val (200 held-out tasks) pass rate rises from 35.0% to 44.7% over training.
• Scaling ablation: high-quality task pools of 1k/3k/5k tasks give progressively higher DeepSWE scores (17.57 → 19.05 → 21.70) and CodeMidas Val scores (41.30 → 43.22 → 44.73); the filtered 5k pool beats an unfiltered vanilla 8k pool by 0.59pp (SWE-bench Pro), 4.59pp (DeepSWE), and 4.49pp (CodeMidas Val), and even the 3k subset outperforms the 8k vanilla set on all three.
• Behavioral analysis: codebase exploration (pre-edit read/search calls) rises from 27.2 to 40.1; code-drafting ratio from 0.36 to 0.63; distinct post-edit self-verification commands from 2.03 to 2.53; self-verifying rollouts show a 4.2pp higher mean pass rate (95% CI 1.8–6.6) than non-verifying ones on CodeMidas Val, and similar exploration/drafting increases generalize to SWE-bench Pro, ProgramBench, and Terminal-Bench v2.1.

Why it matters / caveats: The results establish that source code alone—without issues, PRs, commits, or documentation—can be turned into a scalable supply of high-quality, verifiable RL environments that transfer across issue repair, whole-program construction, code translation, and terminal tasks; the finding that a filtered 3k-task set beats an unfiltered 8k set underscores that verifier reliability and filtering matter more than raw task count, though the approach still depends on multiple agentic review/filtering stages (leakage checks, solution audits, rollout filtering) whose own reliability is not independently benchmarked.

Problem: Data agents interacting with heterogeneous data sources (tables, files, databases) face an "agent–data gap," since existing raw-querying approaches scale poorly to large sources while static, manually-built semantic layers are costly to construct and fail to adapt to new data or agent behaviors.

Method: EvoOntology encapsulates a versioned ontology (schema layer defining object types/reference rules, content layer of typed semantic graph nodes—Terms, Mappings, Constraints, Evidence—and edges—Semantic Relations, Structural References, and a tool layer with MCP-exposed browse/resolve functions) as a Model Context Protocol (MCP) server that agents query at runtime rather than receiving as static prompt text. A builder agent constructs an initial ontology via workload-guided probing over training queries and raw data sources, committing only candidates verified by executable probe results (evidence-grounded commitment). An evolution agent then runs a four-step self-evolution loop—diagnose (trajectory attribution into recurrent failure signatures), attribute (assign signature to Content/Tool/Schema level), patch (localized, typed candidate edit), and gate (backbone-conditional paired evaluation against a held-out validation set, accepting only candidates that beat the parent ontology by margin τ)—to iteratively refine the ontology per LLM backbone.

Key results:

• On DDR-Bench (10-K scenario, 6 backbones under ReAct), EvoOntology raises Trajectory-Wise accuracy by an average of +17.8 points over the no-ontology baseline, ranging from +4.8 (Qwen3.5-Flash) to +26.7 (GPT-5.5); the static semantic-layer baseline (Baseline + SL) even drops −15.0 points on Claude-Sonnet-5.
• Against a memory-based persistence baseline (ReAct + Memory), EvoOntology reaches 89.5% Traj-Wise vs. 75.8% for memory and 69.5% for plain ReAct baseline (average across four backbones).
• On InsightBench, EvoOntology improves Insight/Summary scores on all six backbones with a mean gain of 1.9 points, largest on DeepSeek-V4-Flash (+6.1).
• On BIRD (Oracle Knowledge setting), EvoOntology improves both EX and VES for every backbone, with average gains of 7.4 and 8.6 points, respectively (e.g., Claude-Opus-4.8: EX 78.3, +10.8; VES 80.5, +10.9).
• Decomposing the gain: the builder-only "Initial" ontology already improves over baseline (e.g., +12.3 pts mean Traj-Wise on DDR-Bench), and self-evolution adds a further +7.7 pts (DDR-Bench), +0.2 pts (InsightBench Insight), +3.7 pts (BIRD EX).
• Ablations: removing the gating step causes the largest drop (−11.2 Traj-Wise); removing attribution (−6.3); removing diagnose (−4.8); replacing typed patches with free-form rewrites (−1.7). Single-level-only evolution underperforms the full three-level (Content/Tool/Schema) loop (+20.0): Tool-only +13.2, Content-only +8.7, Schema-only +3.6.
• Masking ontology object families: removing Mappings causes the largest drop (−13.4 Traj-Wise), removing Evidence (−8.7), Constraints (−3.5), Relations (−2.1).
• Cross-backbone analysis: pairwise Jaccard overlap of accepted Term identifiers across backbones never exceeds 0.62, and applying one backbone's evolved ontology store to another backbone drops performance by at least 6.6 points relative to using its own store (up to −10.9 for GPT-5.5).

Why it matters / caveats: By exposing ontology content through queryable MCP tools rather than injecting it wholesale into prompts, EvoOntology scales to large heterogeneous data sources and adapts per-backbone, consistently outperforming both raw-querying agents and static semantic-layer baselines across three benchmarks and six LLM backbones; however, the evolved ontologies are backbone-specific and transfer poorly across different LLM backbones, implying evolution must be repeated for each new backbone.

Problem: Computer-use agents split into GUI-operating agents and code/terminal agents that are each blind to what the other does, so there is no environment to measure or train "hybrid" agents that autonomously interleave interface exploration, implementation, and execution/visual verification of their own artifacts.

Method: The paper introduces RecreationWorld, a framework centered on "application recreation": given a running reference application, an agent must discover its behavior (via GUI exploration and source/DOM inspection where permitted) and build a faithful, independently runnable implementation with no prescribed workflow, across five platforms (Ubuntu, macOS, Windows, Android, Web) using a unified harness exposing platform-native GUI control (accessibility APIs like AT-SPI, AXUIElement, UI Automation, UiAutomator) plus coding/build tools. Hidden test suites are constructed via reference-grounded generation—an orchestrator plus specialized generators probe the reference to author programmatic (exact text/state/value assertions) and visual (VLM-judged) test cases, which are validated by replaying against the reference and reviewed by humans before being frozen. For training, Qwen3.8-Max generates long-horizon recreation trajectories on isolated VM workers, rejection-sampled by the behavioral verifiers into a 35,000-trajectory SFT mixture (7,000 per platform), used to fine-tune two initializations (Qwen3.7-Plus and Qwen-Flash-CPT, a continually-pretrained Qwen-Flash checkpoint).

Key results:

• RecreationBench: 250 held-out tasks (50 each on Ubuntu, macOS, Windows, Android, Web); trajectories have a median of 282.5 top-level tool calls and 9.08 GUI–code-edit transitions per 100 calls.
• Among 10 frontier models evaluated, GPT-6 Astra scores highest overall at 58.06% (Prog 58.19%, VLM 57.92%), followed by Claude Opus 5 (44.16%) and GPT-5.6 Sol (42.06%); Qwen3.7-Plus scores 24.38%, Grok 4.6 scores 9.15%.
• GPT-6 Astra is the only model with substantial full-suite passes: 17.6% of apps reach ≥90% Prog coverage and only 2.8% reach 100% Prog pass (vs. ≤5.5%/0.8% for any other model).
• Training on recreation trajectories transfers to 5 OOD benchmarks (ProgramBench, GameCraft-Bench, Vision2Web, OSWorld 2.0, WeaveBench), with both fine-tuned model sweeps finishing above their first checkpoints, with gains up to 17.9 percentage points.
• Coverage audit of the frozen test suites: on average 77% (Table 2: ~77.2%, i.e., 1-22.8%) of cases leave the starting UI surface, 24.1% traverse 2+ surfaces, 94.2% check an interaction outcome (not mere presence), and 40.7% require an exact expected result.
• A persistent programmable-SDK interaction runtime (vs. direct MCP calls), tested on 50 Windows apps with Claude Opus 4.8, achieved similar task quality (Prog 35.05%→35.60%, VLM 31.00%→32.29%) while reducing computer-use calls by 39.9%, agent turns by 35.8%, input tokens by 40.7%, tool-result text by 65.5%, wall-clock time by 26.1% (4.12→3.04 hrs/task), and model cost by 54.1% ($90.50→$41.58/task), though output tokens increased 15.7%.
• Final-loop closure (final edit → relaunch → re-observation) stays below 50% for all models: Qwen3.8-Max-0902 47.5%, GLM-5.3 38.0%, GPT-6 Astra 29.1%, Claude Opus 5 23.6%.

Why it matters / caveats: The results show current frontier agents remain far from faithfully recreating reference application behavior (near-zero full programmatic pass rates), reproduce static interface structure more reliably than dynamic interactions and computed outputs, and generate applications that are substantially smaller and more monolithic than the references, while training on verified recreation trajectories offers only initial, non-causal evidence of transfer to broader coding and computer-use capabilities (comparisons across models/behaviors are descriptive, not controlled for causality).

Problem: Existing Mixture-of-Experts designs cannot independently control expert participation, execution cost, and parameter materialization: sparse routing keeps compute and memory low but limits how many experts contribute to each token, dense output-mixing restores full participation at the cost of executing every expert, and parameter-merging keeps execution to one expert but makes materialization grow with the number of routing decisions.

Method: IntBMoE is a block-conditioned MoE that replaces the Transformer FFN sublayer with a module built from a small learned codebook of K embeddings, one per candidate block; a shared hypernetwork maps each codebook embedding to value/gate composition coefficients that merge each internal layer's shared pool of E expert bases into K reusable, token-independent multi-layer blocks (via a linear-LayerNorm-ReLU trunk with two linear output heads and a variance-preserving 1/√E scaling, using unnormalized, unconstrained coefficients rather than softmax/sigmoid weights). A token-level router then performs Top-k selection over these K precomputed blocks per token, with block-conditioned feature filtering (a sigmoid gate over token+codebook-embedding concatenation) applied before each block. Dual-Path Residual Gating (DPRG) couples the independently composed value and gate paths per layer through residual multiplicative modulation (RMSNorm + SiLU + learnable residual scale λ), and outputs are aggregated by routing probability and added to an always-active shared SwiGLU expert; because block composition is input-independent, all K blocks can be precomputed and cached at inference to remove the O(KED) synthesis cost from the request path.

Key results:

• On ImageNet-1K (DeiT-Tiny-style 8-layer backbone, 3 seeds): IntBMoE reaches 73.76% Top-1 / 91.48% Top-5 accuracy, beating the dense backbone by 7.36 / 3.79 percentage points and the strongest MoE baseline (SMEAR) by 1.98 Top-1 / 1.15 Top-5 points, at ~24.3M total params, 23.111M activated params, and 4.063 GFLOPs (3.457 GFLOPs cached).
• Ablations: removing the gate path causes the largest Top-1 drop (0.7376→0.6804); collapsing to a 1-layer parameter-matched block drops it to 0.6878; fixed λ gives 0.7244; softmax-normalized coefficients give 0.7263.
• Hyperparameter sweeps: expanding K from 8→32 adds only 0.07 Top-1 points; expanding E from 16→64 adds only 0.15 points; k=2 is used as a favorable compute/accuracy tradeoff over k=1; L=2 is optimal block depth.
• Expert-ablation analysis (removing individual expert bases from one layer at a time, 64 settings across layers 0/2/4/6): mean Top-1 drops of 1.60, 0.49, 1.17, and 0.78 points respectively; Layer 0 shows highly uneven contributions (up to 9.15-point drop for one basis), later layers more balanced (0.26–1.95-point range); smallest observed drop is 0.26 points, indicating every expert basis contributes.
• Block-recipe diversity increases with depth: mean pairwise cosine similarity between block composition recipes falls from 0.796 (layer 0) to 0.079/0.019/0.010 (layers 2/4/6) for the value path, and 0.726 to 0.126/0.083/0.043 for the gate path.
• Caching effect: without caching, peak inference memory grows from 54.57 MB to 627.83 MB and cost from 3.495 to 8.305 GFLOPs as E goes from 1 to 128; with caching both stay constant at 104.33 MB and 3.457 GFLOPs.
• Generalization: on MiniPile (6GB Pile subset, 18-layer Llama-style Transformer), IntBMoE gets test loss 2.6802 / PPL 14.5878, a 2.9% PPL reduction vs. the strongest baseline (µMoE CP) and 12.4% vs. dense. On IntTravel (162.8M users, 7.3M POIs, 4.13B interactions), IntBMoE achieves the best HR@1 (0.6852), HR@5 (0.8692), and NDCG@5 (0.7850).
• Production deployment in AMap's generative POI recommendation system: one-week online A/B test at ~5,000 QPS on Alibaba T-Head PPUs, cached IntBMoE achieved 19 ms average / 38 ms P99 latency (within a 60 ms budget) and a 2.4% relative UVCTR improvement; subsequently fully deployed to production traffic serving hundreds of millions of users.

Why it matters / caveats: IntBMoE demonstrates that full expert-pool participation, sparse per-token execution, and bounded (codebook-sized) parameter materialization can be achieved simultaneously rather than traded off, and that this decoupling holds up not just on vision benchmarks but also in language modeling, sequential recommendation, and a real latency-critical production recommender system at scale. A caveat is that uncached IntBMoE's inference FLOPs/memory still scale with the number of blocks and experts, so the practical benefits (especially the flat cost curve as expert-pool size E grows) depend on precomputing and caching the input-independent composed blocks ahead of request time.

Problem: There is little real-world recorded data and no reliable evaluation method for "OmniVChat" — native audio-visual dialogue where an omni model must directly understand a user's simultaneous audio and video input (with the query embedded in it) and reply, without a separate text question, external captioning, or ASR.

Method: The paper introduces OmniVChat-Studio, a multi-agent data engine (four agents: Director, Renderer, Reviewer, deterministic Validator) that synthesizes single- and multi-turn audio-visual dialogue clips with reference replies and tiered rubrics from a text corpus, using per-subcategory configurable "Flexible" modules and fixed pipeline modules with review/repair loops. From this, OmniVChat-Bench is built, an LLM-judged (qwen3.7-max) tiered-rubric benchmark covering five ability categories (DSLP, MEA, MSA, AH, ER) across 17 subcategories and 22 scenario domains. OmniVChat-RL then fine-tunes Qwen3-Omni-30B-A3B-Instruct (Thinker module) with Group Sequence Policy Optimization (GSPO, GRPO-style group-baseline advantage, LoRA rank-64 adapters) using a composite reward combining rubric correctness (Eq. 1), a training-only format term, a within-group-normalized reply-efficiency term, and an LLM-graded 7-criterion style term.

Key results:

• OmniVChat-Bench: 2,800 synthesized instances (2,550 single-turn, 250 multi-turn), 1,766 English (63.1%) / 1,034 Chinese (36.9%) dialogues, spanning 5 ability categories, 17 subcategories, 22 scenario domains.
• Training data: OmniVChat-Bench-Train has 5,600 training dialogues + 560 dev dialogues (synthetic); OmniVChat-Bench-Human has 360 human-recorded single-turn dialogues (Chinese) for transfer testing.
• Training: GSPO with LoRA rank-64, 1,000 iterations, 32 inputs/iteration, 4 sampled replies per input, checkpoint every 20 steps; reward weights λ_fmt=0.5, λ_eff=0.1, λ_sty=0.5 (correctness weight 1), total reward range [0, 2.1].
• OmniVChat-RL raises OmniVChat-Bench Subcategory Mean from 0.465 to 0.652 (best checkpoint, step 940); dev set Mean rises from 0.507 to 0.707.
• OmniVChat-Bench-Human (recorded, real-world transfer) rises from 0.402 to 0.632, closely tracking the Chinese-only synthetic subset (0.437 → 0.634).
• Reply Efficiency (RE, rubric credit per 1,000 words) rises from 5.75 to 18.38; Style score rises from 0.710 to 0.992; mean reply length falls from 91.5 to 36.6 words (peaking near 127 words at step 50).
• Ablations: removing the efficiency term raises Mean to 0.697 and Human to 0.691 but reply length grows to ~99 words and RE falls to 7.12; removing the style term gives Mean 0.661, Human 0.632, Style drops to 0.788.
• Among 12 released systems compared (Table 1), Gemini-3.5-Flash leads Mean (0.667), Gemini-3.7-Flash leads Human (0.575) and RE (16.96), Gemini-3.1-Pro leads Style (0.871); OmniVChat-RL (0.652 Mean, 0.632 Human, 18.38 RE, 0.992 Style) surpasses all open-source baselines including base Qwen3-Omni-Instruct (0.465 Mean, 0.402 Human, 5.75 RE, 0.710 Style).
• Multi-turn vs. single-turn gap: Gemini-3.7-Flash shows mean multi-minus-single gap of −0.114 versus −0.026 for OmniVChat-RL.

Why it matters / caveats: The results show that fully synthetic multi-agent-generated audio-visual dialogue data can train models with RL rewards that transfer to real human-recorded dialogues, validating synthetic data as a substitute for scarce real device recordings; however, the recorded human benchmark covers only single-turn Chinese dialogues (no live interruption/multi-turn testing), and the authors note that matched single- vs multi-turn gains only indirectly suggest aligned data distributions since the synthetic and recorded sets are independently sampled, not paired.

Problem: Existing text-to-image generation and editing methods lack a unified, prompt-native way to control an object's exact color via arbitrary 24-bit hex values, instead relying on dedicated color modules or costly inference-time procedures that treat generation, editing, and colorization as separate problems.

Method: Paint-Anything finetunes a rectified-flow/flow-matching text-to-image transformer (FLUX.2-klein-base-4B and Z-Image Base) to accept hex color codes wrapped in explicit <color>#HEX</color> tags directly in the text prompt, jointly training generation and editing under one flow-matching objective (Lt2i + Ledit + Lrgb). Training data (Paint-500K) is built via a pipeline of VLM object grounding, SAM3 segmentation, and MeanShift clustering in CIELAB space to extract object-level dominant hex colors from real images, plus edit-pair synthesis using a pretrained editing model. Because real-image labels are only approximate due to shadows, the recipe adds "pure-color anchors" — solid-color images paired with their exact hex value — trained only at high-noise timesteps (t ∈ [tgate, 1], tgate=0.8) so clean hex-to-RGB grounding is learned without corrupting low-noise natural-image training.

Key results:

• Paint-500K: 400K T2I samples (100K single-object + 300K multi-object) and 100K editing samples.
• On FLUX.2-4B, ACBench-T2I Overall improves from 37.02 to 68.58 (+85.3% relative) and ACBench-Edit from 58.90 to 75.57 (+28.3% relative).
• The finetuned 8B model exceeds FLUX.2-dev (56B total params) by 16.88 points on ACBench-T2I and 6.70 points on ACBench-Edit.
• Exceeds strongest specialized baselines: +22.04 points over ColorWave on ACBench-T2I, +15.19 points over ColorBind/Edit on ACBench-Edit.
• CompColor (hex-prompt average) rises from 0.38 (base model) to 0.79, exceeding the base model's named-color average (0.72→0.79 after finetuning).
• Ablations: full finetuning beats rank-256 LoRA (68.58 vs. 48.45 on T2I, 75.57 vs. 58.71 on Edit, 0.79 vs. 0.54 on CompColor); color-token wrapping raises bare-hex scores from 44.06/65.81 to 57.16/73.89; high-noise gating adds +4.75 (T2I) and +5.18 (Edit) points over ungated anchors.
• On GenColorBench NCU, mean score improves from 34.00 (base) to 57.89 (+23.89 points), exceeding published FLUX+NumColor (51.90) by 5.99 points.

Why it matters / caveats: The results show that hex-color grounding can be learned purely through object-level supervision and timestep-gated pure-color anchors, letting an 8B model outperform a 56B model and dedicated color-control baselines with a single unified prompt interface for both generation and editing. The authors note their training data lacks palette-specific supervision, leaving multi-color palette control as future work.

Problem: Existing benchmarks and training datasets for reference-to-video (R2V) generation cover only a narrow range of reference types (mostly content) and evaluate models with holistic consistency scores that fail to check whether individual reference factors are actually preserved, disentangled, and correctly routed to their targets, while training data for the broader "omni R2V" setting is scarce and costly to build.

Method: The paper introduces OmniVBench, a benchmark organized into 7 task families and 18 fine-grained sub-tasks (content, motion, style, structure, narrative, multi-content, and cross-aspect reference), each evaluated via a factor-grounded checklist protocol that decomposes cases into case-specific atomic questions scored by a VLM (Gemini-3.1-Pro) across three dimensions: Reference Fidelity, Instruction Realization (disentanglement/routing vs. target compliance), and Video Quality (via DOVER++, Aesthetic Predictor V2.5, UnifiedReward 2.0). It also constructs the Omni-R2V Dataset using task-specific pipelines built on cross-pair matching (e.g., cross-video identity matching, cross-segment style matching) and inverse construction (e.g., Wan-Animate for motion transfer, Wan2.2-VACE-Fun-A14B for greybox structure videos, Qwen-Image-Edit for storyboard sketches, GPT Image 2.0 for isolated object/scene extraction), with instructions generated by Gemini-3.1-Pro captioning references/targets and DeepSeek-V4-Pro converting captions into task-specific training instructions.

Key results:

• OmniVBench: 813 evaluation cases across 18 sub-tasks; 12,172 factor-grounded checklist items.
• Omni-R2V Dataset: 339,570 (~340K) processed training samples, spanning 7 task families (Content ~18,615, Motion ~57,400, Style ~8,842, Structure ~38,837, Narrative ~167,881, Multi-content ~19,497, Cross-aspect ~28,498), resolutions 480p–2160p+, clips up to 20 seconds.
• Overall model scores (Table 3): MiniMax H3 (open-source) scored highest overall at 72.41, followed by Seedance 2.5 (72.68) and Seedance 2.0 (70.91) among closed-source models; UniVideo scored lowest overall (49.69).
• Automatic evaluation correlated with human judgment: Pearson/Spearman of 0.81/0.77 (Reference Fidelity), 0.78/0.74 (Instruction Realization), 0.86/0.82 (Video Quality), based on 100 sampled cases and 965 human-evaluated model outputs.
• Ablation: factor-grounded checklist evaluation achieved higher human correlation (RF Spearman 0.77, IR Spearman 0.74) than holistic evaluation (0.67 and 0.69 respectively).
• No model performed consistently well across all task families; models scored much higher on content reference than on motion, style, structure, narrative, or multi-reference tasks, and several models showed high target compliance (IRTC) but much lower disentanglement/routing (IRDR) scores, especially on multi-content and cross-aspect tasks.

Why it matters / caveats: The factor-grounded, checklist-based evaluation exposes capability gaps (e.g., disentanglement vs. compliance) that holistic reference-similarity metrics miss, and the 340K-sample Omni-R2V dataset provides a reusable, task-diverse, processed training resource for the community, addressing data scarcity for compositional/multi-reference R2V generation. The benchmark and dataset rely on an in-house professional video corpus with usage rights and on VLM-based automated scoring (validated against only 100 sampled cases), so evaluation quality depends on the underlying VLM judge and generalization beyond the sampled validation set is not fully established.

Problem: Existing LLM agent skill-optimization methods represent skills as unstructured natural-language text, which lacks explicit workflow-level guidance and creates a vast, redundant search space that makes optimization ineffective.

Method: GraphSkillEvo represents each skill as a graph-structured artifact s = ⟨hs, gs⟩, with global guidance hs plus a directed graph gs = (Vs, Es) whose nodes are reusable execution steps (with self-contained instructions/rules) and whose edges are context-dependent transitions defined by named workflows (applicability condition + ordered node path). Optimization is a population-based evolutionary computation framework (population size N=4, T=5 generations) that at each generation executes each population member on a sampled batch (B=15) of training instances, retains up to K=5 failed trajectories per skill, and applies one of four operators selected via round-robin — global-guidance mutation, graph-structure mutation, global-guidance crossover, and graph-structure crossover — with rank-based parent selection (p ∝ 1/(r+N)); new candidates are scored on the full validation set and the top-N skills (from parents plus offspring) survive to the next generation. It is compared against the baseline SkillOpt, which iteratively patches unstructured skills via LLM self-reflection and validation gating, using GPT-5.4 and GPT-5.4-nano across five benchmarks (SearchQA, SpreadsheetBench, DocVQA, LiveMathematicianBench, ALFWorld) and two harness settings (no harness, Codex harness).

Key results:

• GraphSkillEvo achieves the best result in 13 of 14 model-harness-benchmark settings.
• Average success rate improvement over no-skill execution: +15.37% (GPT-5.4, no harness), +21.86% (GPT-5.4-nano, no harness), +10.31% (GPT-5.4, Codex harness).
• Average improvement over SkillOpt: +1.76% (GPT-5.4, no harness), +4.01% (GPT-5.4-nano, no harness), +1.33% (GPT-5.4, Codex harness).
• Largest per-benchmark gains over SkillOpt: +10.60% on SpreadsheetBench (60.71 vs 50.11, GPT-5.4-nano) and +3.73% on ALFWorld; one regression case: LiveMath with GPT-5.4-nano trails SkillOpt by 0.80% (28.76 vs 29.56).
• Token efficiency: SkillOpt uses 1.31x as many tokens as GraphSkillEvo with GPT-5.4 (81.08M vs 61.94M total) and 1.36x with GPT-5.4-nano (103.54M vs 75.94M total).
• Ablations (GPT-5.4-nano, average of SearchQA/Spreadsheet/DocVQA): full method 71.52; removing graph structure drops to 64.08 (-7.44); removing crossover drops to 66.59 (-4.93); removing mutation drops to 54.50 (-17.02, the largest degradation).
• Representation ablation: converting optimized graph-structured skills to unstructured text (same content) reduces success rate by 4.52, 2.50, 4.19, 1.35, and 0.75 points on SearchQA, Spreadsheet, DocVQA, LiveMath, and ALFWorld respectively.
• Cross-model transfer: a GraphSkillEvo skill optimized on GPT-5.4-nano and applied to GPT-5.4 reaches 71.78 on SpreadsheetBench, exceeding both its directly-optimized GPT-5.4 counterpart (69.40) and the transferred SkillOpt skill (53.21).

Why it matters / caveats: The graph structure gives smaller/less capable models (GPT-5.4-nano) the largest gains, and skills remain effective and even improve when transferred across LLMs, suggesting reusable procedural knowledge that outlives a specific model version; the approach still relies on LLM-driven mutation/crossover operators and was evaluated on only five benchmarks with two LLMs, and the authors note future work is needed to combine it with parametric optimization and richer graph composition mechanisms.

Problem: Vision-language agents that ground UI instructions, navigate mobile/desktop/web interfaces, and invoke external tools are currently built as separate per-domain specialists, which is costly to serve, hard to scale, and especially impractical for compact on-device models.

Method: MintAct is a family of vision-language agents (2B, 4B, 8B scales, initialized from Qwen3-VL-Instruct) that unifies UI grounding, multi-step navigation (mobile via AndroidWorld, desktop via OSWorld, web via Weblica), and visual tool use (via MM-ToolSandBox) with a single set of weights, using raw-screenshot pixel-coordinate grounding and domain-specific system prompts to steer per-domain action sets. Training follows a multi-stage recipe: high-resolution single-step SFT for grounding, low-resolution multi-step SFT over cross-domain trajectories (balanced 25%/25%/25%/25%), per-domain RL specialists distilled back into one model via RFT with rejection sampling, and a final joint agentic RL stage across mobile and desktop. RL is run on a custom asynchronous framework (built on verl and rLLM, using GRPO-style group-relative advantages, DAPO-style dynamic group filtering, a dual-clipped surrogate, and truncated importance-sampling weights) that controls cross-domain training mixture via per-domain quotas and quota-normalized backpressure while sustaining hundreds of concurrent heterogeneous environment instances.

Key results:

• MintAct-8B: 48.9 on OSWorld-Verified, 39.1 on Online-Mind2Web, 67.0 on AndroidWorld, 74.7 on Weblica, 56.6 on UI-Vision, 64.5 on OSWorld-G, 24.5 on MM-ToolSandBox — best or near-best among size-matched public models (e.g., beats EvoCUA-8B's 46.1 on OSWorld-Verified, WEBLICA-8B's 70.6 on Weblica).
• Over its Qwen3-VL-8B initialization, MintAct-8B improves: AndroidWorld 47.6→67.0, OSWorld-Verified 33.9→48.9, Weblica 55.5→74.7, MM-ToolSandBox 3.1→24.5.
• SFT data scale: ~42.7k mobile, ~23.5k desktop, ~51.7k web, ~59.8k visual-tool-use trajectories for multi-step SFT; RFT distillation data: ~37.8k (mobile), ~21k (desktop), ~7k (web), ~24k (visual tool use).
• RL training tasks: ~3k OSWorld tasks, ~3k AndroidWorld tasks, 10k Weblica-Synth tasks, ~800 MM-ToolSandBox scenarios.
• Ablations: joint SFT model matches/exceeds single-domain SFT specialists (e.g., MintAct-SFT-8B AndroidWorld 63.8 vs. mobile specialist 62.3); RFT lifts navigation/tool-use (e.g., AndroidWorld 44.8→55.7 at 2B); joint RL improves OSWorld-Verified 43.1→48.9 (8B) and transfers to web (Weblica 72.8→74.7) despite no web data in that stage; synthetic environments alone raise AndroidWorld 47.6→60.3 and OSWorld-Verified 33.9→38.6 with zero real interaction data.
• Environment infrastructure sustains 200+ concurrent desktop instances and 100+ concurrent mobile instances for online RL rollouts.

Why it matters / caveats: The results show a single compact (2B-8B) model family can match or beat per-domain specialist agents across grounding, navigation, and tool use, easing deployment (especially on-device) without sacrificing quality. Stated limitations: joint RL is currently only run on mobile+desktop (not web/tool-use) due to resource cost, context grows unbounded across long trajectories without pruning, tool use and UI navigation remain separately handled rather than seamlessly integrated, and the dynamic tool-registry function-calling formulation relies on coarse trajectory-segment credit assignment rather than a principled solution.

Problem: As LLM-generated peer reviews enter public data and future training corpora, training successor review models on this recursive mixture of official and AI-generated reviews risks narrowing ("collapsing") the diversity of scientific judgments those models produce.

Method: Starting from Llama 3.1 8B (Meta-Llama-3.1-8B-Instruct), the authors first fine-tune a reviewer model M1 via LoRA-based supervised fine-tuning (rank 64, LlamaFactory) on official ICLR reviews from 2018–2023, then use M1 to generate synthetic reviews for ICLR 2024 papers and train four successor models M2^p (p = 0%, 33%, 66%, 100% synthetic reviews per paper, i.e. 0/1/2/3 of 3 reviews synthetic) under otherwise identical training settings. To mitigate observed collapse, they build TrustReviewer, which (1) trains a single-stage core reviewer on a curated corpus (Dcurated) built from ICLR 2018–2025 official reviews filtered for malformed, duplicated, short, repetitive, and follow-up reviews, and (2) applies test-time "paired activation steering" — a Representation-Engineering/Contrastive-Activation-Addition-style method that computes a steering vector from last-token hidden-state differences between official and model-generated reviews of the same papers (K=5,000 calibration pairs) and adds it to the residual stream at a selected decoder layer (final layer, α=0.15) during generation, without further training.

Key results:

• Rating diversity compresses with synthetic exposure: standard deviation drops from 1.63 (M2^0%) to 1.44 at 33% synthetic exposure and stays lower through 66%/100%; entropy falls similarly (official reviews: SD 1.73, entropy 2.38; M2^0%: SD 1.63, entropy 2.31).
• Mean ratings shift non-monotonically: 5.30 (0%) → 5.85 (33%) → 5.70 (100%), indicating homogenization rather than systematic leniency/harshness shift.
• Same-paper semantic diversity decreases monotonically: mean pairwise semantic distance falls from ~0.159 (0%) to 0.153 (33%), 0.147 (66%), 0.142 (100%) — an ~11% reduction from 0% to 100% synthetic exposure.
• Corpus-level semantic spread contracts from ~0.609 (0%) to 0.584/0.580/0.579 (33/66/100%) — an ~5% reduction.
• Curated training corpus for TrustReviewer: 112,743 paper–review examples, ~1.9 billion tokens (ICLR 2018–2025), with 2,000 held-out evaluation papers.
• TrustReviewer achieves the best recommendation agreement: 75.40% exact match and MAD 1.079, vs. OpenReviewer (73.10%, MAD 1.113), Qwen3.6-35B-A3B (61.85%, MAD 1.335), and base Llama-3.1-8B-Instruct (33.93%, MAD 2.679).
• TrustReviewer's rating entropy is 2.18, higher than Llama (1.53), Qwen (1.94), and OpenReviewer (2.10), narrowing the gap to official reviews (2.38).
• Activation steering alone improves TrustReviewer's exact match from 73.85% to 75.40% (+1.55 points) and entropy from 2.13 to 2.18, with MAD essentially unchanged.

Why it matters / caveats: The study demonstrates a concrete, measurable risk ("scientific-judgment collapse") from recursively training AI reviewers on AI-generated reviews, and shows that curated training data plus lightweight, training-free activation steering can partially counteract it while improving recommendation alignment. Limitations acknowledged by the authors: the experiment covers only one recursive training step, one base-model family, and one domain (ICLR/AI-ML reviews); diversity metrics (embedding-based semantic distance, entropy) are proxies that do not establish substantive correctness or quality of critiques; and "official" reviews used as reference/ground truth may themselves contain unverified AI assistance.

Problem: Deploying audio-language models for telecom anti-fraud detection requires predictions that comply with a fixed, hierarchical label ontology (service-scenario → fraud detection → fraud-type), but existing fine-tuning and prompt-engineering adaptation methods bake this task knowledge into model weights or hand-maintained prompts, making them hard to update as fraud patterns and labeling policies change.

Method: FRAUDSkill keeps a frozen audio-language model (Qwen2-Audio-7B-Instruct) unchanged and instead optimizes an external, editable "skill program" P = (root instruction r, skill library K, route policy π) via DSPy/APO-style program search: a critic model diagnoses trajectory-level errors on held-out development data, an editor proposes revised programs, and a beam search with validation selection (on a disjoint Dprog split) retains the best/top-L programs (FRAUDSkill-Text is the single best program). At deployment, the complete FRAUDSkill system adds structured inference on top: deterministic label projection/aliasing onto the official ontology, route normalization enforcing the scene→fraud→type conditional protocol (marking invalid/not-applicable outputs), complementary multi-path inference across the L retained programs, and a validation-fitted, class-balanced reliability selector (chosen to maximize Macro-F1 on a calibration split Dcal) that produces the final closed-set decision.

Key results:

• On TeleAntiFraud (10,711 train / 2,677 test audio samples, 1,453 with fraud-type labels), FRAUDSkill achieves 73.50% Macro-F1, +31.96 percentage points over the shared frozen-model baseline (41.54%), with W-F1 79.40%, Accuracy 78.72%, Joint Accuracy 58.87%, and Invalid Rate reduced to 1.94% (from 36.04%).
• Baseline comparisons (all on the same frozen model): shared baseline 41.54% Macro-F1 / 36.04% invalid rate; SkillOpt 37.67% / 29.00%; EvoSkill 39.07% / 34.19%; FRAUDSkill-Text (text-only program) 42.42% Macro-F1 (mean over seeds 42/43/44, std 1.39) / 34.48% invalid rate.
• Reference (weight-updating) methods: SFT 66.06% Macro-F1; SFT+Memory 75.51% Macro-F1 — FRAUDSkill (frozen weights) lands above SFT and just below SFT+Memory.
• Ablation (cumulative, starting from best text program at 43.66%): closed-set projection → 54.47%; + route normalization → 66.21%; + complementary multi-path inference → 70.31%; + reliability weighting → 70.84%; + class-balanced selection → 73.50% (final), a total structured-inference gain of 29.84 points over the best textual program.
• Error analysis on FRAUDSkill-Text: scene-route error rate 74.2% (91.1% of these are missing/off-ontology outputs); fraud-route error rate 32.9% (60.0% false-normal); type-route error rate 83.1% on annotated examples.

Why it matters / caveats: FRAUDSkill shows that for closed-set, multi-stage audio fraud classification, externalizing and structurally optimizing skills/decision rules (rather than fine-tuning the underlying model) can approach or exceed weight-updating baselines while remaining inspectable and adaptable to evolving fraud policies. Caveats: gains depend heavily on the structured-inference layer (projection, normalization, multi-path selection) rather than textual program search alone, which the authors find "unstable" (FRAUDSkill-Text gives only marginal improvement with variation larger than the mean gain); results are protocol-bound to this audio-level TeleAntiFraud evaluation and are not directly comparable to the dataset's original interaction-level protocol, so the reported comparisons do not imply task-independent rankings.

Problem: Audio-based telecom-fraud benchmarks cannot absorb newly observed scam patterns without overwriting prior test sets, and they typically pit fraud calls against topically unrelated negatives rather than realistic, near-domain lawful calls, which lets models exploit shortcuts instead of learning to distinguish fraud from legitimate service conversations.

Method: The paper introduces the Mixed-Tree Anti-Fraud Generation Pipeline, which converts online fraud-case abstracts into structured "scenario profiles" (receiver background, caller identity/persuasion strategy, risk nodes), expands each profile into a mixed dialogue tree (formalized as Tx = (V, E, r, ϕ, σ, τ) with depth D=4, branching factor b=3, ≤81 leaves before pruning) whose fraud and non-fraud sibling paths share context and diverge only at label-bearing actions, realizes each path via a six-agent collaborative system (caller/receiver role-play agents plus branch, termination, and delivery-state functional agents), and renders validated dialogues into role-matched speech via TTS with signal-level validation. Snapshots are frozen monthly (immutable once released, e.g., June/V1 and July/V2) with full manifests (audio, labels, rationales, prompts, model responses, provenance) to support refreshable-yet-reproducible evaluation, and models are tested via direct-audio and ASR (Whisper-medium)+LLM zero-shot pipelines.

Key results:

• Each frozen snapshot contains 900 Chinese calls (600 fraud, 300 near-domain non-fraud); two snapshots released (June/V1, July/V2).
• Text classifiers (LR, SVM, RoBERTa) achieve Macro-F1 = 1.000 against unrelated or ordinary in-domain negatives, but drop to 0.650–0.680 against near-domain sibling negatives (Table 4).
• Cross-benchmark TF–IDF+SVM comparison: TeleAntiFraud-28k-ASR reaches Macro-F1 0.9950, vs. 0.9286 (TAF 2.0 dialogue) and 0.7998 (TAF 2.0 ASR-test), with predicted-fraud ratio rising to 0.7878 on the harder ASR-test setting.
• Full 900-sample model evaluations: fraud F1/accuracy/fraud recall vary widely across model families and snapshots (e.g., Qwen3-Omni 0.800/0.667/1.000 on both snapshots; Claude-Sonnet4/ASR 0.000/0.333/0.330 on June/V1 but 0.800/0.667/1.000 on July/V2; GLM-5.2/ASR 0.012/0.337/0.335 on June/V1 vs. 0.800/0.667/1.000 on July/V2), indicating strong snapshot sensitivity.
• Before prompt-language averaging, 11 of 27 June/V1 configurations and 15 of 27 July/V2 configurations show an all-FRAUD-like collapse signature (fraud recall ≈1.0, accuracy ≈2:1 prior, fraud F1 ≈0.80).
• Class-prior resampling: an all-FRAUD baseline's fraud F1 rises from 0.500 to 0.800 as fraud prevalence increases from 1:2 to 2:1, while Balanced Accuracy stays at 0.500 and non-fraud recall stays at 0; MiniMax-CN remains fraud-biased even at 1:1 ratio, predicting FRAUD for 0.830 of calls and recalling only 0.233 of non-fraud calls.
• Construction audits: BGE-small-zh embeddings over 813 dialogues give mean within-tree distance 0.0188 vs. cross-tree distance 0.3351 (17.8× ratio); leave-one-tree-out F1 drops from 0.883 (in-domain) to 0.605 (held-out trees).
• Label audit: 10 experts reviewed 1000 item-level judgments with corrected-gold agreement averaging 0.792 (range 0.700–0.880), yielding 494 FRAUD / 506 NONFRAUD aggregate judgments, expert confidence averaging 4.431/5, and 744/1000 judgments marked evidence-sufficient.
• 80-dialogue audio pilot annotation scores (1–5 scale): dialogue realism 4.60±0.70, strategy coherence 4.41±0.59, victim reaction plausibility 4.35±0.53, audio naturalness 4.13±0.77.
• Speech rendering pool: 35 authorized reference voices (29 male, 6 female); removing emotion tokens from 15 paired dialogues changed aggregate F1 from 0.920 to 0.960 (max per-model difference 4.6 points).

Why it matters / caveats: The benchmark demonstrates that near-domain sibling construction and collapse-aware reporting (Macro-F1, Balanced Accuracy, class-conditional recall, prediction distributions) are necessary to avoid overestimating audio-based fraud detectors, which otherwise exploit topic-level or class-prior shortcuts; limitations include reliance on synthetic (not real) calls, only two monthly snapshots (insufficient for long-term temporal claims), a single-annotator pilot for audio quality, and unaddressed demographic representativeness in the voice pool.

Problem: Existing token-indexed conditional-memory mechanisms for LLMs (e.g., Per-Layer Embedding, Value Embedding, STEM, Engram) retrieve memory via a deterministic function of the surface token or n-gram, forcing polysemous tokens (e.g., "python" as language vs. animal) to share a single fixed memory vector regardless of context.

Method: MoME replaces each token-indexed memory row with M learnable memory slots (tensor E_mem ∈ R^{N×M×d_value}) and adds a context-aware gate g_θ(h_t) that maps the hidden state to slot logits, selects a Top-K subset of slots per value head, and aggregates them via a sigmoid-norm (or softmax for K=1) weighted sum; the aggregated vector m̃_t is injected into the attention value stream through a per-head gated residual (v_t,i + γ_θ,t,i·m̃_t,i), so the memory branch runs in parallel with the value projection. An optional token-index grouping function f, built via offline kNN matching on a pretrained reference embedding table (grouping factor c_grp = 2 or 4), merges semantically similar tokens into shared rows and reallocates the saved capacity into additional slots. The method is evaluated via controlled pretraining on nanochat-style, Llama-3/MobileLLM-style, and Qwen3-style backbones on FineWeb-Edu and ClimbMix data, using Muon (matrix params) + AdamW (embeddings/memory tables) optimization.

Key results:

• On a 135M nanochat backbone at iso-parameter (151M memory) and iso-FLOP (3×10^18 FLOPs, ~3.3B tokens) settings, MoME (c_grp=1) reaches val bpb 0.8621 vs. 0.8636 (Bigram) and 0.8633 (VEmbedding); CORE 0.1571 vs. 0.1533/0.1522, while staying within <2% of Bigram's training throughput (1.07M vs. 1.09M tok/s).
• Scaling memory to 302M lowers val bpb further (e.g., c_grp=2 gives val bpb 0.8561, CORE 0.1664).
• On Llama/MobileLLM 125M/350M and Qwen3 0.6B (iso-token training), MoME improves CORE over STEM at all three scales using fewer memory parameters (e.g., Qwen3 0.6B: MoME-A2/8 CORE 0.2737 vs. STEM 0.2556 vs. VEmbedding 0.2530, at 470M memory params), with training wall time 1.04–1.08× the no-memory base.
• In the memory-size scaling study on nanochat-d12, MoME achieves lower val bpb than matched-memory Bigram at every tested memory budget (75.5–528.5M memory parameters) and shows lower run-to-run variance.
• Compound scaling: combining MoME with a Bigram first-stage indexer improves over Bigram alone at matched parameter budgets (e.g., 604M memory: 12V×12 gives val bpb 0.8546 vs. Bigram's best comparable rows around 0.8547–0.8588).
• Inference latency overhead is small and shrinks with backbone size: 7.82%/5.47% for Llama/MobileLLM 350M/1B, 7.90%/2.35%/1.56% for Qwen3 0.6B/4B/8B (value-stream injection), versus roughly double that for a hidden-state-injection variant (e.g., 0.509ms vs. 0.996ms added latency on Qwen3-4B).
• At 100B-token scale (nanochat-d24, ~0.78B network + ~0.6B memory params), MoME obtains lower bpb than Dense and VEmbedding on FineWeb-Edu (0.7548), enwik9 (0.8850), and Shakespeare (1.4789) out-of-domain sets, and higher CORE-22 (0.3687 vs. 0.3484 VEmbedding, 0.3441 Dense), while ClimbMix in-domain bpb (0.6504) is slightly worse than VEmbedding's (0.6463).
• Quantitative WiC-based routing analysis across 670 filtered pairs and 144 memory layer-head sites shows positive ΔJSD (same-sense vs. different-sense routing) at 117/144 sites and positive Δ overlap at 110/144 sites, supporting sense-sensitive routing.

Why it matters / caveats: MoME shows that adding a lightweight, context-conditioned gate over multi-slot memory tables can improve validation loss, CORE benchmark scores, and memory-scaling behavior over deterministic token/n-gram memory lookups with negligible added compute and only modest inference latency overhead, while producing qualitatively interpretable sense-specific routing. The authors note the main limitation is computational scale (largest experiment ~1.4B total parameters, single seed) and that the descriptive routing/activation analyses are correlational, not causal, evidence that context-aware routing improves downstream accuracy or robustness.

Problem: In on-policy distillation (OPD) for reasoning models, the observed teacher-student token-level likelihood discrepancy is contaminated by "teacher self-deviation" (TSD)—context-induced instability in the teacher's own likelihood estimates, unrelated to the actual capability gap—which standard and privileged OPD indiscriminately learn as supervision.

Method: The paper introduces Calibrated On-Policy Distillation (Cal-OPD), which probes the teacher with a positive and a negative privileged intervention (e.g., contrasting evaluative feedback, task-agnostic instructions, or answer/solution-level context) at each student token position, computes the resulting upward/downward likelihood shifts, and scales them by a relaxation factor λ to estimate a token-level "TSD region" around the teacher's original log-likelihood. The teacher-student discrepancy advantage used in the OPD loss (Agarwal et al. 2024 formulation) is then replaced by a calibrated advantage that zeroes out the signal when the student likelihood falls inside this estimated region and otherwise keeps only the residual beyond its nearest boundary; the interventions are used solely to calibrate the reference, never distilled directly into the student. Experiments use Qwen3-4B-Thinking-2507→Qwen3-1.7B and Qwen3-30B-A3B-Thinking-2507→Qwen3-4B teacher-student pairs, trained with verl on data filtered from DAPO-17K.

Key results:

• TSD analysis (Qwen3-8B teacher / Qwen3-1.7B student, 6,528 questions from DAPO-17k, ~60M response tokens): task-agnostic instructions alone induce significant TSD on 20.2%/25.8% of tokens (positive/negative variants, union 29.8%); evaluative feedback 29.1%, answer-level privilege 29.4%, solution-level privilege 39.6%.
• Retention across intervention richness: 98.2-98.6% of tokens with significant TSD under weaker interventions remain significant under solution-level privilege, vs. only 72.6-74.2% in the reverse direction.
• Directional agreement/shared-deviation-ratio under contrasting (positive vs negative) interventions: evaluative 88.7% overlap directional consistency and 74.7% shared deviation ratio; solution-level shows highest positional overlap (80.3%) but lowest shared deviation ratio (66.1%).
• TSD concentrates on surface-form tokens: highest-TSD-rate tokens (e.g., "maybe," "however," "therefore") show >89% significant-TSD rate, while math/notation tokens (digits, "frac," symbols) show <9.3%.
• Main results (Avg@16 across AMC23, AIME24/25/26, HMMT26, MATH500): Cal-OPD reaches 53.1 avg (vs. student 49.2, standard OPD 50.8, Privileged-OPD 49.3) for the 4B→1.7B setup, and 69.0 avg (vs. student 66.6, OPD 65.9, Privileged-OPD 64.0) for the 30B→4B setup — gains of +3.9/+2.4 over the student and +2.3/+3.1 over standard OPD; Cal-OPD wins on 7 of 12 benchmark-configuration pairs.
• Cal-OPD retains only about 52-65% of the original teacher-student discrepancy as optimization signal (best at λ=5); increasing λ to 80 over-filters, dropping performance 1.7 points below the λ=1 baseline.
• Standard OPD training expands average response length from ~9.8K to ~11.8K tokens; Cal-OPD ends at ~9.3 K tokens (after dipping to 8.5K), yielding roughly 1.26× faster training despite extra teacher-side computation for TSD estimation.

Why it matters / caveats: The findings show that raw teacher-student likelihood discrepancy is not uniformly useful supervision—part of it reflects teacher-side noise rather than task-relevant capability gaps—and that privileged conditioning (e.g., giving the teacher reference solutions) can worsen this problem rather than help; Cal-OPD's calibration mitigates this and also curbs unwanted response-length inflation, but it relies on manually chosen contrastive interventions and a hand-tuned relaxation factor λ, and results are demonstrated only on Qwen3-family models and mathematical reasoning benchmarks.

Problem: Automatically generating deformable objects for robot manipulation from text or a single image is difficult because such limited inputs provide no direct evidence of how the object will physically deform, contact, and respond during interaction, yet these responses determine whether the asset is usable in simulation.

Method: DeformSmith is a hierarchical agentic framework organized into four layers (L0–L3): L0 reconstructs 3D geometry and Gaussian appearance (using Qwen-Image-2512 for text-to-image, SAM 3 for segmentation, SAM 3D for mesh/Gaussian reconstruction, MoGe-2 for metric geometry, and CoACD for convex collision decomposition) and aligns mesh, collision proxy, particles, and Gaussians in a canonical frame; L1 initializes particle mass/volume and contact conditions and validates via rigid-body placement/drop/slide tests; L2 configures a homogeneous isotropic neo-Hookean material (Young's modulus, Poisson's ratio, damping) evaluated with a Material Point Method (MPM) solver (Warp MPM backend from DeformMaster) through drop, compression/lift, and stability probes; L3 performs simulated robot pick-and-place (SAPIEN simulator, RealMan RM65-6F robot URDF, GraspNet for grasp poses) to test grasping/transport/release and feed manipulation outcomes back for action/material revision. A shared physics-grounded harness (LLM agents GPT-5.6 Sol acting as Planner, Designer, and Critic, plus a rule-based Orchestrator and simulation-based Prober) governs proposal, evaluation, and revision across all layers under a "harness contract" of permitted actions, hard gates, and revision budgets.

Key results:

• On 39 test cases (30 text-driven, 9 image-based), DeformSmith achieves GPT-6 Astra ratings (0–1 scale) of 0.70 physical realism and 0.58 photorealism, each 0.24 higher than the strongest baseline (PhysGen3D: 0.46/0.34), and 0.82 semantic consistency vs. 0.80 for PhysGen3D.
• Blinded human pairwise comparisons (40 participants): win rates of 68–75% for physical plausibility, 88–96% for visual quality, and 63–76% for semantic consistency against PhysGen3D, PhysGM, and PhysX-Omni.
• Ablation (C1, hierarchical vs. flat construction): asset delivery improves from 83% to 93% and independent physics-test pass rate from 80% to 87%, at comparable simulation cost (13.7 vs. 13 simulation calls).
• Ablation (C2, harness vs. one-shot material prediction): material-target satisfaction rises from 40% to 73% and hard failure rate falls from 17% to 7%, averaging 14 construction calls per asset with the harness vs. 0 for one-shot.
• Ablation (C3, manipulation-guided refinement vs. no feedback): pick-and-place task success rises from 40% to 67%, material pass rate from 67% to 83%, and joint success (task + material) from 27% to 57%.

Why it matters / caveats: DeformSmith demonstrates that closing the loop between agentic LLM-driven asset generation, physics simulation probes, and simulated robot manipulation meaningfully improves both visual/physical quality and task readiness of generated deformable assets, and produces replayable interaction data useful for manipulation research. The authors note limitations: the method assumes homogeneous, isotropic materials and approximate robot contact, restricting coverage of more complex deformable objects, and the physical parameters inferred from text/images still require real-world (e.g., video-based) validation.

Problem: Training-free text-guided image editing must apply the requested change from an editing prompt while preserving unrelated source content, but existing diffusion-based (spatial masks/attention control) and causal autoregressive editors either localize edits inaccurately or cannot revise earlier decisions once made.

Method: The paper introduces RefineEdit, a training-free prompt-to-prompt editing framework built on a frozen, pretrained Generative Refinement Network (GRN), which represents images as binary codes via Hierarchical Binary Quantization (HBQ) and refines them globally and repeatedly rather than in a fixed causal order. At a chosen switch step, an editing branch is cloned from the source branch's intermediate binary state and both branches continue refinement under their respective prompts using the same random code and schedule; at each step the signed difference between the source- and editing-branch bit probabilities (evaluated at the same source-sampled bits) defines a spatial mask and a bitwise mask that select which binary coordinates may be edited, with source-anchored bit routing copying the evolving source state elsewhere. Two stabilization mechanisms—adaptive spatial freezing (limits unnecessary mask expansion) and finite bit locking (keeps recently selected bits editable for K consecutive steps)—stabilize these routing decisions across refinement steps. The method requires no additional training, external masks, or attention control, and is evaluated on GRN-generated 1024x1024 images using source/editing prompt pairs from nine PIE-Bench editing categories (object replacement, addition, removal, content/pose modification, color/material modification, background modification, style transfer).

Key results:

• On nine PIE-Bench editing categories, RefineEdit ranks first on 5 of 7 metrics: PSNR 30.25 (vs. FlowEdit 25.03), LPIPS 0.032, MSE 0.0045, SSIM 0.950, and whole-image CLIP 26.47 and edited-region CLIP 23.30 (text also cites PSNR 30.50/LPIPS 0.037 in the discussion, slightly differing from the table).
• Structure Distance is 0.0224, close to but not better than the best diffusion baseline (PnP-DirectInv, 0.0229).
• Compared against 9 training-free baselines (P2P, MasaCtrl, Pix2Pix-Zero, PnP, PnP-DirectInv, LEDits++, ChordEdit, FlowEdit, RF-Inversion) built on SD 1.4/1.5, SD-Turbo, and FLUX.1-dev.
• Runtime: 26.77 seconds per edit at 1024x1024 on a single NVIDIA A100 GPU, comparable to FlowEdit (27.15s) and RF-Inversion (32.05s), and about 3x faster than PnP/PnP-DirectInv (79.70s/79.65s).
• Ablation on an 80-image object-replacement subset examines switch step ts, spatial threshold τspatial, and bitwise threshold τpower; default settings used were ts=18, τspatial=0.015, τpower=0.12, K=4, τfreeze=2τspatial.
• Evaluation set: 560 prompt pairs constructed from PIE-Bench across the nine categories (Table 7).

Why it matters / caveats: RefineEdit demonstrates that GRN's globally revisable binary representation can be repurposed for training-free editing by comparing bit-level probabilities between source and editing trajectories, offering a new editing paradigm distinct from diffusion attention/mask control or fixed-order autoregressive decoding, with notably stronger background preservation than compared methods. Caveats: the edited-region CLIP improvement over LEDits++ is described by the authors as small, so the gain is framed as comparable semantic alignment with better preservation rather than a substantial semantic improvement; the method depends on a specific frozen GRN backbone, and the paper's own ablation Table 6 is explicitly labeled as containing "simulated placeholders, not experi[mental data]," indicating some mechanism-ablation numbers in the paper are not real measured results.

Problem: Existing attention-based hallucination-mitigation methods for Multimodal Large Language Models (MLLMs) rely on indirect signals like attention weights, which fail to capture the actual causal information shift within attention heads that underlies hallucination generation.

Method: The paper proposes HEAL (Head-lEvel information disentAnglement and caLibration), which first applies causal noise intervention on multi-head attention outputs (replacing a head's output with distribution-matched Gaussian noise and measuring the resulting representation change) to filter out causally redundant heads. It then uses a counterfactual Difference-in-Differences procedure, built on Partial Information Decomposition theory, that masks visual and/or language tokens with statistics-preserving Gaussian noise to compute visual, language, and synergy information scores, classifying heads into redundant, visual, language, and synergy types (via 3σ and Logit-transformed MAD thresholds). At inference, HEAL introduces an equilibrium factor α that dynamically calibrates the value vectors of visual and language tokens in synergy heads (via calibration factors β=α/αvis and γ=(1-α)/αlang), applied after the KV cache update and before the attention kernel, with head-type recomputation done periodically (every 10 steps) rather than every step, supported by parallelized tensor operations for the causal intervention and batched Difference-in-Differences computation.

Key results:

• On POPE (LLaVA-1.5-7B base): HEAL achieves F1 87.7±0.3, Accuracy 88.3±0.2, outperforming baselines such as MemVR (87.1/87.4) and LocoRE (86.9/87.3).
• On CHAIR: CHAIRS 36.7±0.4, CHAIRI 10.7±0.03, Recall 79.1±0.1, generation length 99.8±0.7.
• On MME: Total score 669.76±1.72 (vs. CausalLLM 656.00, LocoRE 656.66, MemVR 648.30).
• Plug-and-play gains across models (LLaVA-Bench / CHAIRS / CHAIRI / POPE-F1): LLaVA-1.5-7B 72.5→75.2 / 51.0→36.9 / 15.2→10.7 / 85.4→87.8; LLaVA-NeXT-7B 81.6→82.2 / 29.9→24.6 / 9.2→7.9 / 86.5→88.1; Qwen2.5-VL-7B 76.8→78.5 / 27.2→23.3 / 9.0→8.5 / 87.4→88.4; Qwen2-VL-7B 75.6→78.0 / 25.0→23.1 / 7.3→6.2 / 86.6→88.1; InternVL-7B 51.6→53.4 / 46.6→39.2 / 12.4→9.6 / 85.3→87.8.
• Robustness: head-type assignment agreement across masking strategies ranges 92.13%–95.36% (100% for base Gaussian masking vs. itself); POPE F1 stays stable (86.93–87.84) across masking strategies and across σtotal/MAD threshold choices (86.23–87.84).
• Equilibrium factor α ablation on LLaVA-Bench: scores of 72.1 (α=0.3), 73.6 (0.4), 74.6 (0.5), 75.2 (0.6), 74.8 (0.7) for LLaVA-1.5, showing a peak (U-shaped hallucination trend) around α=0.5–0.6.

Why it matters / caveats: HEAL offers a causally grounded, interpretable, plug-and-play mechanism (rather than a black-box fix) that consistently reduces hallucinations across seven MLLM backbones (LLaVA, Qwen, InternVL series) without retraining. The authors note limitations: the equilibrium factor α and update interval are set empirically and vary by model/task, and hallucinations caused by early visual-encoding failures or lost visual evidence cannot be fixed by head calibration alone, requiring future work on adaptive calibration and tighter integration with training.

Problem: 3D diffusion policies for robot manipulation generate actions from current geometric observations but leave foresight about how an interaction is unfolding to emerge only implicitly from the action-learning objective, with no explicit mechanism for representing where the interaction is heading.

Method: The paper introduces Movement Trend Guidance, which encodes a short history of point clouds and robot states (DP3-style encoders, N=3 observation frames) into a compact 256-dimensional latent via a lightweight two-hidden-layer MLP (hidden width 256); during training an auxiliary decoder is supervised with sparse future gripper-target states (Cartesian position + gripper state at offsets Δ=5,10,15,20) using an elementwise MSE loss (Lfuture, weight λfuture=1.0) added to the standard diffusion sample-prediction loss, while at inference only the latent (not the decoded future states) is retained as conditioning. Architecturally, the latent enters the diffusion UNet through the standard global-conditioning pathway, plus an additional zero-initialized, gated FiLM branch restricted only to the UNet bottleneck (scale/bias projections initialized to zero, negative gate bias), preserving DP3's dense-action, receding-horizon formulation (H=8, executing na=6 actions before re-observing).

Key results:

• Adds only 9.23M parameters to DP3's 262.43M (271.67M total, +3.52%), increasing mean inference latency from 50.28ms to 50.90ms (+1.23%) on an RTX 4090 (batch size 1, 10 DDIM steps).
• RoboTwin2.0 50-task mixed training: 62.8% vs. 56.1% for DP3 (+6.7 points), improving 38 of 50 tasks; single-task category comparison: 61.7% overall vs. 55.2% for DP3.
• LIBERO-40: 71.93% ± 0.49% vs. 37.08% ± 1.21% for DP3 (+34.85 points) at epoch 1000; largest suite gain on LIBERO-Goal (+68.80 points, 77.53% vs. 8.73%).
• DexArt: 59.25% average vs. 52.0% for DP3 (+7.25 points), highest among compared methods (IBC, BCRNN, H3DP, FreqPolicy, DP, SimpleDP3, VITA).
• Five real-robot SO101 tasks: 72.0% average vs. 49.0% for DP3 and 43.0% for SimpleDP3.
• Ablations (50-task mixed training): removing gated FiLM (early fusion only) drops to 57.1%; all-block gated FiLM reaches 55.8%; cross-attention injection reaches 52.9%; bottleneck-only gated FiLM (the proposed design) reaches 62.8%.
• LIBERO-40 ablation: parameter-matched latent without future-supervision loss reaches 44.87% ± 0.33% (+7.79 over DP3's 37.08%), while adding future supervision yields 71.93% (+27.06 further points); explicit future-point conditioning (raw points at offsets 5/10/15/20 embedded in the condition) reaches only 65.28% ± 0.19%, 6.65 points below the latent-trend approach.
• Transfer to ACT (transformer policy) on a six-task RoboTwin2.0 validation: mean success rises from 24.00% to 51.67% (+27.67 points) with movement-trend conditioning added.

Why it matters / caveats: The results indicate that a diffusion policy can gain substantially from a compact, non-decoded representation of "where the interaction is heading" rather than from an explicit predicted trajectory or waypoint target, and that the gain comes specifically from future-state supervision shaping the latent rather than from added latent capacity alone. Limitations noted by the authors: gains are near zero on already near-ceiling tasks (DP3* success >80%), improvements are smaller on precise-placement and tool-use tasks requiring fine-grained local geometry, and occlusion of the manipulated object degrades the movement-trend estimate itself; real-robot validation was limited to five SO101 tasks, and broader validation across diverse objects/scenes is left to future work.

Problem: Convolutional sparse coding (CSC) offers an explicit mechanism to balance compact and sufficient visual representations, but its sparsity coefficient λ is typically fixed and manually selected, leading to suboptimal compression across layers and reduced robustness to input perturbations.

Method: The paper unfolds the CSC optimization using the Fast Iterative Shrinkage-Thresholding Algorithm (FISTA) and reformulates the per-layer sparsity coefficient λ as a differentiable variable, deriving its hypergradient through the unrolled FISTA iterations so it can be jointly learned with the convolutional dictionary and network parameters via backpropagation (parameterized through a Softplus update for non-negativity), yielding the Training-Adaptive CSC (TA-CSC) framework, motivated by an explicit connection between the CSC objective and the information bottleneck (IB) trade-off (I(T;X) vs. I(T;Y)). A training objective combines the task loss with an ℓ1-based compression term (weighted by γ=0.001) to jointly encourage sufficiency and compactness. A label-free post-training adaptation stage further re-estimates λ on a small set of unlabeled corrupted/shifted samples (using a relative-reconstruction-error loss) while freezing the main network parameters θ, to adapt compression strength under distribution shift.

Key results:

• On ResNet-18 backbones, two variants are built: TA-CSC-18 (first conv layer replaced) and TA-CSC-18all (all conv layers replaced).
• Clean-data Top-1 accuracy: TA-CSC-18all reaches 97.65% (CIFAR-10), 80.76% (CIFAR-100), and 72.53% (ImageNet-1K), outperforming ResNet-18 (95.54%/77.82%/68.98%), SCN-18 (95.12%/78.59%/70.42%), and SDNet-18 (95.20%/78.31%/69.47%).
• TA-CSC-18 (single-layer) achieves 96.18%/79.63%/71.12% on the same three datasets, with training speeds of 1324, 1324 (CIFAR), and 1689 n/s respectively, versus 1600/1600/2100 n/s for ResNet-18 and slower speeds for SCN (158/158/51 n/s).
• Memory usage: TA-CSC-18all uses 3.8 GB (CIFAR) and 88.6 GB (ImageNet) vs. 1.0 GB/24.1 GB for ResNet-18.
• On CIFAR-10-C/ImageNet-C corruption benchmarks (averaged over 5 severities), TA-CSC-18all with post-training λ adaptation achieves 68.23% (Gaussian), 73.96% (Shot), 72.67% (Speckle), 60.25% (Impulse) on CIFAR-10-C, and 30.93%/29.62%/23.46% on ImageNet-C, exceeding SDNet-18 + per-sample λ tuning (64.92%/71.13%/71.42%/57.48% and 29.16%/27.59%/22.01%) and plain ResNet-18 (44.43%/57.88%/62.16%/51.72% and 22.73%/21.78%/17.38%).
• Ablations: increasing FISTA iterations from 2→4→8 raises clean CIFAR-10 accuracy from 96.18%→96.54%→96.93%; increasing post-training adaptation samples from 50→100→500 improves corruption robustness (e.g., Gaussian noise accuracy rises from 66.04%→66.63%→67.54%) with diminishing returns relative to compute cost; default settings used are 2 FISTA iterations and 100 adaptation samples.
• λ dynamics show a two-stage training pattern (task-fitting then compression), depth-dependent compression (larger λ near the task head), and four compression-strength peaks aligned with ResNet's four feature-width expansion stages.

Why it matters / caveats: The work provides an interpretable, information-bottleneck-grounded way to make sparse-coding compression adaptive both during training and at test time under corruption, improving robustness without labels. The authors note the study is evaluated only on ResNet architectures and classification tasks, and the link between learned λ and information compression is supported mainly by empirical evidence rather than rigorous theory; TA-CSC-18all also incurs substantially higher memory use and slower training speed than the baseline.

Problem: LLM-generated long-horizon robot plans often fail to respect embodiment constraints, cannot recover from planning errors, and reason poorly under partial observability, especially with compact models.

Method: GAVEL pairs an LLM planner with an explicit graph world model that represents object relations, action pre-/post-conditions over nine grounded primitives (NAVIGATE_TO, GRASP, RELEASE, PLACE_ON_TOP, PLACE_INSIDE, OPEN, CLOSE, TOGGLE_ON, TOGGLE_OFF), and probabilistic beliefs (via a Relational Semantic Network, following SEEK) over unobserved object locations. The world model rolls LLM-generated plans forward via a VALIDATE/REPAIR algorithm that directly applies edits implied by violated action preconditions (e.g., inducing NAVIGATE_TO on a failed grasp), returning only unresolved semantic failures to the LLM (bounded by a query budget T). For multi-task instructions, GAVEL uses an O(N²) belief-conditioned rollout cost model (Eq. 7) to enumerate and re-optimize task orderings after every completed task, reducing expected search/travel cost under evolving beliefs. Task/goal extraction uses LoRA-adapted Qwen3-1.7B models trained on 8,000 synthetic instruction-target pairs, and the RSN uses a frozen BAAI/bge-small-en-v1.5 encoder plus a 3-layer MLP trained on 11,218 object placements across 51 scenes.

Key results:

• On 100 single long-horizon BEHAVIOR-1K tasks, GAVEL raises Qwen3-8B success from 41.2% (llm-only) to 91.8%, and Qwen3-4B from 21.8% to 88.8%, versus 76.4%/55.4% for a SayPlan-style feedback baseline.
• gavel-basic (graph repair only, no LLM re-query) alone reaches 76.2% (Qwen3-8B) and 67.7% (Qwen3-4B) success with just 1 LLM call, versus 3.4/2.7 calls needed by feedback-only replanning.
• On 500 multi-task instructions (Qwen3-8B), GAVEL improves success from 19.9% (llm-only) to 92.6%, versus 75.6% (SayPlan-style) and 60.2% (EPoG-style); oracle achieves 100%.
• Distributional belief reasoning with online reordering reduces mean travel distance from 82.45 m (gavel-map, most-likely-room) to 78.01 m (full gavel), a ~5.4% (4.45 m) reduction; ordering optimization costs only ~17 ms per instruction.
• RSN achieves AUC 0.904, Brier score 0.057; the most-likely room is correct only 47% of the time across 832 held-out queries. The pairwise cost model achieves R² = 0.93 (4-task) and R² = 0.89 (5-task).
• Scaling test (100-instruction subset): without GAVEL, Qwen3-4B/8B solve 2.4%/23.6%, GPT-5.6 Sol 24.6%, Claude Sonnet 5 38.6%; with GAVEL, these rise to 75.2%, 89.2%, 99.2%, and 99.4% respectively.
• The lightweight 2-D executor reduces per-plan execution time from ~17 minutes (OmniGibson) to ~1 second, enabling 5,500 evaluations; abstraction validated with 100% agreement on OmniGibson success outcomes.

Why it matters / caveats: GAVEL shows that an explicit, repair-capable graph world model yields large, consistent reliability and efficiency gains that persist even as LLM capability scales, suggesting compact local models paired with GAVEL can outperform much stronger hosted models used alone. The evaluation is limited to symbolic manipulation (no geometric reachability/collision checking), and most residual failures stem from instruction grounding/object extraction rather than plan verification itself.

Problem: Existing agent-safety benchmarks measure only whether a model refuses an attack, not whether a consequential action (a payment) actually executes when a deterministic authorization check does or does not sit between the model's tool call and its execution.

Method: The authors replay 4,371 human-authored attacks collected from a live capture-the-flag event against a live payment agent, across 14 models from 8 labs, five policy levels (each a "passport" granting a payment capability with different recipient/amount constraints), two replay tracks (single-turn final message vs. full multi-turn message sequence), and two architectures (model alone vs. behind a deterministic pre-action authorization check implementing the Open Agent Passport, OAP, specification). Outcomes are read deterministically off executed tool calls across five separate stages (request, successful payment, policy decision, recipient membership, unpermitted transfer) rather than collapsed into one success rate, and audited (not scored) by a two-model LLM judge panel (Mistral Medium 3.5, Grok 4.6). Statistics use session-clustered bootstrap intervals (1,500 resamples) and Benjamini-Hochberg FDR correction for paired comparisons.

Key results:

• 225,964 of 244,776 planned evaluations completed; corpus of 4,371 attacks (1,128 sessions) from a $6,500-prize CTF.
• Payment-request rate varies by policy level: 10.9% (L1), 3.0% (L2), 0.1% (L3), 79.4% (L4), 25.3% (L5, model alone).
• At Levels 2–4, unpermitted transfers: 140 of 76,842 with model alone vs. 0 of 69,297 behind the OAP layer; on 68,970 matched (model/prompt/track) triples, 105 vs. 0; the zero has a session-clustered upper bound of 0.38% (790 source sessions).
• Behind the layer, 25,370 payments still executed (not obtained by blanket refusal); the policy denied only 187 of 25,640 evaluated transfer calls (148 for forbidden recipient, 17 invalid amount, 13 limit violation, 9 missing audit code).
• Aggregate request rates nearly identical across architectures: paired difference +0.084 percentage points [-0.020, +0.189] on matched triples; 1,220 of 68,970 (1.77%) individual pairs disagreed.
• On 1,293 Level-4 prompts evaluated on all 14 models, request rates ranged 71.2%–84.3%; 809 prompts (62.6%) elicited a request (and successful payment to the allowlisted recipient) from all 14 models.
• Outcome concentration: 2 of 790 sessions produced half of Levels 2–4 outcomes; a 103-attempt forged-receipt cohort (8 sessions) produced 111 of 113 multi-turn Level 2 outcomes; only 73 of 2,809 attacks defeated any model, and just 1 attack defeated as many as five of fourteen.
• Judge panel: pooled inter-judge Cohen's kappa 0.772 overall, dropping to 0.167 at Level 3 and 0.521 at Level 5; one judge recovered 99.1% of confirmed outcomes, the other only 64.4% (missing 3,356 confirmed outcomes).
• Cost/latency: 987.6M input + 218.5M output "banker" tokens plus 1,071.7M judge input tokens (judge panel = 47.4% of total tokens); median latency 8.2s–66.8s, unchanged by the authorization layer; companion paper reports enforcement latency at a median of 53ms.

Why it matters / caveats: The results show that model choice alone does not bound residual payment-authorization risk—every tested model requested unpermitted-adjacent payments at similar rates—whereas a correctly configured deterministic policy check at the tool-execution boundary reduced unpermitted transfers to zero (bounded at 0.38%) without suppressing legitimate requests. Caveats: the study covers a single domain (simulated bank payments, one tool schema), a self-selected CTF attacker population, single-run-per-cell point estimates, an author with a financial conflict of interest (founder of the company whose OAP layer is evaluated), incomplete multi-turn coverage for some models, a locally re-implemented policy engine that is stricter than the published pack at Level 4, and an unfinished human-labeled validation slice for the judge audit.

Problem: Deploying the ~305M-parameter Cellpose-SAM segmentation foundation model on CPU/edge hardware in iPSC (induced pluripotent stem cell) laboratory settings requires compression, but existing evaluation practice for post-training quantization relies on single-number accuracy rather than an auditable, modality-stratified retention criterion needed for regulated stem-cell imaging deployment.

Method: The authors evaluate post-training quantization (PTQ) schemes on Cellpose-SAM (checkpoint cpsam_v2, a promptless Segment-Anything-style encoder combined with Cellpose's dynamics-based flow-integration decoder) using a pre-specified retention protocol: paired instance F1 at IoU 0.5 (plus AP50/AP75 endpoints and empty-mask rate) is compared to FP32, and a scheme passes only if the entire 2,000-draw cluster-bootstrap 95% CI of mean ∆ over experimental units stays above a fixed −0.02 margin on every imaging modality. Compression schemes tested include weight-only W8A16, W4A16-G64 (group size 64), a calibrated W8A16-QDQ-obs (per-tensor activation QDQ instrumentation), a sensitivity-guided mixed W4/W8 scheme (four highest-sensitivity Linear/Conv2d operators, identified via one-operator-at-a-time W4 perturbation over 100 eligible operators, kept at INT8 while the rest use W4), ternary W2A16-G64, and whole-graph W8A8/sub-A8 configurations. Evaluation uses a stratified 176-field hold-out panel across BBBC038 nuclei, BBBC039 U2OS fluorescence, and NIST iPSC images (three density regimes), with a disjoint development split used for sensitivity analysis, bit allocation, and calibration.

Key results:

• Panel: 176 hold-out fields (BBBC038 n=70, BBBC039 n=34, NIST iPSC n=72), 107 experimental units for cluster-bootstrap resampling; FP32 model is ~305M parameters, 1,162.07 MiB storage.
• W8A16: preserves instance F1 across all modalities (∆F1 = +0.0004, +0.0003, +0.0006 for BBBC038/BBBC039/NIST), 3.93× weight-storage compression, 0/176 catastrophic failures (rule-of-three upper bound 0.028).
• W4A16-G64: ∆F1 = −0.0000, +0.0006, −0.0027 (widest arm on NIST, still within margin), 6.90× compression, 1/176 catastrophic failures ([0.000, 0.001]).
• W8A16-QDQ-obs: ∆F1 = −0.0028, +0.0003, +0.0004, 3.93× compression, 1/176 catastrophic failures.
• Sensitivity-guided mixed W4/W8 (MW4-SW8, four INT8 exceptions: blocks.0.mlp.lin2, blocks.23.attn.qkv, neck.2, out): ∆F1 = +0.0017, +0.0004, −0.0012, achieves 6.76× compression with 0/176 catastrophic failures, matching W8A16.
• Ternary W2A16-G64: 12.08× compression but fails catastrophically — ∆F1 = −0.841 (BBBC038), −0.907 (BBBC039), −0.023 (NIST, floor-limited); 169/176 fields catastrophically fail (rate 0.979, CI [0.949, 1.000]).
• Sub-A8 activation quantization (on a broader 245-field whole-graph panel) collapses: A8 gives 83/245 empty masks, A4 and A2 collapse to 245/245 empty masks.

Why it matters / caveats: The mixed W4/W8 scheme deepens compression from 3.93× to 6.76× with no measurable retention loss on this panel, showing sensitivity-guided mixed-precision PTQ can match full W8A16 safety while ternary quantization is unusable regardless of its higher compression ratio; the paper argues compression decisions should be made via modality-stratified, pre-registered retention protocols rather than a single accuracy metric. Caveats stated by the authors: verdicts are scoped to the three evaluated modalities and do not certify performance on 3D volumetric, extended time-lapse, or non-nuclear-stain imaging; the −0.02 margin suits monitoring pipelines but regulatory release-testing would need a tighter margin; and the specific passing bit widths/operator selections are properties of Cellpose-SAM's flow-integration decoder and would not directly transfer to other decoders (e.g., mask-token or U-Net) — only the evaluation protocol itself is claimed to be transferable.

Problem: LLMs exhibit hidden, cross-lingually brittle value biases when resolving conflicts between competing ethical principles, and it is unclear whether such learned value preferences can be isolated and swapped on demand without retraining.

Method: The authors build a 12,000-instance multilingual dataset (English, Hindi, Arabic, Spanish, Chinese) of two-option ethical dilemmas covering three pairwise value conflicts (Honesty vs. Justice = AB, Justice vs. Autonomy = BC, Autonomy vs. Honesty = CA), generated via GPT-4o, validated with Gemini-3-Flash-Preview, and supplemented with a human-authored gold test set. They fine-tune Llama-3.2-1B/3B with LoRA adapters (rank 4/16 on Wq, Wk, Wv) using both SFT and Direct Preference Optimization (DPO, beta=0.1), and benchmark GPT-5-mini zero-shot and with prompt-based stance steering. To achieve preference reversal without retraining, they compute a task vector (Δ = θ_S − θ0) for a trained stance, orthogonalize it against an instruction-only vector (estimated by averaging task vectors from opposing-preference checkpoints) to isolate a pure preference direction, then recombine it with the base model using grid-searched mixing weights γ1 (instruction) and γ2 (preference).

Key results:

• GPT-5-mini (zero-shot, no policy) favors Justice over Autonomy (~70%) and Honesty over Autonomy (~70%) across all five languages, with a weaker bias for Honesty over Justice.
• Prompt-based stance steering on GPT-5-mini raises accuracy substantially but is uneven; e.g., Task AB accuracy drops from 64.5% to 61.8% for Hindi even when explicitly instructed, showing prompting alone is unreliable.
• Zero-shot Llama-3.2-1B/3B models behave near randomly with strong first-option position bias.
• LoRA SFT (5 epochs) eliminates position bias and achieves ≥98% accuracy on the held-out synthetic test set across all value pairs and languages, and >90% accuracy on the human-written gold set.
• DPO achieves comparable results to SFT, with only a small performance drop.
• Task-vector-based preference reversal retains ≥93% of full fine-tune performance on Task BC and ≥80% on the other two pairs for the 1B model, and ≥98% for two tasks (85% on one task in Hindi) for the 3B model; overall ≥96% retention in most cases.
• Optimal mixing weights found via grid search: γ1 (instruction) ∈ [0.3, 0.8], γ2 (preference) ∈ [0.3, 0.7].
• Transitive composition of preference vectors fails (near-random accuracy), and cosine-similarity analysis shows the angles between different stance preference vectors exceed 80°, indicating near-orthogonality rather than a composable linear geometry.
• Human gold set: 60 human-written dilemmas (20 per pair, from 6 annotators), used to confirm generalization beyond synthetic templates.

Why it matters / caveats: The results show ethical stance adherence is learnable and modular in compact (1B-3B) open models via a lightweight, orthogonalized task-vector method, enabling on-demand value-preference switching without retraining or storing multiple checkpoints — supporting practical value pluralism. However, the study is limited to forced-choice dilemmas over only three principles, relies heavily on LLM-generated/translated data with a small human gold set (60 examples), is restricted to Llama-3.2 1B/3B (unclear scaling to larger models), still requires pre-trained preference checkpoints and dev-set-tuned mixing coefficients, and the failure of transitive vector composition indicates the value geometry is only locally, not globally, linear.