AI papers — 2026-07-24

Authors: Shuqi Lu, Chaofan Li, Kun Luo, Zhang Zhang, Hui Wang, Hongwang Xiao, et al.

Problem: Deep research agents that simply search longer fail to systematically resolve multi-constraint queries, since they lack a mechanism to diagnose which specific constraints remain unverified and target follow-up research accordingly.

Method: AREX runs a bi-level loop: an inner research loop (search/visit/python tools) builds a provisional answer with supporting evidence and a confidence score, while an outer self-improvement loop audits the answer constraint-by-constraint and decides to accept, refine (preserving verified progress, targeting unresolved claims), or restart. A learned update_context tool (invoked by the model itself, not an external summarizer) compresses growing trajectories into a compact state retaining verified findings, rejected candidates, unresolved constraints, and next-step plans. Training uses verified synthetic task synthesis + teacher trajectory distillation, followed by multi-stage agentic mid-training (progressive browse-then-reasoning training plus key-step focused supervision on high-loss "decisive" steps like evidence discovery and path redirection) and step-aware reinforcement learning (turn-level GRPO variant with hierarchical step-balanced normalization and key-step reward shaping). Instantiated as a dense 4B model (AREX-Turbo, Qwen3.5-4B backbone) and a 122B-A10B MoE model (AREX-Base, Qwen3.5-122B-A10B backbone).

Key results:

• AREX-Base: BrowseComp 82.5, GAIA 85.4, xbench-2510 71.0, DeepSearchQA 89.9, WideSearch-en 82.0 (best reported, beating Gemini-3.1-Pro's 66.4 and Kimi-K2.6's 80.8), text-only HLE 52.4.
• AREX-Base outperforms the much larger Qwen3.5-397B backbone-family model on every benchmark tested, and beats MiroThinker-H1 on DeepSearchQA/HLE while staying within 1 point on xbench-2510.
• AREX-Turbo (4B) beats Qwen3.5-35B on 5 of 6 benchmarks despite far fewer parameters.
• Ablations on BrowseComp: ACU (context updating) alone raises accuracy 59.6→71.4 (+11.8); outer self-improvement loop adds +10.2 without ACU and +11.1 with ACU; full system reaches 82.5 vs. 59.6 with neither (+22.9 total).
• Training ablations: replacing progressive mid-training with mixed training drops accuracy to 77.5; replacing key-step focused supervision with random-step replay drops it to 74.1 (largest degradation); replacing step-aware RL with standard GRPO drops it to 79.4 — full recipe reaches 82.5.
• Key-step loss analysis: annotated key steps (evidence discovery, path rejection/redirection, context-update) show 19-29% higher token loss than ordinary steps even after full-trajectory training, confirming they are systematically underlearned.
• update_context is invoked in 80.3% of BrowseComp cases, at a mean of 25,721 tokens (well below the 128K limit), mostly triggered by search-strategy revision (66.9%) rather than hitting the context cap.

Why it matters / caveats: Demonstrates that explicit verification-driven state refinement (rather than longer single-pass search) and targeted step-level training signals can let a 10B-active-parameter MoE model match or beat frontier proprietary systems (Gemini-3.1-Pro, GPT-5.4) and much larger open models on deep-research benchmarks, suggesting an efficient path to capable research agents. Caveat: all ablations are reported only on BrowseComp, and comparisons rely on self-reported numbers for competing systems (some HLE scores are marked with different subset conventions, i.e. full vs. text-only HLE).

Authors: Hao Liang, Qihan Lin, Zhaoyang Han, Xiaochen Ma, Zhen Hao Wong, Meiyi Qiang, et al.

Problem: Existing K-12 education benchmarks (C-Eval, CMMLU, GaokaoBench, EduEval) only test whether LLMs can answer exam questions, not whether they understand "curriculum cognition" — how curriculum knowledge is structured (prerequisite chains, concept taxonomies, experiment-concept links, pedagogical sequencing) and visually presented in textbooks.

Method: The authors build K12-KGraph, a heterogeneous property graph extracted from official People's Education Press textbooks (math, physics, chemistry, biology; primary through high school) with 9 node types and 14 relation types, via a 5-stage pipeline: OCR-based Markdown parsing (MinerU), table-of-contents-based section splitting, GPT-5.2-driven schema-guided node/edge extraction with evidence citations, hierarchical bottom-up graph merging/deduplication, and DAG validation with human verification (12 annotators, Fleiss' κ = 0.84). From this graph they derive K12-Bench, a 23,640-item multi-select benchmark across five graph-derived task families (Ground, Prereq, Neighbor, Evidence, Locate), and K12-Train, a KG-guided SFT corpus of 7,335 samples (2,267 text-only + 5,068 multimodal) generated via node-grounded, edge-grounded, and deterministic-template QA synthesis using Qwen3-235B-A22B.

Key results:

• On K12-Bench, best model Gemini-3-Flash reaches only 57.1% exact match (73.0% F1); strong open-source model Gemma-4-31B-IT reaches 46.4% EM; LLaMA-3-8B-Instruct (7.2% EM) is near the random baseline (6.7% EM).
• Prereq and Neighbor are the hardest task families (EM below 35% even for Gemini-3-Flash), while Ground and Evidence are easiest (F1 above 75%/72%).
• Under a matched ~2,300-sample SFT budget, K12-Train-Text beats 8 mainstream instruction datasets on GaokaoBench for both backbones: +24.1 points over best baseline DataFlow (1009.96 vs 985.91 total) on Qwen3-4B-Base, and +32.4 over best baseline WizardLM on Llama3.1-8B-Base; also best on EduEval (66.76 and 40.90 avg respectively).
• For VLMs, K12-Train-Full (7,335 samples) achieves best overall scores on Gaokao-MM (39.9%), MDK12-medium (52.94), and K12Vista (79.95 avg) versus full DataFlow (10,000) and WizardLM (142,759) baselines, and outperforms both K12-Train-Text-only and K12-Train-MM-only variants.
• Cross-subject transfer: despite K12-Train covering only math/physics/chemistry/biology, SFT on it also yields the best Chinese (+3.33) and Humanities Math (+4.08) scores on GaokaoBench over the strongest baseline, suggesting it teaches a transferable reasoning style rather than memorized content.

Why it matters / caveats: The results suggest curriculum-structural understanding is a distinct, currently underserved capability separate from exam-answering ability, and that small, structurally-grounded synthetic datasets can be more sample-efficient than much larger general-purpose instruction corpora for educational LLM/VLM training. The graph and benchmark are specific to Chinese K-12 textbooks (People's Education Press), so generalization to other curricula/languages is untested.

Authors: Hanjing Ye, Tianle Zeng, Jiazhao Zhang, Shaoan Wang, Zibo Zhang, Weisi Situ, et al.

Problem: Vision-language-action (VLA) policies for embodied visual tracking (following a natural-language-described person using only onboard vision) reason in abstract spatial latents that are hard to supervise and poorly aligned with explicit image-space detections, hurting target identification in crowded/ambiguous scenes.

Method: ReferTrack reformulates target identification as selecting one entry (a single Refer-CoT token) from an indexed catalog of detected pedestrian bounding boxes (from YOLO11+ByteTrack), including a special ⟨NO EXIST⟩ token, then conditions waypoint prediction on this selection. A sliding-window FIFO queue of previously selected target bboxes is injected into visual history via temporal-viewpoint-bbox indicator (TVBI) tokens (extending NavFoM-style TVI tokens with bbox geometry via a shared MLP projector). The model (Qwen3-4B backbone, dual SigLIP+DINOv2 encoder) is trained with pure supervised fine-tuning (no RL) via a combined trajectory MSE loss, Refer-CoT cross-entropy loss, and text cross-entropy loss, co-trained 1:1 on 1.3M EVT-Bench navigation trajectories and 1.3M synthesized Refer-QA samples built from the SYNTH-PEDES person-ReID dataset.

Key results:

• On EVT-Bench single-view setting: 89.4/92.5/1.6 (SR/TR/CR) on Single-Target Tracking, 73.3/81.8/7.6 on Distracted Tracking, 74.1/85.7/7.7 on Ambiguity Tracking — state of the art among single-camera methods.
• Versus strongest single-view baseline TrackVLA++: +6.8 SR and +13.0 TR on Distracted Tracking, +22.9 SR and +22.3 TR on Ambiguity Tracking.
• Matches or exceeds several reported multi-camera (3-4 camera) baselines on identification-heavy splits despite using only a single forward camera and a compact 4B model with no RL.
• Ablations: an oracle variant using ground-truth target bboxes (bypassing Refer-CoT) reaches 81.5 SR/84.7 TR (vs. expert policy's 85.1 SR), showing identification—not motion planning—is the main bottleneck; removing TVBI drops SR/TR from 73.3/81.8 to 70.4/80.8; removing both Refer-CoT and TVBI drops SR to 55.7 and TR to 71.4.
• Real-world deployment on Unitree Go2 (quadruped) and Unitree G1 (humanoid) robots runs at 10.6 Hz average loop frequency (12 ms detection per step) on a remote GPU server, successfully following targets through clutter and multi-person interference.

Why it matters / caveats: Shows that explicit, image-grounded referring (rather than abstract spatial CoT or more cameras) can substitute for costly RL fine-tuning and multi-camera setups, offering a simpler, more supervisable path to robust person-following robots. Results and comparisons rely on the EVT-Bench simulation benchmark (Habitat 3.0) with only qualitative (not quantitative) real-world validation.

Authors: Yijun Liang, Yunjie Tian, Yijiang Li, Yuqi Jia, Furong Huang, Tianyi Zhou, et al.

Problem: On-policy self-distillation (OPSD) needs a teacher-student information asymmetry to give useful supervision, but existing methods create this asymmetry via privileged answers or visual evidence signals that require task-specific auxiliary information.

Method: VCSD has an EMA teacher evaluate each student-generated response prefix under two matched visual conditions — the original image and a content-erased control (a same-size black RGB image) — and takes their token-wise log-probability difference (Δt) as a contrast signal. This contrast sharpens the teacher's original-image next-token distribution within a plausibility support set (restricted to tokens with probability ≥ β times the max, β=0.1), and the resulting full-distribution target is distilled into the student via forward KL (α=1.0 controls contrastive shaping strength, TKD=2). No external teacher, privileged answers, reasoning traces, or extra inference-time cost is required; only the trained student is kept at inference.

Key results:

• Trained on ViRL39K, evaluated on 7 benchmarks (BLINK, MMStar, MathVista, V*Bench, HRBench4K/8K, HallusionBench).
• Qwen3-VL aggregate accuracy: 2B 62.27%→67.04% (+4.77 vs base, +2.15 vs OPSD), 4B 71.30%→73.16% (+1.86), 8B 72.51%→76.26% (+3.75, +2.54 vs OPSD).
• Qwen3.5 aggregate accuracy: 2B 68.61%→71.51% (+2.90), 4B 73.94%→76.77% (+2.83), 9B 74.97%→79.24% (+4.27, +4.51 vs OPSD); OPSD gives no consistent gain over base on Qwen3.5, while VCSD improves every scale.
• Ablations: forward KL beats JSD (66.25%) and reverse KL (64.77%) for distillation; plausibility support (β=0.1) prevents long-horizon degradation vs. unrestricted (β=0) shaping; contrastive strength peaks at α∈[1,1.5] (α=0 drops accuracy by 2.33%, α=2 collapses back near no-contrast level); control-image construction (black, Gaussian noise, blur, no-image) is largely interchangeable (66.24%–67.14%); original-image anchor doesn't change aggregate accuracy much but substantially reduces language drift during training.

Why it matters / caveats: Shows visual grounding asymmetry for self-distillation can be manufactured purely from input conditioning (real vs. content-erased image), removing the need for privileged answers, visual-evidence crops, external teachers, or extra inference cost — a simpler and cheaper OPSD recipe. Caveats: evaluated only on Qwen3-VL/Qwen3.5 (2B–9B) with a fixed 90-step training budget on one dataset (ViRL39K), so generalization to other model families, larger scales, or longer training is not established in this paper.

Authors: Xu Wang, Kaixiang Yao, Miao Pan, Xiaohe Zhou, Xuanyu Liu, Wenqi Zhang, et al.

Problem: Existing spatial reasoning benchmarks force answers into coordinates, options, or text, creating an "answer-interface mismatch" that prevents image-generation models — which naturally express spatial judgments in pixels — from being fairly evaluated against text-output VLMs.

Method: The paper introduces ProVisE (Protocolized Visual Evaluation), a benchmark-agnostic framework that pairs a guidance prompt constraining an image-generation model's visual output (e.g., marked instances, direction grids, depth maps, region masks, trajectories) with a deterministic parser that converts the image back into a structured prediction scorable by the benchmark's original metric. An Agentic builder normalizes new benchmarks into task contracts and automatically constructs/validates generation-parser protocols (via Reuse, Build, or Fallback routes) with smoke-test validation before applying them unchanged across all evaluated models. The authors also build SpatialGen-Bench, a 470-sample diagnostic benchmark spanning 14 spatial subtasks across four capability levels (perception, understanding, reasoning, interaction).

Key results:

• On SpatialGen-Bench, GPT-5.4 leads text answering with an Overall score of 61.04%, while GPT Image 2 leads visual answering at 54.49%, both well below the human reference of 87.79%.
• Visual (image-generation) models show advantages on Depth (+18.85 pts group-level, +50.0 pts same-family SenseNova comparison) and Relationship (+6.74/+5.71 pts) tasks, where answers stay directly observable in pixels.
• Text-output VLMs remain stronger on Size, Feasibility, Prediction, and Counting, leading by 17.63 points at the Reasoning capability level overall.
• The Agentic builder generalized to six external benchmarks (EmbSpatial, OmniSpatial, Q-Spatial+, RoboSpatial-Home, SAT, RoboAfford) with GPT Image 2 vs. text baselines, showing no single interface dominates (GPT Image 2 wins on SAT and RoboAfford; text models win the other four).
• Swapping in universal VLM parsers (Qwen3-VL-8B, Qwen2.5-VL-72B, Llama 4 Scout) instead of ProVisE's deterministic parsers changed both scores (mean absolute change 5.26–5.87 points) and model rankings (rank correlations of 0.31–0.60 vs. ProVisE), despite high valid-parse rates (92–99.5%).
• Failure analysis across 5,170 model-sample records found 88.03% of non-correct outcomes were valid-but-incorrect spatial predictions, versus only 8.46% protocol noncompliance, 3.45% parser failure, and 0.06% generation failure — indicating the visual channel usually works, but the underlying spatial reasoning is often wrong.

Why it matters / caveats: The framework offers a metric-compatible way to compare pixel-space and text-space spatial answers without relying on an unconstrained VLM-judge, and reveals that image generators and text VLMs have complementary strengths rather than one being strictly superior. A caveat is that the study's own parser-sensitivity analysis shows evaluation rankings are sensitive to the parsing method chosen, and Fallback protocols (used when deterministic parsing isn't possible) still depend on an auxiliary constrained VLM parser.

Authors: Tencent WorkBuddy Bench Team, Siqi Cai, Shaopeng Chen, Xiang Fei, Yong Mao, Zihan Xu, et al.

Problem: Existing coding-agent benchmarks force a tradeoff between openly released but web-searchable/narrow suites (e.g., SWE-bench) and realistic but closed, unauditable vendor production benchmarks (e.g., CursorBench), leaving no suite that is simultaneously realistic, broad, and openly auditable without contamination risk.

Method: A 260-task, four-domain suite (Code 80, Web 70, Office 50, Security 60) where every task is reverse-engineered from a real commit, pull request, CVE, or business scenario and rewritten as a short, colloquial, role-played, deliberately underspecified request rather than reused issue text, so prompts aren't recoverable by web search. All tasks share a Harbor-style task-directory format (instruction.md, task.toml, Docker environment, held-out tests/grading) and run under two agent harnesses (CodeBuddy Code and Claude Code) in isolated sandboxes; Code uses hidden unit tests with oracle-gated admission (baseline reward ≤0.3, gold-patch reward =1.0), Web uses rule + LLM/VLM + agent-judge rubric scoring over 786 items, Office blends deterministic rule checks with an evidence-grounded LLM Judge (task-specific weight 0.70–0.95), and Security uses a fully deterministic per-task scoring.py behind five anti-cheat layers (no LLM judge). Scores are not averaged across subsets by design.

Key results:

• Leaderboard (avg of 3 runs, think mode; CodeBuddy Code / Claude Code): Claude Opus 4.8 leads Code (74.4/77.9) and Web (68.1/69.9) and Office under cbc (82.4); GPT-5.5 leads Office under cc (86.1); open-weight GLM-5.2 leads Security under both harnesses (76.3/80.9).
• Harness choice materially reorders rankings: mean absolute score shift between harnesses is ~8.6 points on Security (largest), versus ~0.86 median on Office (smallest); e.g., GPT-5.5 jumps from 6th to 2nd on Security when switching harness.
• On Code, models score much lower on real bug-fix/api_contract categories (mean reward 0.47) than on well-specified synthetic categories like feature_pipeline (0.94) and testing (0.88); Data & Algorithm tasks average ~74% vs. ~65% for Coding tasks.
• GPT-5.5 is consistently the leanest high scorer, using the smallest output-token budget of any model on every track under cbc (6.9k tokens on Code, 13.5k Web, 10.2k Office, 7.5k Security), while Security is the most token/turn-heavy track overall (30–89 turns per run, one config reaching ~11.1M cache-inclusive input tokens/run).
• Task-level security refusals were rare but concentrated: Claude Opus 4.8 recorded 13 refusals under Claude Code (0 under CodeBuddy Code); GPT-5.5 had 2 under CodeBuddy Code; all other models had none.

Why it matters / caveats: The dual-harness, per-domain leaderboard shows agent capability rankings are harness-dependent and not well summarized by a single aggregate score, which is a useful corrective for benchmark-driven model comparisons. Caveats acknowledged by the authors: Code is Python-dominated, one leaderboard cell used a modified instruction setup, judge-based components (Web/Office) carry unquantified model-judge bias, Office is text-first with no OCR/vision/GUI coverage, and full open release means contamination resistance relies on construction-time freshness plus future dataset versioning rather than being permanent.

Authors: Paul Furgale, Severin Klingler, James Nolan, Matt Staats, Gaia Di Lorenzo, Elisa Martinez Abad, et al.

Problem: Traditional agent development scatters agent logic across prompt templates, tool schemas, callback code, and workflow graphs, forcing developers (and models) to learn bespoke DSLs instead of reusing mature Python abstractions.

Method: NOOA (NVIDIA Object-Oriented Agents) represents an agent as a single Python class: methods are actions, fields are model-visible state, docstrings are prompts, and type annotations are validated I/O contracts. Methods with a real body execute as deterministic Python, while methods whose body is just "..." are run at runtime as an LLM-driven loop via a pluggable "strategy" (PredictStrategy for single-shot typed calls, or the default CodeActStrategy, an iterative Python REPL where the model writes code, calls execute_python(...), and terminates with a type-validated return_result(...)). Arguments and outputs are passed by reference as live Python objects (rendered to the model only as bounded head/tail previews), and the framework exposes context blocks, an append-only typed event history, and an optional self-curated long-term memory subsystem (SQLite-backed, ACT-R-style retrieval) through explicit Pythonic APIs.

Key results:

• Capability suite (88 tests × 5 runs × 10 models = 4,400 records): 97.9% overall pass rate; large/frontier models 99.2% vs. small/efficient models 96.0%; GPT-5.5 perfect (100%); harder "stress" tests drop to 84.7% overall (93.9% large vs. 70.8% small models).
• SWE-bench Verified: NOOA reaches 82.2% with GPT-5.5 at xhigh reasoning (vs. 78.6% OpenCode, 78.2% PI) and 79.8% with Opus 4.6 (vs. 75.2%/75.8%), using ~28 model calls and ~1.1M tokens/task vs. 66 calls/2.2M tokens for PI.
• Terminal-Bench 2.0: NOOA scores 73.0% (GPT-5.5, high effort, +12.3 pts over OpenCode) and 65.2% with Opus 4.6 (vs. 43.8% OpenCode, 58.4% PI).
• CyberGym L1 (vulnerability discovery): NOOA (GPT-5.5) achieves 86.8% solve rate, the top open-source result, beating OpenAI Codex (64.9%) and most closed-source systems.
• ARC-AGI-3: a single NOOA agent + one 50-line skill (replacing a 6-agent, 1,821-line prior "DreamTeam" system) reaches fleet-mean RHAE 50.2% on GPT-5.5 (+8.5 pts over a baseline skill, +11.8 pts over an ablation without the memory subsystem) and 85.1% on GPT-5.6-sol at under $20/game, versus 13.3% for raw GPT-5.6-sol on the same games.

Why it matters / caveats: The paper argues code-as-action plus pass-by-reference over live typed objects lets agents scale past context-window limits and cuts token usage/failure modes tied to serialization; a 14-framework survey finds the community converging on these six interface ideas piecemeal but NOOA is first to combine all six. Caveats: comparisons rely on the authors' own harness implementations and pinned snapshots of competitor tools (self-reported), gains between reasoning-effort settings narrow for stronger models, and residual failures cluster in long-horizon batching/recovery/decomposition tasks even for frontier models.

Authors: Junsong Chen, Jincheng Yu, Yitong Li, Shuchen Xue, Haozhe Liu, Jingyu Xin, et al.

Problem: Full 3D softmax attention in video diffusion transformers scales quadratically with sequence length, making high-resolution and long-duration video generation prohibitively slow, while pure linear attention (as in the original SANA-Video) is fast but its fixed-size state matrix loses expressiveness for precise spatiotemporal correspondence.

Method: SANA-Video 2.0 is a from-scratch-trained hybrid video DiT (5B and 14B scales, LTX-VAE 2.3 latents, Gemma-2-2B-IT text cross-attention) that interleaves gated bilinear linear attention with gated-softmax "anchor" layers at a fixed 3:1 (75%/25%) ratio to restore full-rank token interactions periodically. Block Attention Residuals (AttnRes) group every 8 layers into a block and route completed block-summary features (via a shared, timestep-independent routing query) into later linear layers so anchor-refreshed representations propagate across depth instead of being re-derived. Training uses a multi-stage pipeline (data curation/quality-motion funnel, resolution/duration curriculum with token-count-aware flow-shift, Self-Flow distillation, then Diffusion-DPO and ReFL preference post-training with HPSv3++/DeQA-Score/UniPercept rewards).

Key results:

• VBench Total 84.30 (Quality 85.61) at 480p/81 frames in 13.2s on one H100 with 40-step sampling, 31.8x cheaper than the only higher-scoring model (Bernini-R 14B, 84.64 Total, 421s).
• AttnRes raises deep-layer effective rank by ~11.7% (up to +12% in layers ≥15) on matched checkpoints, with completed-block routing mass reaching 56%/50% (attention/FFN) at the deepest blocks.
• 25% softmax ratio identified via proxy sweep as the Pareto knee: pure-linear val loss 0.955, pure-softmax 0.945, 50% hybrid best at 0.897 but 1.29x slower than 25% hybrid at 1080p/121f.
• Compiled DiT forward is 3.2x (up to 3.17x-3.2x reported) faster than matched full-softmax baseline at 720p/60s, with the gap widening with duration (e.g., 2.01x at 1080p/121f vs 1.16x at 480p).
• Sol-Engine full-stack deployment (kernel fusion + diffusion caching + sparse attention) gives a directly measured 3.58x speedup on B200 (62.65s to 17.52s at 720p/8s), yielding 13.06s at 720p/5s for the 5B pipeline, 120x faster than Wan 2.2-A14B on one H100.
• MXFP4-weight/MXFP8-activation QAT matches BF16 VBench Total (83.25 vs 83.22) while cutting static model storage 67.9% (8.94GB to 2.87GB) and peak memory 56.9%.

Why it matters / caveats: The paper demonstrates that hybrid linear/softmax attention plus cross-depth attention residuals, trained from scratch rather than linearized from a pretrained softmax model, can match much larger full-softmax video DiTs in quality at a fraction of latency, with advantages that grow with video length/resolution — directly relevant to scaling long, high-resolution video generation on a single GPU. Caveats: it still trails Bernini-R 14B on VBench Total/Semantic, some efficiency gains (Sol-Engine caching/sparse attention) are approximations rather than exact computation, and quantization currently covers only linear GEMMs (attention stays BF16), limiting the QAT latency win to ~11ms.

Authors: Ruikang Li, Molin Li, Jiarui Wu, Zhe Wei, Pengpeng Liu, Tianfan Xue

Problem: When a real scene is captured by a smartphone camera and shown on its screen, the displayed colors, brightness, and contrast noticeably diverge from the original scene because standard ICC-style pipelines separately calibrate camera and display stages through a low-dimensional intermediate color space, causing error accumulation and an information bottleneck.

Method: Color Pass-Through treats the camera and display as one coupled system and learns an end-to-end correction directly on captured images, decomposed into two trained components: (1) a lightweight pixel-wise MLP (two FC layers, hidden width 128, with positional encoding and an AvgPool on the green channel to counter demosaicing artifacts) that learns the camera-display projector F̂_C from a re-capture protocol — rendering sampled RGB images on the display, re-photographing them with the paired camera, and optically aligning input/target pairs; (2) a camera-null color correction term that models the residual color cast (the "metameric-black" spectral component invisible to the camera but visible to a different observer) as a rank-1 PCA approximation, predicted per-pixel by a CNN spectral-reconstruction network (MST++) and scaled by a single observer-specific 3x1 calibration coefficient φ estimated via one-time grid search per observer.

Key results:

• On the camera-display projector benchmark, their MLP (30.8K params, 41.3ms on an RTX 4090 at 2K resolution) reaches PSNR 32.13 / ΔE_mean 3.34 / STRESS 4.69, beating IA-3DLUT, NiLUT, and CSRNet baselines.
• The rank-1 camera-null model is justified empirically: the first PCA principal component explains ~93% of the variance of the camera-null residual on a large hyperspectral radiance set.
• On 24 ColorChecker patches under diverse illumination (10 CCTs 2500K-9000K + 5 RGB-LED colors), the full method reaches PSNR 28.65-29.10 and ΔE_mean 4.79-5.18 across two phones (Huawei Pura 70 Pro, Xiaomi 17 Pro Max), versus PSNR 13.78-16.36 and ΔE_mean 13.49-18.49 for default ISP, multi-illuminant auto-WB, and ColorChecker calibration baselines — roughly 2x+ improvement, and removing camera-null correction drops PSNR to ~27.3-27.8 and raises ΔE_mean to ~6-6.5.
• In a 10-observer, 5-point Likert user study rating similarity of displayed vs. real scene, their method scored 4.32 (brightness) / 4.03 (color) versus 1.90/2.07 (default camera), 1.66/1.90 (ColorChecker calibration), and 2.06/1.84 (multi-illuminant auto-WB) — an average gain of about +2.0 points.
• The learned projector remains effective with as few as 100 training image pairs, and the calibrated observer coefficient φ stays stable across ±0.015 perturbations in a robustness user study across 10 scenes.

Why it matters / caveats: The approach requires per camera-display pair (and per-observer) calibration rather than a universal transform, which fits pass-through use cases (phone/VR see-through) where the same device pair is reused, but doesn't generalize instantly to arbitrary camera-display combinations; evaluation relies on a DSLR as a proxy "digital observer" for most quantitative results, validated only indirectly against human judgments via trend consistency (Fig. 11).

Authors: Jihoon Tack, Philippe Laban, Jennifer Neville

Problem: It is unclear whether LLMs can faithfully track and act on a user's intent as it is incrementally revealed, revised, and redirected across a multi-turn conversation, since current evaluation is predominantly single-turn and fully-specified.

Method: The authors propose a framework that converts any verifiable single-turn benchmark into a multi-turn "evolving-intent" conversation by anchoring the source problem's intent (function, arguments, ground-truth answer) at the final turn and retrospectively synthesizing preceding turns via three controllable transition types: argument reveal (incremental disclosure), argument revision (changing a previously stated value, via LLM-generated counterfactuals), and function switch (pivoting to a related predecessor task with shared arguments). Because the conversation is constructed to converge exactly to the original single-turn intent at the last turn, the source dataset's automatic verifier can score the agent without new annotation. They apply this to four benchmarks (GSM8K, BIRD-SQL, BrowseComp+, SWE-Bench Verified) and evaluate nine frontier and open-weight LLMs (GPT 5.1/5.2/5.5, Gemini 3.1 Pro, Grok 4.20, Kimi K2.5/K2.6, Mistral Large 3, DeepSeek V3.2) under a 6-transition (7-turn) evolving scenario.

Key results:

• Across all models, single-turn accuracy does not transfer: e.g., GPT 5.5 drops from 99.0% to 80.5% on GSM8K (-18.7% relative) after 6 intent transitions; DeepSeek V3.2 drops from 76.0% to 53.0% on BIRD-SQL (-30.3%).
• SWE-Bench Verified shows extreme degradation for some models — GPT 5.1, Grok 4.20, and Mistral Large 3 fall from 72-84% to 0.0% (-100%) as agents exhaust the 100 tool-call budget exploring rather than executing (fewer than 4 of 100 calls per turn are execution-related).
• Function switch is the most damaging transition type — on GSM8K it causes a steeper accuracy decline than argument reveal/revision, and composing switch with revise/reveal drives GPT 5.1 on SWE-Bench to 0.0%.
• Turn-wise intent-tracking analysis shows GPT 5.1 predicts user intent with ~98-99% accuracy after argument reveals/revisions but only 82-89% after function switches.
• Memory mechanisms partially help but don't close the gap: oracle recap raises GPT 5.5 on BIRD-SQL from 65% to 75% under function switch, still below the 80% single-turn accuracy.
• Harder source problems degrade more under evolving intent than single-turn: on BIRD-SQL, removing a difficulty hint drops GPT 5.5 by 3.6% relative in single-turn but 9.0% relative in the evolving setting.

Why it matters / caveats: The paper exposes a capability gap invisible to static benchmarks but critical for real-world collaborative agents that must track shifting user goals. Caveats: the framework assumes one intent transition per turn, uses stylistically uniform LLM-rendered user utterances (no persona/typo variation), and the verifier is only exact at the final turn, so intermediate-turn correctness is not directly measured.

Authors: Lukas Knobel, Andrew Zisserman, Yuki M. Asano

Problem: Frame-to-frame video change entangles camera motion and object motion, and existing self-supervised video representations typically encode this change as a single entangled latent rather than separating these two sources of dynamics.

Method: The Structured Dynamics Model (SDM) sits on top of a frozen DINOv2-B/14 (with registers) image backbone and predicts the next frame's feature map from the current one via two sequential transformer-decoder stages: a primary stage that extracts a recurrent "primary motion" token to compensate for the dominant source of change, and a residual stage that extracts a "residual motion" token from the remaining mismatch to explain leftover dynamics. Training combines a self-supervised future-feature-prediction MSE loss on real video (SSv2, DL3DV) with weak scene-level supervision on synthetic Kubric data (labels indicating whether the camera or scene is static), which selectively bypasses or regularizes the primary/residual stages. The authors also introduce ProbeMotion, a linear-probing evaluation suite spanning Kubric, DL3DV, CameraBench, static DAVIS2017/YouTubeVOS, and an SSv2-110k subset, covering camera motion, object motion, and action classification.

Key results:

• SDM (215M params total, 87M frozen backbone) beats CLS/AVG-pool frozen-feature baselines on 6/7 ProbeMotion tasks (loses only on static DAVIS2017 object displacement).
• Outperforms the self-supervised DeltaTok baseline on 5/7 tasks despite DeltaTok being trained 8x longer at higher resolution — e.g., 0.16 lower MSE on Kubric object motion and +9.6 points accuracy on SSv2-110k (23.1% vs 13.5%).
• Competitive with much larger, strongly supervised 3D models (VGGT-1B, Depth Anything 3, Pi3X, ~1B params each): SDM beats the best supervised baseline by 0.13 MSE on Kubric object motion and 0.04 MSE on static YouTubeVOS, and exceeds the best supervised descriptor on SSv2-110k action recognition by 3.3 points (23.1% vs Pi3X's 19.8%).
• Token specialization confirmed via swapping: primary token p is best for camera-motion/action probes (e.g., 85.3% vs 81.1% for r on CameraBench), while residual token r is best for Kubric object motion (0.19 vs 0.21 MSE), supporting the intended primary/residual decomposition.
• Longer temporal context helps: on SSv2-110k, accuracy rises monotonically from 16.7% (T=2) to 23.1% (T=7), beyond the T=5 training range.

Why it matters / caveats: Shows that frozen, off-the-shelf image backbones can be repurposed into structured, interpretable motion representations using only weak synthetic labels plus unlabeled real video, avoiding the costly geometric supervision (camera pose, depth, point clouds) required by models like VGGT. Caveats: SDM still trails supervised models on some benchmarks (e.g., static DAVIS2017, DL3DV), and qualitative motion extrapolation/token-swapping experiments show quality degrades over longer horizons.

Authors: Sicheng Mo, Yuheng Li, Ziyang Leng, Krishna Kumar Singh, Bolei Zhou

Problem: Autoregressive video diffusion world models condition only on past-frame observation history, which makes it hard to maintain a consistent, shared world state across multiple interacting agents and views.

Method: WorldWeaver (W²) augments a streaming multi-agent video diffusion pipeline (built on the Solaris/SolarisEngine two-player Minecraft setting) with "world state registers" — learnable tokens interleaved with frame tokens in a causal transformer that are committed and updated after each generated chunk. The registers are grounded via auxiliary supervision heads predicting per-agent status (position/velocity/orientation), bird's-eye-view maps (via DINOv2 feature cosine loss), and scene text (via a captioning cross-entropy loss), and the architecture uses a Mixture-of-Transformers (MoT) design with separate weights for register vs. frame tokens under shared attention. Training follows a three-stage curriculum: bidirectional multi-agent pretraining, causal training with register supervision, then Self-Forcing-style rollout distillation (DMD) with register loss retained.

Key results:

• On the Solaris test split, WorldWeaver raises aggregate WorldScore from 81.0 (retrained Solaris baseline) to 105.1, with Frame-concat baseline at 49.1.
• Category VLM accuracy gains over Solaris baseline: Grounding 81.3→93.8, Building 9.4→28.1, Consistency 57.8→76.6.
• Ablation: registers alone (no explicit supervision) already lift WorldScore 81.0→93.8; adding all three supervision signals (agent stats + bird's-eye view + scene text) reaches 105.1; scene text alone is the strongest single signal (103.2).
• MoT vs. dense backbone: under scene-text supervision, dense backbone drops to 91.3 WorldScore while MoT reaches 103.2, showing MoT mainly helps once registers carry richer semantic supervision; freezing the visual transformer after step 1500 in Stage 3 improves mean VLM accuracy from 63.8 to 68.1.
• Semi-supervised training with a fixed 1K labeled clips: adding unlabeled clips improves WorldScore from 63.2 (0 unlabeled) to 82.3 (5K unlabeled) to 90.3 (10K unlabeled).

Why it matters / caveats: Explicit, persistent, cross-agent world-state tokens (rather than raw frame-history conditioning) measurably improve logical/geometric consistency in multi-agent video world models, and the approach degrades gracefully with partial labels via semi-supervised training. The main caveat, acknowledged by the authors, is that the demonstrated state supervision (agent stats, BEV, scene text) relies on simulator-derived ground truth (Minecraft/SolarisEngine) that is not readily available for real-world data, and evaluation is limited to a two-agent Minecraft setting.

Authors: Chenhui Gou, Haoqin Tu, Yunhao Fang, Jianfei Cai, Hamid Rezatofighi

Problem: In-context learning lets agents cheaply exploit their own trial-and-error interaction histories, but those gains vanish once the experience is dropped from the context, and naively distilling that experience into model weights (via context distillation or SFT) either requires costly extra environment rollouts or fails to transfer the gains.

Method: The paper formulates "Experience Distillation" as trajectory-level context distillation: a teacher conditioned on the collected experience trajectory τ_exp induces a target policy that a student (without that context) is trained to match via KL/forward-KL matching. To avoid needing further environment interaction (as full or branched model-based rollouts would require, and which suffer from compounding world-model error), they take the limiting case of a "1-step branched rollout" — the teacher only samples a single next decision at each recorded branch point, requiring no world model and no new environment samples. A practical implementation adds experience preprocessing (summarizing/compressing long histories), an enhanced-reasoning prompt for the teacher, and "branch packing," which autoregressively packs many branch-point teacher decisions into one training sequence (recorded actions/observations copied in as context, only teacher-generated tokens contribute to the loss) for much denser supervision.

Key results:

• On 749 curated SWE tasks, Experience Distillation reaches 51.4% avg pass@1 (vs. 76.4% ICL reference, 5.3% zeroshot), retaining 64.8% of the ICL gain (G_ICL), versus only 3.8% for direct SFT on the same experience.
• On 6 TaleSuite text-adventure tasks, it reaches 43.8 avg normalized score (vs. 45.6 ICL, 18.5 zeroshot), retaining 93.4% of the ICL gain, versus −2.6% for SFT.
• ICL + Experience Distillation matches/exceeds classical RL: 51.4% pass@1 vs. PPO's 17.7% using 9.6× fewer environment samples on SWE; 43.8 vs. GRPO's 29.9 using 57.2× fewer samples on TaleSuite.
• Ablations: the model-free 1-step rollout beats model-based branch/full rollouts (avg task-level G_ICL 83.8% vs. 57.3%); branch packing cuts training instances from 4096 examples to 128 sequences and reduces training+generation time by >10× while maintaining performance (G_ICL 84.2%→90.1%).
• Generalizes to 494 OOD SWE tasks (unseen repos/task types): pass@1 improves from 4.62% (zeroshot) to 8.84%, pass@5 from 20.39% to 26.13%.
• Continual Experience Distillation over 5 collect-and-distill cycles raises TaleSuite mean score from 7.1 to 47.0 using only 20 cumulative environment samples per task, showing gains accumulate in weights across cycles.
• Teacher-sampled forward KL (default) strongly outperforms a student-sampled reverse-KL/on-policy-distillation variant (e.g., Balances G_ICL 96.7% vs. 9.1%; Detective 98.4% vs. 0.4%).

Why it matters / caveats: The method offers a practical route to internalize costly, hard-won agent experience (e.g., from expensive real-world or long-horizon environments like SWE repos) into model weights without any additional environment interaction beyond what was already collected, closing most of the gap to RL at a fraction of the sample cost. Caveats: it still retains only 64.8–93.4% of the ICL ceiling (not full recovery), depends on careful experience preprocessing/teacher prompting, and experiments use in-house base models on two specific domains, so broader generalization is untested.

Authors: Arjun Majumdar, Avinash Sooriyarachchi, Benjamin Tibi, Chris Bamford, Elliot Chane-Sane, Guillaume Lample, et al.

Problem: State-of-the-art vision-language navigation systems rely on depth sensors, multi-camera rigs, or pre-built maps, which limits which robots they can run on and raises deployment cost.

Method: Robostral Navigate is an 8B-parameter VLM, initialized from a spatial-grounding model, that consumes only monocular RGB frames plus a language instruction and predicts the next waypoint by pointing to image coordinates (with a metric-displacement fallback when the target is out of view). A lightweight 121M-parameter diffusion transformer converts waypoints into 10Hz action chunks, which an embodiment-specific motion controller turns into 100Hz motor commands. Training uses 2.4M simulated trajectories across 350k scenes, a prefix-caching scheme with a tree-based attention mask that packs whole episodes into single sequences (cutting training tokens 22x) while blocking attention to prior ground-truth actions, followed by online reinforcement learning with CISPO (reward = -max(2, dist_to_goal)) on a curated hard subset of 35k trajectories.

Key results:

• R2R-CE validation unseen: 77.4% success rate (SR), 74.2% SPL — beats best monocular baseline (Qwen-RobotNav-4B, 66.9% SR) by 10.5 points and best depth/multi-camera system (Qwen-RobotNav-8B, 72.1% SR) by 5.3 points.
• RxR-CE validation unseen: 75.1% SR, 68.7% SPL, 3.47m navigation error — outperforms all monocular baselines and beats the best depth/multi-camera baseline on SPL (68.7% vs 65.7%) and navigation error (3.47m vs 3.58m).
• R2R-CE validation seen: 79.4% SR.
• Online RL adds +4.03% SR on R2R-CE unseen (73.40% to 77.43%) and +3.9% SR on RxR-CE (71.2% to 75.1%) over the SFT baseline.
• Prefix-caching training recipe reduces training tokens by 22x, cutting training time from months to days.
• Demonstrated cross-embodiment deployment of the same VLM and diffusion-policy weights on two different robots (Galaxea R1 and Hiwonder JetAuto) without retraining.

Why it matters / caveats: Shows a minimal-sensor (single RGB camera), image-space pointing policy can beat depth- and multi-camera systems on standard VLN benchmarks, potentially lowering hardware requirements for deploying navigation across wheeled, legged, and aerial robots. Caveats: results are evaluated in simulation (Habitat/R2R-CE/RxR-CE); real-world cross-robot deployment is demonstrated only qualitatively (Figure 2) without reported quantitative real-world metrics in the text read.

Authors: Baohao Liao, Hanze Dong, Christof Monz, Xinxing Xu, Li Dong, Furu Wei

Problem: Fully online on-policy distillation (OPD) for multi-turn LLM agents is expensive because every training update requires fresh student rollouts through the environment plus fresh teacher queries at each visited history.

Method: The paper proposes Replayed-Prefix On-Policy Distillation (ReOPD), which replays pre-collected teacher trajectories (e.g., the teacher's own GRPO rollouts, obtained for free) as fixed prefixes: the student only generates its own action at a selected step on top of a teacher-forced prefix, and the teacher supplies dense per-step KL supervision with no new environment interaction. The paper formally identifies a "prefix trap" — a two-sided distribution shift between student occupancy relevance and teacher reliability — and derives a bound decomposing the objective gap into an occupancy-mismatch term and a teacher-reliability term, motivating a geometric bridge distribution between student and teacher occupancies. This bridge is implemented practically as a one-parameter step-decaying sampling schedule ω(t;κ)=κ^t (κ=0.6 by default) that oversamples early, low-shift prefix positions and undersamples late, high-shift ones.

Key results:

• On math-with-Python reasoning (Qwen3-4B student), ReOPD beats OPD average accuracy across all teacher scales: 57.2 vs 55.1 (Qwen3-4B teacher), 53.7 vs 51.0 (Qwen3-8B teacher), 52.5 vs 51.1 (Qwen3-30B-A3B teacher); AIME24 improves from 28.3→36.7 under the Qwen3-8B teacher.
• On search/QA tasks, where the teacher stays reliable on student-induced histories, ReOPD essentially matches OPD (40.5 vs 40.6 average with Qwen3-4B teacher; 39.0 vs 39.1 with Qwen3-8B teacher).
• ReOPD uses zero tool calls during student training and is at least 4x faster per rollout than OPD (up to 9.1x fewer tool calls per trajectory in search); even accounting for one-time teacher resampling time when no RL pool exists, it remains >2x faster than OPD.
• A single shared student jointly distilled on math+search stays on par with per-domain OPD (math avg 55.3 vs 55.2, search avg 41.0 vs 41.0) while never needing simultaneous online environments.
• Ablations show prefixes generated by the teacher itself outperform prefixes from a larger/stronger generator, and an RL-collected (mixed-checkpoint) prefix pool performs nearly identically to a stationary final-teacher pool (53.7 vs 53.4 avg).

Why it matters / caveats: By decoupling teacher rollout collection from student training, ReOPD turns expensive multi-turn agent-environment interaction into a reusable offline resource, simplifying distillation across heterogeneous tools/environments without deploying them all simultaneously. A caveat noted by the authors: the step-decay schedule is a coarse depth-based proxy for true teacher reliability, and student gains depend on the pre-collected pool's coverage/quality.

Authors: Xiangxin Zhou, Jiarui Yao, Penghui Qi, Bowen Ping, Jiaqi Tang, Haonan Wang, et al.

Problem: In divergence-based trust-region masking for LLM RL (e.g., DPPO), the proximity criterion was upgraded from a single-sample importance-ratio test to a full distributional divergence, but the direction criterion (which decides whether an update should be masked) still relies on the sampled-token ratio, which can disagree in sign with the actual change in the divergence.

Method: The authors propose the predictive divergence mask, which replaces the ratio-based direction criterion sign(Â(r−1)) with the sign of the first-order (directional) derivative of the same KL divergence used by the proximity criterion, Ḋ = (πk − µk) + Σi πi(µi − πi), derived in closed form for softmax policies via a policy-gradient logit perturbation. This decomposes into a "local" term (equivalent to the ratio-based criterion) and a "global" softmax-normalization coupling term that the sampled ratio cannot see. Since rollout engines only expose top-K token probabilities, they introduce two lightweight tail estimators — an aggregated-tail estimator (collapsing the tail into one bucket) and a uniform-tail estimator (spreading tail mass uniformly) — to approximate Ḋ from top-K statistics with negligible overhead.

Key results:

• Evaluated on Qwen3-4B-Base, Qwen3-8B-Base, and Qwen3-30B-A3B-Base (both FP8-Rollout and FP8-E2E precision) trained on filtered DAPO-Math-17k (~13k samples), tested on AIME24/AIME25 (avg@16); GRPO clip-higher collapses on both Qwen3-30B-A3B-Base settings while divergence-based methods (DPPO-TopK-KL and the two predictive variants) stay stable.
• Both predictive divergence masks (aggregated-tail and uniform-tail) improve over the DPPO-TopK-KL baseline across all four model/precision settings at the recommended threshold δ=0.15, and the improvement persists (though all methods degrade) at a tighter δ=0.05.
• Token-level analysis over 61 seeds (1024 sequences each, ~1435 out-of-trust-region tokens/seed, ~82 disagreement tokens/seed): the divergence-based direction criterion has a lower "unsafe-keep" rate than the ratio-based criterion (34.2% vs. 36.9%, a 2.7 pp reduction), and is better on 38/61 seeds.
• Among kept disagreement tokens, the divergence-based criterion produces a higher fraction of divergence-contracting (corrective) updates than the ratio-based one (65.1% vs. 62.9%).
• The two tail estimators behave nearly identically in training, consistent with the theoretical bound that their gap ≈ πtail(µtail − πtail) is small when top-K captures most probability mass (vocabulary size ~10^5 vs. K≤20).

Why it matters / caveats: The method is a drop-in replacement requiring no new hyperparameters (reuses Ât, top-K probabilities, and existing threshold δ) and improves stability/robustness to the trust-region threshold across model scales and low-precision (FP8) training regimes. The authors note it remains a local, token-level first-order approximation — real updates aggregate gradients across all tokens, so the predicted sign is an estimate of local divergence trend rather than an exact prediction of realized change, and the disagreement set (where it differs from ratio-based masking) is a modest fraction of out-of-trust-region tokens.

Authors: Hyunmin Cho, Jaejun Yoo, Kyong Hwan Jin

Problem: Coordinate-based MLPs used as implicit neural representations (INRs) suffer from spectral bias, and existing fixes for high-frequency fidelity typically require adding independently parameterized layers, more parameters, or more optimization steps.

Method: The authors give a Fourier-series analysis showing sinusoidal layers induce a harmonic line spectrum, where repeated application of a shared sinusoidal block generates new spectral lines at integer combinations of the encoder's base frequencies (via a Jacobi-Anger expansion), progressively enriching effective spectral support without adding parameters. They instantiate this as "Harmonic-SIREN": a sinusoidal input projection followed by R weight-tied, bias-free recurrent sinusoidal blocks (unrolled via backprop-through-time) and an output projection. For lossless image fitting they additionally supervise in a binarized Gray-coded bipolar code space using a cosine-similarity alignment loss, plus a decoded-distortion-aware bit-plane reweighting scheme for the non-exact regime.

Key results:

• Under a fixed parameter budget, increasing recurrent unrolling from feed-forward (R=1) to R=5 raises PSNR from 39.7 dB to 63.4 dB at the same training step (500 iterations).
• On Kodak24/Set5/DIV2K-100/FFHQ-600 image fitting, the recurrent+binarized model (609K params, 100 iterations) beats 1000-iteration results of all learnable-frequency baselines (FourierNet, GaborNet, iSIREN), e.g. 58.16 dB/0.9997 SSIM on Set5 with only 0.78K bit errors, and reaches exact (∞ PSNR, zero bit error) reconstruction in ~322-537 iterations on average across datasets.
• Removing the recurrent bias term is critical: with bias enabled, PSNR at R=5 recurrence drops to 78.10 dB vs. 90.28 dB without bias (Kodak24, 792K params).
• Ablation isolating contributions: feed-forward FINER baseline gets 42.15 dB; adding recurrence alone jumps to 64.19 dB; adding binarized supervision on top achieves exact (∞ dB, 0 bit errors) reconstruction.
• Transfers favorably to other tasks: improves NeRF on LLFF scenes (e.g. Flower 23.71→24.54 dB PSNR, LPIPS 0.4145→0.2934), improves pretrained LIIF-based arbitrary-scale super-resolution PSNR/SSIM/LPIPS at matched ~50K decoder parameters, and produces sharper SDF surface reconstruction than SIREN on the Stanford Armadillo under the same 2K-epoch budget.
• Wall-clock efficiency: reaches 42.84 dB in 6.52s, already exceeding the best baseline's 1000-iteration result, and hits exact reconstruction after 636 iterations (34.17s) on Kodak24.

Why it matters / caveats: The paper reframes recurrence as a parameter-free way to expand an INR's effective spectral bandwidth, offering a spectral (rather than purely empirical) justification for weight-tied depth, and demonstrates plug-in transfer across image fitting, super-resolution, NeRF, and SDF tasks. The authors note gains are not consistent across all model sizes and diminish under severe capacity constraints, and each recurrent step adds per-iteration compute even though wall-clock fidelity improves overall.

Authors: Boyuan Wang, Yue Zhang, Xutao Xue, Xueyu Song, Yu Sun

Problem: Generalizable robotic manipulation policies need large-scale, physically plausible tabletop scene data, but existing text-to-layout or procedural synthesis methods produce physically implausible, overly sparse layouts that fail to capture the dense clutter of real human environments.

Method: TableVerse is a fully automated Real2Sim pipeline that reconstructs simulation-ready tabletop scenes deterministically from single-view, in-the-wild internet images rather than hallucinating layouts. It combines open-vocabulary hybrid object detection (Seed-1.8 + SAM2 masks + SAM3D mesh reconstruction, with composite/container objects assembled via isolated MuJoCo free-fall simulation), metric-scale 6-DoF pose registration via Depth Anything 3 point clouds and coarse-to-fine ICP, a novel Layout-Consistent Collision Rectification (LCCR) module that disentangles intersecting meshes through hierarchical contact grouping, radial-graph horizontal rectification, and vertical disentanglement before a final MuJoCo physics stabilization pass, and a task-conditioned trajectory generation framework (GraspGen for 6-DoF grasps + cuRobo GPU-accelerated motion planning) to synthesize collision-free pick-and-place demonstrations. Scene curation and annotation (usability filtering, label error checking, physical property prediction, quality scoring, relabeling, and pick-and-place task generation) is driven by Gemini 2.5 Pro over multi-view renderings.

Key results:

• TableVerse-100K dataset: 100,000 unique physically consistent tabletop environments, ~1M object instances, 35K+ semantic categories, and 1,700+ high-resolution texture maps for domain randomization.
• On a 100-sample in-the-wild benchmark, TableVerse achieves 0.0% Scene Collision Rate versus 90.0% (MIDI), 81.0% (SAM3D), and 72.0% (SceneMaker).
• TableVerse leads on MLLM-based GPT-Score sub-dimensions: Layout Fidelity 7.14, Visual Quality 7.08, Geometry Quality 7.03, and best Average Rank 1.38 (vs. 2.67–3.22 for baselines).
• Ablation on the LCCR module: raw "Direct" alignment yields 79.0% collision rate; adding LCCR drops this to 0.0%; adding the final MuJoCo simulation stage retains 0.0% while closing floating/micro-gap artifacts.

Why it matters / caveats: By grounding scene synthesis in real observations rather than generative hallucination, TableVerse offers a much larger and more physically faithful data source for training generalizable manipulation policies than prior synthetic pipelines. The authors note limitations from SAM3D's fidelity on low-resolution/occluded container contents and the computational cost of per-object 3D generation, which they plan to address via batched one-shot scene-level inference.

Authors: Xiao Yu, Baolin Peng, Ruize Xu, Hao Zou, Qianhui Wu, Hao Cheng, et al.

Problem: Open-source RL/SFT stacks cannot natively train modern agents end-to-end inside the stateful, multi-process inference harnesses (e.g., Claude Code, Codex, OpenClaw) they are actually deployed with, forcing researchers to train on simplified harness reimplementations that mismatch real deployment.

Method: OpenForgeRL pairs a lightweight proxy that intercepts a harness's model calls, routes them to the RL framework's inference engine (e.g., vLLM), and reconstructs the intercepted prompt-response pairs into standard trajectories (s, a, r) consumable by any RL codebase (e.g., veRL, trained with GRPO), with a Kubernetes orchestrator (built on Orchard) that runs each rollout in its own remote container on cloud providers like Azure to scale rollouts independently of training nodes. It also includes a propose-prune-build-test-refine pipeline to synthesize verified SFT/RL tasks and Dockerized environments in data-scarce domains like daily tool-use and computer-use. Models are trained via SFT distillation from a stronger teacher (MiniMax-M2.5 for Claw, Kimi-K2.5 for GUI) followed by GRPO-based RL.

Key results:

• OpenForge-Claw (Qwen3-30B-A3B backbone, trained on ReACT, ZeroClaw, OpenClaw, Codex with only 343 RL tasks) reaches 31.7 pass³ / 55.9 pass@3 on ClawEval, 33.7 pass@1 on QwenClawBench, and 28.1 on MCPAtlas — outperforming similar-size baselines (e.g., Qwen3-30B-A3B-Thinking: 14.3/39.8/21.8/12.4) and SFT-only ablation on every benchmark.
• OpenForge-GUI (8B, trained on Kimi-Agent and Molmo-Web with only 2.5k SFT / 900 RL browser tasks) reaches 37.7 on OSWorld-Verified, 63.0 on Online-Mind2Web, and 72.3 on WebVoyager, beating similarly-sized specialized models (e.g., MolmoWeb-8B trained on 200k+ tasks scores only 35.3/78.2 on the two web benchmarks) and matching/exceeding some much larger VLMs.
• Harness choice matters a lot: on ClawEval, simpler harnesses that support custom tools (ReACT, ZeroClaw) reach much higher performance (SFT+RL: 45.1/48.5 pass@1) than more advanced but less customizable ones (OpenClaw: 20.9, Codex: 32.5); RL gains are large everywhere except OpenClaw.
• Cross-harness training generalizes: a model trained only on ZeroClaw still improves on unseen OpenClaw (+3.3) and Codex (+4.6), while training jointly on ZeroClaw+OpenClaw+Codex gives the best results across all three harnesses (e.g., +20.3 on Codex vs. base).
• RL shifts tool usage from generic shell calls (22.6% to 13.9% of calls) toward dedicated service tools and improves self-verification, tool coverage, and multi-step plan completion, but error recovery remains the weakest capability even after RL.

Why it matters / caveats: The framework lets researchers train and study agents in their real deployment harnesses rather than simplified reimplementations, closing a key gap between open and proprietary agent training, and offers empirical evidence that harness design strongly shapes learnability. Caveats: gains from RL are highly harness-dependent (weak on OpenClaw), and critical reliability behaviors like error recovery remain poorly learned even with RL, suggesting the approach alone doesn't solve all agentic reliability issues.

Authors: Xianfu Cheng, Shiwei Zhang, Jiyu Zhao, Jian Yang, Xinyuan Wang, Ming Zhou, et al.

Problem: Existing financial QA benchmarks focus on narrow tasks (table QA, numerical extraction, short-context retrieval) and cannot evaluate whether LLM-based RAG and agentic systems can perform the multi-step, cross-layout, document-grounded reasoning that real financial analysts do.

Method: The authors build Finance-LaTeX SKILL, a multi-agent workflow that combines expert financial knowledge, evidence planning, layout-aware LaTeX document generation, and multi-channel (LLM/web/MCP/harness) verification to synthesize 2,000 professional financial documents and 6,000 QA pairs for development use. From a separate, curated pipeline they construct FinanceComplexQA, a held-out bilingual (Chinese/English) benchmark of 2,026 deep-research QA tasks over 1,009 real financial documents spanning 8 scenario types (e.g., corporate reports, investment strategy, bank statements, compliance audits) and 9 task labels (comparison, multi-hop reasoning, planning, summarization, etc.), scored via an Agent-as-a-Judge protocol across accuracy, numeric correctness, evidence coverage, faithfulness, and completeness.

Key results:

• Evaluated 6 systems (LightRAG, PageIndex, Codex-style and Claude Code-style agents) across 7 LLMs (GPT-5.4/5.5, Claude-Sonnet-5, Qwen3.5/3.7, DeepSeek-V4-Flash).
• Layout-aware PageIndex beats plain LightRAG by 9.73 points on Chinese overall average (72.15 vs 62.42) and 6.98 points on English (66.90 vs 59.92); on Chinese Investment Strategy reports the gap reaches +23.32 (64.78 vs 41.46).
• Claude Code with Sonnet-5 achieves the best overall Chinese scene score (76.01) and best overall English scene score (69.39); Codex with GPT-5.5 has the strongest closed-source aggregate task averages (60.63 CN / 62.97 EN), while Codex with DeepSeek-V4-Flash leads open-source settings (60.44 CN / 61.55 EN).
• Agentic systems cost far more: LightRAG uses ~12.8k tokens/8.6s per question vs PageIndex's 15.6k/11.9s, while agentic systems require 31.4k–45.8k tokens and 22.8–50.6s.
• Common failure modes identified: numeric drift, evidence omission, layout confusion, over-synthesis, and weak planning (e.g., one system scores 83.54 faithfulness but only 32.77 coverage on Chinese planning, showing faithful-but-incomplete answers).

Why it matters / caveats: The benchmark shows no single system dominates across tasks/scenarios, that layout-preserving retrieval and agentic reasoning offer complementary strengths, and that quality gains from agentic tool use come with substantial cost overhead — arguing for cost-aware routing and explicit evidence/calculation verification in future financial agents. The Agent-as-a-Judge protocol may inherit evaluator bias, and the synthetic Finance-LaTeX data is for development only, not part of the held-out evaluation set.

Authors: Vedant Shah, Onkar Susladkar, Tushar Prakash, Kiet A. Nguyen, Tianjiao Yu, Adheesh Juvekar, et al.

Problem: Controllable image-to-video generation lacks a way to specify precise multi-object interactions, since text prompts are ambiguous and trajectory/motion-control inputs require users to draw accurate per-object tracks that scale poorly and become ambiguous under occlusion.

Method: GraphVid represents user intent as a directed interaction scene graph (nodes = detected entities with fused visual/text/bbox features from Qwen3-VL; edges = open-vocabulary interaction types like push, pull, hold, encoded with Qwen3-Embedding). An Edge-Aware Graph Reasoning module (GINEConv-based GNN) propagates messages conditioned on directed edge attributes to produce interaction-aware node embeddings, which are projected via an MLP into conditioning tokens fed as encoder hidden states to a frozen LTX-Video Diffusion Transformer backbone, adapted only through LoRA modules (rank 128) in the Q/K/V/output projections; training uses a flow-matching objective with only the GNN, adapter MLP, and LoRA weights updated. The authors also curate GraphVid-Bench, ~27K interaction-centric video clips (81 frames, 16fps) with structured relational graph annotations (avg. 7.76 nodes / 4.85 edges per graph).

Key results:

• Uses only 0.6B trainable parameters and 27K training clips, vs. e.g. Wan-Move (14.5B params, 2M clips) and Motion-I2V (1.2B params, 10M clips), and is the fastest at inference (200s vs. 1800s for Wan-Move, 1200s for Tora, 1000s for WISA).
• Vs. Motion-I2V: FID improves 28.32→17.02 (-39.9%), FVD 159.32→99.42 (-37.6%), PSNR 9.87→15.98, SSIM 0.38→0.61.
• Vs. WISA (physics-centric text baseline): FID 25.98→17.02 (-34.5%), FVD 107.89→99.42 (-7.8%), PSNR +5.9%, SSIM +15.0%, EPE 4.1→2.9 (-29.3%).
• On multi-object MoveBench subset, GraphVid achieves best FID (49.45 vs. next-best FlashMotion 55.03, -10.1%) and best FVD (291 vs. 311, -6.4%) among comparable-scale methods, while using ~21.7x fewer trainable params than FlashMotion and ~23x less training data than Tora.
• Ablations: capping graph conditioning at 30 nodes outperforms larger padding (128/256 nodes degrade FID/FVD due to attention dilution); full graph with edge-text semantics beats topology-only graph (FID 17.02 vs 17.52) and beats plain text+image LTX baseline (FID 20.04); backbone-swap to Wan 2.2 (5B) yields comparable performance (FID 17.29), showing the graph interface is backbone-agnostic.

Why it matters / caveats: Structured interaction graphs offer a more scalable and interpretable control interface than dense trajectory/optical-flow supervision, achieving competitive or better quality with far less data and compute; however, GraphVid still trails the much larger Wan-Move (14.5B params, 2M videos) on absolute metrics, and results rely on the authors' own MoveBench interaction-centric subset and dataset curation, so cross-benchmark generalization outside this evaluation setup is not established in the excerpted text.

Authors: Haoru Tan, Wang Wang, Sitong Wu, Xiuzhe Wu, Yangtian Sun, Chirui Chang, et al.

Problem: Existing dataset distillation methods align intermediate training "process" surrogates (gradients or trajectories) between synthetic and real data, but matching this process does not guarantee that the resulting trained model actually matches the outcome (final parameters/performance) of training on real data.

Method: Influence Matching (Inf-Match) instead learns a compact synthetic set S whose removal-and-addition "influence" on final model parameters matches that of the real dataset D, formalized as minimizing ||I−D + I+S|| where influence terms are the parameter shift from removing/adding data. A differentiable, linear-time influence estimator is derived by unrolling SGD optimization dynamics and applying a first-order Taylor approximation with Pearlmutter's Hessian-vector-product trick, avoiding inverse-Hessian computation and convexity assumptions (with a proven error bound polynomial in training steps T). The algorithm initializes synthetic images from real data with soft labels from a pretrained checkpoint, then updates images and learnable soft labels via gradient descent on the influence-matching objective, sampling minibatches and checkpoints (with a DATM-style easy-to-hard time-step schedule) for efficiency.

Key results:

• CIFAR-10: 72.5% (IPC=10) and 78.1% (IPC=50), ~0.7% over NCFM; 49.9% at IPC=1 (new high for extremely low IPC).
• CIFAR-100: 49.3% (IPC=10) and 57.4% (IPC=50), the latter beating NCFM by 2.7%.
• Tiny-ImageNet: 31.5% (IPC=10, +4.7% over NCFM) and 33.8% (IPC=50, +4.2% over NCFM).
• Cross-architecture generalization (CIFAR-100, IPC=50): 45.4%–57.4% across ConvNet/ResNet-18/VGG/AlexNet, outperforming DATM and NCFM in every architecture.
• Flickr30K vision-language distillation: outperforms NCFM/DATM on I2T/T2I recall@1 across the 200–1000 synthetic-sample range, by roughly 2.5% average.
• Ablation (CIFAR-100, IPC=50): base 52.2% → +real-data init 53.7% → +sampling schedule 55.0% → +learnable labels 57.4% (full model), vs. DATM 55.0% and NCFM 54.7%.

Why it matters / caveats: The influence-matching formulation offers a more principled, outcome-aligned objective than heuristic process-matching (gradient/trajectory matching), with a theoretically bounded, Hessian-free estimator that is practical at scale, and it generalizes beyond image classification to vision-language retrieval distillation. Caveat: convergence is slower than trajectory-matching baselines like MTT (per the paper's own learning-curve visualization), and code was not yet available at time of writing (promised via GitHub).