Last 7 Days (July 31 – August 06, 2026)
We construct unambiguous DNFs having width $O(n)$ but $0$-certificate complexity $Ω(n^2)$. By utilizing the special structure of these DNFs, we prove a lifting theorem with a constant-sized gadget that lifts the DNF to a communication problem, while losslessly translating the separation in certificate complexity to a separation in communication complexity. This leads to an optimal refutation of the Alon-Saks-Seymour conjecture, as well as an optimal communication lower bound for the Clique versus Independent Set problem, improving the previous results of Balodis, Ben-David, Göös, Jain and Kothari (FOCS 2021, SICOMP 2023) by several doubly logarithmic factors. As further applications of our construction to query complexity and learning theory, we exhibit: (a) a family of Boolean functions that has an optimal quartic separation between certificate complexity and approximate degree, and (b) a sample compression lower bound of $Ω(\sqrt{\log c})$ for multiclass concept classes over $c$ labels.
Primary: Stanford University
All Institutions: Stanford University
This paper provides an optimal refutation of the Alon-Saks-Seymour conjecture and establishes new lower bounds in communication and query complexity through novel constructions of unambiguous DNFs and a constant-sized lifting gadget. The work represents a significant theoretical contribution to machine learning theory, offering deep insights into the fundamental limits of learning and computation, with rigorous proofs that advance the state of the art in complexity theory.
The paper presents a significant theoretical advance in computational complexity and learning theory. The core methodology involves constructing unambiguous Disjunctive Normal Forms (DNFs) with specific width and certificate complexity properties. The authors then employ a lifting theorem with a constant-sized gadget to translate these query complexity separations into communication complexity lower bounds. This approach is mathematically rigorous and leverages deep connections between boolean function analysis, communication complexity, and learning theory. The construction of the DNFs and the proof of the lifting theorem constitute a novel methodological contribution to the field of theoretical computer science.
As a theoretical computer science paper, this work does not contain empirical experiments, datasets, or benchmarks in the traditional machine learning sense. The "results" are mathematical proofs establishing lower bounds and separations. Therefore, experimental evaluation is not applicable. The validity rests entirely on the correctness of the proofs.
Theoretical papers are reproducible in the sense that their proofs can be verified. The paper provides sufficient detail in the abstract and structure (implied by the section headers) to allow for verification by experts in the field. However, without access to the full text's proofs, one must rely on the abstract's claims. The acknowledgements mention interaction with LLMs, which is a transparency note but does not affect the mathematical reproducibility of the results.
The primary limitation is that this is a theoretical result. While it has profound implications for understanding the limits of learning and computation, it does not provide immediate algorithms or practical tools for practitioners. The "applications" mentioned (sample compression lower bounds, approximate degree separation) are also theoretical bounds. Furthermore, the reliance on LLMs for idea development, while acknowledged, is a minor concern regarding the originality of the *ideation* process, though the *execution* and *proof* remain the authors' responsibility.
This paper has high impact within the theoretical machine learning and complexity theory communities. Refuting the Alon-Saks-Seymour conjecture is a major milestone. The improved lower bounds for Clique vs. Independent Set and the new separations in query complexity provide fundamental insights into the hardness of learning and computation. It sets new benchmarks for what is achievable in certificate complexity and communication complexity, guiding future research in these areas. This paper provides an optimal refutation of the Alon-Saks-Seymour conjecture and establishes new lower bounds in communication and query complexity through novel constructions of unambiguous DNFs and a constant-sized lifting gadget. The work represents a significant theoretical contribution to machine learning theory, offering deep insights into the fundamental limits of learning and computation, with rigorous proofs that advance the state of the art in complexity theory.
Modern GPUs rely on private per-SM L1 caches and a shared L2 cache, but this organization obscures cross-SM reuse: an L1 miss is typically forwarded to L2 even when the requested line already resides in a peer L1 cache, leading to redundant L2 access. Prior GPU L1-sharing designs attempt to recover such reuse through exact or broad remote-hit searches, which become increasingly difficult to scale and can interfere with the critical L1 miss path under high concurrency. %miss handling as more caches participate and more misses arrive concurrently. We observe that eliminating redundant L2 accesses does not require exact, chip-wide knowledge of private L1 contents. Instead, it requires only sufficient visibility to sharply narrow down a small set of candidate caches, leaving exact confirmation to a much smaller number of L1s. Based on this insight, we propose C2P-Cache, a scalable GPU L1-sharing mechanism that transforms remote-hit discovery from a chip-wide exact search problem into a lightweight filtering-and-confirmation process. C2P-Cache maintains compact Bloom-filter-based snapshots of private L1 tags, performs parallel chip-wide candidate filtering, and selectively probes only a small number of likely peer caches. To sustain high concurrency, C2P-Cache organizes filtering as bit-sliced matching over a banked and replicated snapshot matrix, enabling efficient, parallel processing of many concurrent misses without interfering with normal L1 accesses. Across a wide range of GPU workloads, C2P-Cache improves instructions per cycle (IPC) by up to 49.7\% and by 23.5\% on average for applications with high remote-L1 reuse and strong sensitivity to L2 latency, demonstrating that lightweight, scalable filtering can effectively unlock cross-SM reuse with modest overhead.
Primary: National University of Defense Technology
All Institutions: National University of Defense Technology
C2P-Cache introduces a scalable GPU L1 cache sharing mechanism that utilizes Bloom-filter-based snapshots to prune remote-hit candidates, significantly reducing redundant L2 accesses and improving IPC for memory-intensive workloads while maintaining low overhead and high concurrency.
The paper proposes C2P-Cache, a hardware mechanism for GPU L1 cache sharing. The core innovation is replacing exact, chip-wide remote hit searches with a probabilistic filtering stage using Bloom filters. Specifically, it maintains a "Snapshot Matrix" of Bloom filter states for all SMs. When an L1 miss occurs, the system performs a Boolean matrix multiplication (logical AND reduction) between the miss query (Access Matrix) and the Snapshot Matrix to identify candidate SMs. Only these candidates are probed for exact tag confirmation. This transforms a high-latency, high-contention search problem into a lightweight filtering-and-confirmation pipeline. The design includes specific optimizations for high concurrency, such as bit-sliced matching and a banked/replicated Snapshot Matrix organization to handle worst-case lookup demands without interfering with normal L1 accesses. The methodology is sound, leveraging well-known probabilistic data structures (Bloom filters) in a novel architectural context (GPU cache hierarchy) to solve a specific scalability bottleneck.
The evaluation is conducted using Accel-Sim, a standard cycle-level GPU simulator. The authors evaluate 24 workloads from ISPASS, Rodinia, Parboil, PolyBench, and Pannotia. They compare C2P-Cache against a baseline (no sharing) and three prior works (ATA, CCD, RING). Results show significant IPC improvements (up to 49.7%, avg 23.5% for sensitive workloads) and substantial L2 access reduction (avg 46.6%). The paper provides a thorough sensitivity analysis covering BF parameters, matching latency, remote return latency, and SM scaling. The results are consistent and demonstrate that C2P-Cache outperforms prior art in both performance and scalability, particularly as the number of SMs increases. The inclusion of power and area overhead estimates adds credibility to the practical feasibility assessment.
The paper provides detailed descriptions of the hardware components (BF Engine, Snapshot Matrix organization, addressing schemes) and simulation parameters (latencies, BF sizes, hash functions). The use of Accel-Sim and standard benchmarks allows for potential reproduction. However, the specific implementation details of the BF hash functions and the exact timing models for the Snapshot Matrix SRAM (modeled via CACTI) are abstracted. While sufficient for architectural researchers to reproduce the study, full bit-level reproducibility would require access to the specific Accel-Sim fork and CACTI configuration files, which are not explicitly linked but are standard practice in the field.
The primary limitation is the reliance on probabilistic filtering, which introduces false positives (unnecessary probes) and false negatives (missed reuse opportunities). The paper acknowledges this and shows that the impact is manageable, but in extreme cases, false positives can add latency. Additionally, the design assumes a specific GPU microarchitecture (banked L1s, specific interconnect) which may not generalize to all GPU designs without adaptation. The "Snapshot Matrix" consumes significant on-chip SRAM (estimated 40KB logical, though physical implementation details vary), which might be a constraint for smaller GPUs. The venue date (2026) is an anomaly, suggesting this might be a very recent acceptance or a metadata error, but the technical content is current.
This work addresses a fundamental scalability issue in modern GPUs: memory bandwidth and latency bottlenecks caused by private L1 caches. By enabling efficient cross-SM data reuse, C2P-Cache can improve performance for a wide range of parallel applications, including AI/ML workloads (Transformers, CNNs) and HPC applications (stencils, linear algebra). This contributes to the broader goal of making GPU architectures more efficient and scalable as core counts increase. It also highlights the value of probabilistic data structures in hardware design for system-level optimization. C2P-Cache introduces a scalable GPU L1 cache sharing mechanism that utilizes Bloom-filter-based snapshots to prune remote-hit candidates, significantly reducing redundant L2 accesses and improving IPC for memory-intensive workloads while maintaining low overhead and high concurrency.
Modern vision language models (VLMs) turn high-resolution images into long sequences of visual tokens. Every token traverses the language decoder and persists in its prompt KV cache, inflating inference cost and motivating aggressive visual compression. Existing score-based methods assign each token an independent importance score and retain the Top-K. However, text queries consume collective, signed attention messages from the visual population, not isolated patches. Consequently, equally sized Top-K sets can repeatedly cover one salient region, omit sparse but complementary evidence and discard information carried by the removed population. We therefore formulate faithful visual compression as constructing a compact coreset for decoder messages, and introduce our training-free Grounded Message Coreset Pruning (GMC) which jointly allocates support across query-grounded, appearance, and coordinate-aware evidence, then transports discarded states into selected representatives at their original multimodal positions before physical compaction and native attention resume. This decomposes faithful compression into two coupled components, including selecting carriers that cover the required message modes and realizing the signed population message on those carriers. We further derive bounds connecting their errors to signed-message distortion, visual innovation, and candidate-margin stability. Experiments across multiple VLM families and diverse benchmarks demonstrate strong performance, with GMC-H2 retaining 97.78% Full-relative mean capability on Qwen2.5-VL-7B using 80.2% fewer visual tokens, while GMC-L16 reaches 100.36%. Controlled interventions verify that collective support and population realization jointly drive these gains.
Primary: Cardiff University
All Institutions: Cardiff University, Chinese Academy of Sciences, Foundation Model Research Center, Institute of Automation, School of Engineering, School of Future Technology, University of Chinese Academy of Sciences, Wuhan AI Research
[One sentence main contribution]. [The paper introduces GMC, a training-free visual token compression method that formulates faithful compression as constructing a coreset for decoder messages, jointly optimizing support allocation and population realization to preserve signed, complementary evidence, achieving state-of-the-art fidelity with significantly reduced token counts across multiple VLM families.]
The paper proposes "Grounded Message Coreset Pruning" (GMC), a training-free method for compressing visual tokens in Vision-Language Models (VLMs). The core theoretical contribution is reframing token selection not as independent importance scoring, but as constructing a "coreset" for the collective, signed attention messages received by the language decoder. The method involves two coupled steps: (1) Support Allocation: Using a facility-location objective with query-grounded, appearance, and spatial clients to select a subset of tokens that cover complementary evidence modes; (2) Population Realization: Transporting the hidden states of discarded tokens to the selected representatives, preserving their original multimodal coordinates and signed contributions before native attention resumes. The authors provide theoretical bounds connecting the compression error to signed-message distortion and visual innovation. The approach is technically sophisticated, moving beyond simple redundancy reduction to address the specific mechanics of cross-attention in VLMs.
The evaluation is extensive, covering multiple VLM families (Qwen2.5-VL-7B, LLaVA-1.5-7B) and diverse benchmarks (POPE, AMBER, HallusionBench, CHAIR, TextVQA, ChartQA, MME, MMBench, GQA). The results demonstrate that GMC retains significantly higher fidelity than state-of-the-art baselines (VisionZip, MMTok) at aggressive compression ratios (e.g., retaining ~98% capability with 80% fewer tokens). The paper includes rigorous ablation studies isolating the effects of support allocation vs. population realization, and controlled interventions verifying the theoretical claims. The performance gains are consistent across discriminative and generative tasks, and the method shows strong transferability across different model architectures without retraining.
The paper provides detailed descriptions of the algorithm, including the facility-location solver, the transport mechanism, and the coordinate preservation strategy. It mentions frozen probes and specific settings in the appendix (referenced but not fully visible in the provided text snippet, though standard for such submissions). The training-free nature of the method enhances reproducibility as it requires no additional training data or parameter updates. The use of standard benchmarks and open-source base models facilitates independent verification.
The method introduces computational overhead during the pruning phase due to the facility-location optimization and state transport, although this is a one-time prefill cost. The theoretical bounds, while insightful, rely on assumptions about Lipschitz continuity and submodularity that may not hold perfectly in deep non-linear transformers. The paper focuses on static image inputs; the behavior with video or highly dynamic sequences is less explored. Additionally, the "appearance" and "spatial" clients rely on fixed heuristics or banks which might require tuning for specific domains (e.g., dense text vs. open scenes).
This work addresses a critical bottleneck in deploying large VLMs: inference cost and memory usage. By enabling faithful compression without retraining, it lowers the barrier for running powerful multimodal models on edge devices or in high-throughput applications. The theoretical framework of "message coresets" could inspire similar approaches for other sequence-to-sequence or multimodal architectures where collective context matters. It also highlights the importance of preserving signed, complementary information in attention mechanisms, which may influence future model design and pruning strategies. [One sentence main contribution]. [The paper introduces GMC, a training-free visual token compression method that formulates faithful compression as constructing a coreset for decoder messages, jointly optimizing support allocation and population realization to preserve signed, complementary evidence, achieving state-of-the-art fidelity with significantly reduced token counts across multiple VLM families.]
Vision offers a critical axis for advancing foundation models, driving a shift towards natively unified multimodal pretraining. Despite this momentum, the design space and the fundamental mechanisms of how modalities interact during unified training remain underexplored. We provide empirical clarity through a systematic exploration of multimodal pretraining. Our controlled experiments on both synthetic and large-scale real-world datasets yield four key insights into the physics of multimodal pretraining: (i) Knowledge Flow: We disentangle how language, visual understanding, and visual generation transfer knowledge across modalities, revealing distinct patterns of influence and asymmetry; (ii) Synergy vs. Competition: We show that data "complexity" largely determines whether modalities are synergistic, identify architectural choices that promote synergy: such as shared attention and normalization with modality-specific feed-forward layers, and find that these behaviors generalize across different visual tokenizer designs; (iii) Early Unification: Unifying modalities from the very early stages and training them jointly is shown to be more effective than late alignment or sequential training. This process uncovers a vision laziness phenomenon, where delayed integration leads models to rely on language priors; (iv) Recipes: We derive efficient pretraining recipes that achieve strong generative performance using only 5% of the compute budget. These core findings are subsequently validated at scale by training multiple 13.5B MoE models on 2T tokens. We hope this study provides a principled foundation for understanding and scaling multimodal pretraining.
Primary: Unknown (Affiliations not explicitly listed in the provided text snippet, though author names suggest industry/academic collaboration)
All Institutions: Unknown
This paper makes a significant empirical contribution to the understanding of unified multimodal pretraining, providing robust, scalable evidence that challenges existing heuristics and offers practical guidelines for building more capable foundation models.
The paper employs a rigorous empirical methodology to dissect the "physics" of unified multimodal pretraining. It utilizes controlled ablation studies on both synthetic (CLEVR) and real-world (SSTK, DCLM) datasets to isolate specific mechanisms: knowledge flow asymmetry, the role of task complexity in synergy vs. competition, and the temporal dynamics of early vs. late unification. The architectural analysis, specifically the isolation of Feed-Forward Networks (FFNs) versus Attention/Normalization layers, provides a granular understanding of where modality-specific capacity is needed versus where shared representation is beneficial. The use of synthetic data to establish causal links for concept transfer is a strong methodological choice that mitigates the confounding factors of web-scale data.
The experimental design is comprehensive, spanning from small-scale controlled experiments (1.5B parameters) to large-scale validation (13.5B MoE models on 2T tokens). The evaluation covers a wide range of benchmarks for visual understanding (VQA, OCR, spatial reasoning) and generation (GenEval, DPG-Bench, CLIPScore). The results are consistent and well-supported by the data: (1) Language acts as a universal booster for vision, but vision generation does not reciprocally boost language; (2) Simple tasks promote synergy, while complex tasks induce capacity competition; (3) Early unification prevents "vision laziness," where late alignment causes models to rely on language priors at the expense of visual fidelity. The large-scale training of 13.5B MoE models adds significant weight to the conclusions, demonstrating that these insights scale.
The paper provides detailed hyperparameters, model architectures (Llama-3 like, Transfusion framework), and data sources (DCLM, SSTK). The synthetic CLEVR setup is well-described, allowing for replication of the concept transfer studies. The use of fixed random seeds and specific optimization settings (AdamW, cosine decay) further aids reproducibility. However, the exact composition of the "SSTK" dataset and the specific codebase for the 13.5B model training are not fully detailed in the text, which is typical for arXiv preprints but slightly hinders immediate exact replication of the largest scale experiments.
The study focuses primarily on decoder-only Transformer architectures with discrete next-token prediction for text and flow matching for vision. The generalizability to other architectures (e.g., encoder-decoder, pure diffusion models without text) is not explored. The synthetic CLEVR study, while controlled, may not fully capture the complexity of real-world visual concepts. Additionally, the "vision laziness" phenomenon, while identified, is described primarily through empirical metrics; a deeper theoretical explanation of why late alignment leads to this specific failure mode could be strengthened. The paper also notes that visual generation yields neutral effects on language, but the mechanisms behind this lack of backward transfer are less deeply explored compared to the forward transfer.
This paper provides actionable "recipes" for training unified multimodal models, challenging the prevalent late-alignment paradigm. By demonstrating that early unification and specific architectural choices (shared attention, split FFNs) are critical for performance, it offers a principled foundation for future model development. The insights into modality synergy and competition help practitioners optimize compute budgets and data mixing strategies. The finding that simple tasks can boost performance in other modalities suggests new data curation strategies for efficient pretraining. This paper makes a significant empirical contribution to the understanding of unified multimodal pretraining, providing robust, scalable evidence that challenges existing heuristics and offers practical guidelines for building more capable foundation models.
Clinical decision support is moving toward committees of language-model agents deliberating on a shared workspace. We ask whether such committees can be gamed by shortcuts, cues a benchmark rewards but a clinician would ignore. Across seven cohorts on six public datasets spanning text (MedQA-USMLE, MedMCQA, MIMIC-CXR reports), imaging (NIH ChestX-ray14, MIMIC-CXR-JPG, CheXpert) and tabular ICU records (SUPPORT2), Gemini committees resist these cues in isolation (flip 5-16%), yet a socially plausible shortcut spreads: when two peers assert the same wrong answer, the holdout under test adopts it in 38% of cases, as does a false "pre-screen" system flag, on both capability tiers. Of three oversight agents, a gate cannot separate adoption from honest agreement (false-positive rate 100%); a same-lineage judge reading only the transcript flags adoption on text (precision 100%, recall 93%) but collapses onto the gate in imaging; a referee that privately re-queries the holdout transfers to imaging (77-88% precision, 13-21% false-positive rate). Tripling a cue's visual salience does not move contagion, whereas a second peer voice raises it by half again. Gaming a hidden rubric is near-silent: only 1/10 text and 1/134 imaging drifters name the rubric they moved toward. What games a committee is social plausibility, and only a referee independent of self-report catches it. Code: https://github.com/criticaldata/benchmaxxing
Primary: MIT Critical Data
All Institutions: MIT Critical Data, Georgia State University, Politecnico di Milano, American International School Vienna, Boston University, Technische Hochschule Lübeck, Substrate Labs, University of British Columbia, Dartmouth College, University of Maryland, McGill University, University of Texas at Austin, King's College London, Beth Israel Deaconess Medical Center
This paper provides a rigorous empirical demonstration of social contagion of errors in multi-agent clinical AI systems, introducing a novel "referee" oversight mechanism that outperforms traditional judge-based evaluations in detecting benchmark gaming and shortcut cascades.
The paper introduces a novel evaluation framework called DOJO (Distributed Open Justice Oversight) to detect "benchmaxxing" in multi-agent clinical systems. The core methodological innovation is the "referee agent," which performs a private re-query of the holdout agent to distinguish between genuine reasoning and social conformity (shortcut cascades). This contrasts with standard "LLM-as-a-judge" approaches that rely solely on transcript analysis. The experimental design involves creating controlled environments where peer agents assert incorrect answers to observe if a holdout agent adopts them, effectively measuring social contagion of errors. The approach is theoretically sound and addresses a critical gap in evaluating agentic systems: the difference between isolated capability and collaborative reliability.
The authors conduct extensive experiments across seven cohorts on six public datasets (MedQA, MedMCQA, MIMIC-CXR, NIH ChestX-ray14, CheXpert, SUPPORT2). Key findings include: 1) Single agents are largely resistant to visual/textual shortcuts in isolation. 2) Social pressure from two peers asserting the same wrong answer causes adoption rates to spike to 38-61%. 3) Standard oversight mechanisms (gate, same-lineage judge) fail to detect this adoption, while the referee agent succeeds. 4) Self-reporting by agents is unreliable for detecting reward hacking. The results are robust across modalities (text, imaging, tabular) and demonstrate that social plausibility, not just cue strength, drives errors. The statistical analysis is rigorous, using exact McNemar tests and bootstrap confidence intervals, though some cohort sizes (e.g., NIH cascade n=35) are small.
The paper provides a GitHub repository. However, the authors explicitly note reproducibility challenges: MIMIC-CXR data cannot be fully released due to PhysioNet terms, and the imaging library version affects cue rendering. They provide checksums and a fixed font face to mitigate some issues. The use of a content-addressed cache for API calls aids in replaying specific runs. Despite these efforts, full reproducibility is hindered by data access restrictions and API dependencies.
The study is limited by the small sample sizes in some imaging cascade experiments (n=35 for NIH). The reliance on Gemini models means findings may not generalize to other LLM architectures or families. The "referee" agent's effectiveness is specific to the designed setup and may not capture all forms of agentic failure. The paper acknowledges that some metrics were structurally constrained (e.g., recall being a subset relation), which limits the interpretability of certain oversight metrics. Additionally, the social dynamics simulated are simplified compared to real-world clinical committees.
This work has significant implications for the deployment of multi-agent systems in high-stakes domains like healthcare. It highlights the risks of "social contagion" of errors in collaborative AI systems and challenges the assumption that ensemble methods or committee-based approaches automatically improve reliability. The findings suggest that oversight mechanisms must be structurally independent of the decision-making process (e.g., via private re-queries) rather than relying on self-reporting or transcript analysis. This could reshape how benchmarks are designed for agentic systems, emphasizing the need for dynamic, intervention-based evaluation rather than static accuracy metrics. This paper provides a rigorous empirical demonstration of social contagion of errors in multi-agent clinical AI systems, introducing a novel "referee" oversight mechanism that outperforms traditional judge-based evaluations in detecting benchmark gaming and shortcut cascades.
Self-evolving agents increasingly convert interaction histories into reusable skills that persist beyond individual tasks. While prior work studies memory and retrieval poisoning, such attacks only affect agents when poisoned records are retrieved as context. We uncover a new and more fundamental risk: poisoned experiences can be transformed by the agent itself into durable behavioral artifacts. We present SkillJack, the first attack that exploits the experience-to-skill pipeline of self-evolving agents. Instead of directly manipulating runtime context, SkillJack hijacks the agent's own learning process to implant malicious behaviors into its reusable skill repertoire. We identify three key properties of this transformation: sanitization whitewashing, where malicious intent is obscured during skill extraction; cross-layer promotion, where transient experiences become persistent capabilities; and persistence isolation, where the attack survives removal of its original source records. We evaluate SkillJack on two representative systems, SkillX and Anything2Skill, using a shared dataset of 150 trajectories across four policy-risk categories. Results show that skill extraction substantially reduces attack detectability: in SkillX, safety detection drops from 98.5\% for poisoned trajectories to 11.4\% for extracted skills, while Anything2Skill shows a similar effect. Meanwhile, the implanted skills remain effective, achieving attack success rates of 56.2\% and 89.2\% on the two systems, respectively. Furthermore, 80.0\% of skill-mediated attacks persist after deleting the original poisoned records, and some skills unintentionally activate on benign queries. Our findings reveal skill evolution as a new attack surface and motivate provenance-aware skill lifecycle protection. Our code is available at https://github.com/Tencent/AI-Infra-Guard/research/skilljack.
Primary: Tencent Zhuque Lab
All Institutions: Tencent Zhuque Lab
SkillJack presents a critical security analysis of self-evolving agents, revealing that the skill extraction process itself can be hijacked to create persistent, hard-to-detect backdoors, fundamentally changing the threat model for autonomous AI systems.
The paper introduces "SkillJack," a novel attack vector targeting the experience-to-skill pipeline in self-evolving agents. The core methodology exploits the skill extraction process, where the agent's own learning mechanisms are used to "sanitize" and persist malicious behaviors as reusable skills. The authors identify three key properties: sanitization whitewashing, cross-layer promotion, and persistence isolation. This represents a significant conceptual shift from traditional context-poisoning attacks, moving the attack surface to the agent's internal memory consolidation phase. The approach is theoretically sound and addresses a critical gap in the security of autonomous agents that rely on long-term memory and skill reuse.
The evaluation is conducted on two representative systems, SkillX and Anything2Skill, using a dataset of 150 trajectories. The results are compelling and demonstrate the efficacy of the attack: safety detection drops drastically from ~98% on raw trajectories to ~11% on extracted skills, while attack success rates remain high (56-89%). The persistence of the attack after deleting source records (80%) is a strong empirical finding. However, the dataset size (150 trajectories) is relatively small for generalizing to broader agent architectures, and the evaluation is limited to two specific systems. While the findings are robust within this scope, the generalizability to more complex, multi-modal, or larger-scale agents remains to be seen.
The authors provide a code repository link, which enhances reproducibility. The description of the attack vectors and the evaluation metrics is clear. The use of a shared dataset across two systems allows for comparative analysis. However, the specific implementation details of the "sanitization" and "skill extraction" algorithms in SkillX and Anything2Skill are proprietary or complex, which might make exact replication difficult without full access to the underlying agent frameworks.
The primary limitation is the scale of the evaluation. 150 trajectories is insufficient to claim broad security guarantees for the entire class of self-evolving agents. The study focuses on specific policy-risk categories, and the behavior of the attack on more nuanced or adversarial environments is not explored. Additionally, the paper does not extensively discuss the computational overhead or feasibility of defending against such attacks, leaving the practical implications for system designers somewhat open.
This paper has significant broader impact for the AI safety and security community. It highlights a fundamental vulnerability in the design of self-evolving agents, specifically the assumption that experience replay or skill extraction is inherently safe. It motivates the need for provenance-aware skill lifecycle protection and new defense mechanisms that can detect malicious patterns in extracted skills, not just raw interactions. This work will likely influence the design of secure memory modules in future autonomous agents. SkillJack presents a critical security analysis of self-evolving agents, revealing that the skill extraction process itself can be hijacked to create persistent, hard-to-detect backdoors, fundamentally changing the threat model for autonomous AI systems.
Omni-modal large language models (Omni-LLMs) have achieved remarkable performance on audio-visual understanding tasks, but processing long and highly redundant visual and audio token sequences incurs substantial computational overhead, demanding aggressive token compression for efficient deployment. Existing methods often degrade at low token budgets: pre-LLM compression may discard structurally important and globally distributed evidence, whereas inner-LLM compression often underexploits query-conditioned audio-visual collaboration. To address these limitations, we propose OmniPack, a training-free framework that coordinates structural compression before the LLM with task-relevant semantic refinement within the LLM. Before the LLM, OmniPack removes structural redundancy through modality-specific importance, global coverage, and similarity-aware merging. After sufficient multimodal interaction, it further consolidates diverse, task-relevant representations through textual guidance and audio-visual collaboration. Extensive experiments on five benchmarks with three Omni-LLM backbones demonstrate that OmniPack consistently achieves the best performance-efficiency trade-off across diverse retention ratios, outperforming all existing methods. Notably, on Qwen2.5-Omni-7B, OmniPack preserves 98.0% of the original performance while reducing FLOPs to 16.7%, and still retains 92.9% of the original performance with only 6.8% of the original FLOPs.
Primary: Northwestern Polytechnical University
All Institutions: Northwestern Polytechnical University, Peking University, Alibaba Group, Tsinghua University
OmniPack presents a practical and effective training-free solution for token compression in Omni-modal LLMs, offering substantial efficiency gains with minimal performance degradation, though its novelty is incremental and its reproducibility is hindered by the lack of public code.
The paper proposes "OmniPack," a training-free token compression framework for Omni-modal Large Language Models (Omni-LLMs). The methodology is divided into two stages: pre-LLM structural compression and intra-LLM semantic refinement. The pre-LLM stage employs modality-specific importance scoring, global coverage metrics, and similarity-aware merging to reduce redundancy in audio and visual tokens before they enter the LLM. The intra-LLM stage leverages textual guidance and audio-visual collaboration to consolidate representations dynamically. The approach is logically sound and addresses a critical bottleneck in multi-modal LLMs: the quadratic complexity of attention mechanisms with long token sequences. The "training-free" aspect is a significant practical advantage, allowing immediate deployment on existing models without expensive retraining. However, the novelty is somewhat incremental; token pruning and merging techniques (e.g., H2O, SnapKV, LLM-Lion) are well-established in the LLM literature, and adapting them to the multi-modal domain with specific "importance" heuristics is a logical extension rather than a fundamental theoretical breakthrough.
The authors evaluate OmniPack on five benchmarks using three Omni-LLM backbones (including Qwen2.5-Omni-7B). The results demonstrate consistent performance-efficiency trade-offs, with notable claims of preserving 98% performance at 16.7% FLOPs and 92.9% performance at 6.8% FLOPs. These are impressive efficiency gains. The evaluation covers diverse retention ratios, which is good practice. However, the paper relies on existing benchmarks, and the "five benchmarks" likely include standard multi-modal QA datasets. The lack of a new benchmark or a rigorous ablation study isolating the contribution of the "intra-LLM" phase versus the "pre-LLM" phase limits the depth of the empirical claim. The results are strong, but the comparison against other *training-free* methods is crucial; if the baseline methods are less optimized, the gain might be overstated. The FLOP reduction claims are theoretically plausible given the token reduction, but empirical verification of actual wall-clock speedup vs. theoretical FLOP reduction is often missing in such papers.
The paper describes the methodology in sufficient detail to allow reproduction, particularly since it is training-free. The reliance on standard Omni-LLM backbones and open-source compression primitives enhances reproducibility. However, the specific hyperparameters for the "similarity-aware merging" and "global coverage" thresholds are not explicitly detailed in the abstract, and full reproducibility would require access to the codebase, which is not provided in the text. The lack of a public code repository (URL extraction: none) is a negative signal for reproducibility and community adoption.
The primary limitation is the reliance on heuristic-based importance scoring rather than learned, task-specific adapters, which might not generalize perfectly to out-of-distribution tasks or highly specialized domains. Additionally, the "training-free" nature means it cannot exploit the specific latent space of the target model as effectively as fine-tuned compression methods. The paper does not discuss the latency overhead of the compression algorithm itself; if the compression step is computationally expensive, the net gain in end-to-end latency might be lower than the FLOP reduction suggests. There is also a risk that "global coverage" metrics might discard rare but critical tokens in long-context scenarios.
This work contributes to the democratization of large multi-modal models by making them more efficient and accessible for deployment on resource-constrained devices. It aligns with the broader trend of efficient AI and sustainable computing. By enabling high performance with significantly reduced computational cost, it lowers the barrier to entry for researchers and developers working with Omni-LLMs. OmniPack presents a practical and effective training-free solution for token compression in Omni-modal LLMs, offering substantial efficiency gains with minimal performance degradation, though its novelty is incremental and its reproducibility is hindered by the lack of public code.
We construct unambiguous DNFs having width $O(n)$ but $0$-certificate complexity $Ω(n^2)$. By utilizing the special structure of these DNFs, we prove a lifting theorem with a constant-sized gadget that lifts the DNF to a communication problem, while losslessly translating the separation in certificate complexity to a separation in communication complexity. This leads to an optimal refutation of the Alon-Saks-Seymour conjecture, as well as an optimal communication lower bound for the Clique versus Independent Set problem, improving the previous results of Balodis, Ben-David, Göös, Jain and Kothari (FOCS 2021, SICOMP 2023) by several doubly logarithmic factors. As further applications of our construction to query complexity and learning theory, we exhibit: (a) a family of Boolean functions that has an optimal quartic separation between certificate complexity and approximate degree, and (b) a sample compression lower bound of $Ω(\sqrt{\log c})$ for multiclass concept classes over $c$ labels.
Primary: Stanford University
All Institutions: Stanford University
This paper provides an optimal refutation of the Alon-Saks-Seymour conjecture and establishes new lower bounds in communication and query complexity through novel constructions of unambiguous DNFs and a constant-sized lifting gadget. The work represents a significant theoretical contribution to machine learning theory, offering deep insights into the fundamental limits of learning and computation, with rigorous proofs that advance the state of the art in complexity theory.
The paper presents a significant theoretical advance in computational complexity and learning theory. The core methodology involves constructing unambiguous Disjunctive Normal Forms (DNFs) with specific width and certificate complexity properties. The authors then employ a lifting theorem with a constant-sized gadget to translate these query complexity separations into communication complexity lower bounds. This approach is mathematically rigorous and leverages deep connections between boolean function analysis, communication complexity, and learning theory. The construction of the DNFs and the proof of the lifting theorem constitute a novel methodological contribution to the field of theoretical computer science.
As a theoretical computer science paper, this work does not contain empirical experiments, datasets, or benchmarks in the traditional machine learning sense. The "results" are mathematical proofs establishing lower bounds and separations. Therefore, experimental evaluation is not applicable. The validity rests entirely on the correctness of the proofs.
Theoretical papers are reproducible in the sense that their proofs can be verified. The paper provides sufficient detail in the abstract and structure (implied by the section headers) to allow for verification by experts in the field. However, without access to the full text's proofs, one must rely on the abstract's claims. The acknowledgements mention interaction with LLMs, which is a transparency note but does not affect the mathematical reproducibility of the results.
The primary limitation is that this is a theoretical result. While it has profound implications for understanding the limits of learning and computation, it does not provide immediate algorithms or practical tools for practitioners. The "applications" mentioned (sample compression lower bounds, approximate degree separation) are also theoretical bounds. Furthermore, the reliance on LLMs for idea development, while acknowledged, is a minor concern regarding the originality of the *ideation* process, though the *execution* and *proof* remain the authors' responsibility.
This paper has high impact within the theoretical machine learning and complexity theory communities. Refuting the Alon-Saks-Seymour conjecture is a major milestone. The improved lower bounds for Clique vs. Independent Set and the new separations in query complexity provide fundamental insights into the hardness of learning and computation. It sets new benchmarks for what is achievable in certificate complexity and communication complexity, guiding future research in these areas. This paper provides an optimal refutation of the Alon-Saks-Seymour conjecture and establishes new lower bounds in communication and query complexity through novel constructions of unambiguous DNFs and a constant-sized lifting gadget. The work represents a significant theoretical contribution to machine learning theory, offering deep insights into the fundamental limits of learning and computation, with rigorous proofs that advance the state of the art in complexity theory.
Language models are increasingly promoted from examinees to examiners: they write the test suites, answer keys, rubrics, and reward functions that define correctness for other systems. We measure the capability that role assumes and find it lacking under the protocol the role is usually deployed with, one-shot greedy authoring with no test-time reasoning. Across four reference constructions - two with complete finite truth, one with a hardened executable reference (HumanEval+/MBPP+), one with an explicitly incomplete lexical reference (WordNet) - models judge whether a candidate belongs far better than they author the set itself. On the incompleteness-proof algorithmic construction the gap is +0.34 to +0.29 F1 over a 24x parameter range and does not close; on executable code, models judging at F1 0.74-0.90 author suites admitting only 19-42% of oracle-correct solutions. A control locates the deficit: asked to emit the predicate rather than its extension, the same models reach F1 about 0.99. The failure is not missing knowledge or an inability to specify, but an inability to materialise the region a specification induces. The dominant error is omission, which resists audit: an over-inclusion is a token a reviewer can challenge, a missing member an absence whose discovery is the authoring problem itself. Models detect planted over-inclusions 6-7x more often than planted omissions, and a production deployment of 43,227 items fails omission-first at 10:1. Wired into RLVR, an authored key costs 1.9 points of accuracy against an exact oracle and 18.5 WordNet-relative (six paired seeds, p=0.031). Gating authored verifiers on a known-correct probe cuts false rejection from 58-92% to at most 5%, but keeps only 5-39% of suites. Repairing them instead, by rewriting each wrong expected value to what a reference execution returns, raises yield 3.3-10.6x across four author families.
Primary: University of Macau
All Institutions: University of Macau
The paper makes a compelling and empirically rigorous case for a fundamental asymmetry in LLM capabilities: while models are proficient at judging membership in a set, they are significantly less capable of authoring the set itself, a deficit driven by silent omissions that resists standard audit and has tangible costs in RLVR pipelines.
The paper employs a rigorous comparative methodology to isolate the "judging-authoring asymmetry" in Large Language Models (LLMs). By constructing ground-truth benchmarks where the acceptable set is mechanically decidable (algorithmic) or executable (code), the authors create a controlled environment to measure the fidelity of authored sets against execution-based judgments. The methodology is strong because it avoids the circularity of using LLMs to grade LLMs, instead relying on oracles and execution. The decomposition of the deficit into "emission," "stopping," and "specification" components via format controls (JSON checkboxes vs. free text) and intensional controls (writing predicates vs. enumerating sets) provides a deep mechanistic understanding of the failure mode. The use of multiple model families and scales ensures the findings are not artifacts of a specific architecture.
The experimental evaluation is comprehensive and robust. It covers four distinct construction types: complete finite truth (word lists with simple predicates), executable truth (HumanEval+/MBPP+), lexical truth (WordNet), and arithmetic truth. The results consistently show that models judge membership significantly better (F1 0.74-0.90) than they author the corresponding sets (F1 0.19-0.42 for code). The paper includes ablation studies on prompt sensitivity, emission format, and model scale. Crucially, it tests frontier models (GPT-5.1, Claude Opus 4.8) and finds the gap persists, although test-time reasoning can close it for simple rules. The inclusion of a "production-scale" field evidence section (43,227 items) adds significant weight to the practical relevance of the findings. The statistical significance is addressed via paired seeds and confidence intervals.
The paper provides detailed descriptions of the construction protocols, including the specific predicates, word lists, and code benchmarks used. The use of deterministic seeds for sampling and the clear definition of the authoring vs. execution interfaces enhance reproducibility. The authors explicitly state that no model output is graded by a model, relying instead on mechanical execution or oracle labels, which facilitates independent verification. The code and data are likely available given the standard practices of such venues, though specific URLs are not in the text. The clear distinction between the "gate" and "repair" mitigations allows other researchers to replicate the baseline failures and improvements.
The primary limitation is the scope of the "authoring" task. The paper focuses on one-shot greedy decoding without test-time reasoning for the main results, acknowledging that reasoning can close the gap for simple rules. This means the findings may not apply to systems that utilize extensive chain-of-thought or self-correction. Additionally, the "lexical" construction suffers from the inherent incompleteness of WordNet, which the authors correctly identify as a confound for precision, though they mitigate this by relying on recall and complete-truth constructions for their main claims. The "repair" mitigation requires a known-correct reference solution, which is not always available in real-world scenarios, limiting the immediate applicability of the proposed fix.
This paper has significant implications for the development of LLM-based agents, automated testing, and reinforcement learning from verifiable rewards (RLVR). By demonstrating that LLM-authored verifiers are prone to silent omissions and over-specification, it warns against blindly trusting model-generated test suites and reward functions. The finding that omission errors resist audit suggests that current evaluation pipelines may be systematically biased towards under-acceptance. The proposed mitigation (gating on known-correct probes) offers a practical path forward for deploying LLM-authored components safely. This work shifts the community's focus from "can LLMs judge?" to "can LLMs define the space of correctness?", a crucial distinction for building reliable AI systems. The paper makes a compelling and empirically rigorous case for a fundamental asymmetry in LLM capabilities: while models are proficient at judging membership in a set, they are significantly less capable of authoring the set itself, a deficit driven by silent omissions that resists standard audit and has tangible costs in RLVR pipelines.
Flow Matching trains continuous-time generative models by regressing the velocity field of a probability path between a simple source distribution and a target data distribution. The coupling that pairs source and target samples strongly affects optimization and sample quality, but structured couplings typically rely on mini-batch transport or assignment procedures whose cost grows at least quadratically in batch size. We propose Quantile Coupling Flow Matching (QC-FM), a lightweight one-sided coupling: rather than matching two pre-sampled batches, it samples only the data batch and constructs each paired source directly. Data ranks projected along a small number of random orthogonal directions are mapped to Gaussian quantiles, and the latent code is completed in the orthogonal complement by conditional Gaussian sampling. The construction is one-dimensional per slice, so the coupling requires no pairwise cost matrix and no assignment to solve. We show that, for each drawn frame, this coupling eliminates the irreducible regression variance along every selected slice and makes the ideal flow exactly straight there, while leaving the sampling prior unchanged: generation still starts from the standard Gaussian, and the training source deviates from it only through the copula of the slice codes, whose transport cost we bound. For training, we apply QC to an anchor subset and complete the remaining source slots with exact Gaussian samples, retaining the QC bias while preserving an explicit signal from the Baseline coupling. Across CIFAR-10, CelebA, FFHQ, and ImageNet-64, QC-FM improves over the Baseline under matched training budgets, reducing FID by up to 12.9%, and outperforms OT-CFM on all four datasets. These results suggest that preserving projected rank structure is a simple and scalable way to inject useful geometric bias into FM couplings without solving a mini-batch transport problem.
Primary: Unknown
All Institutions: Unknown
This paper introduces Quantile Coupling Flow Matching, a computationally efficient, one-sided coupling scheme for Flow Matching that reduces regression variance and improves sample quality without the quadratic cost of mini-batch optimal transport.
The paper proposes Quantile Coupling Flow Matching (QC-FM), a method to structure the coupling between source (noise) and target (data) distributions in Flow Matching (FM). Instead of solving an expensive optimal transport (OT) assignment problem within mini-batches, QC-FM projects data onto random orthogonal directions, ranks the projections, and maps these ranks to Gaussian quantiles to construct the source samples. This "one-sided" coupling is computationally efficient ($O(B \log B)$ vs $O(B^2)$ or $O(B^3)$) and theoretically motivated by the reduction of irreducible regression variance along the selected slices. The authors also introduce hybrid schemes (Mixture and Adjacency) to handle the remaining source slots. The methodology is sound, leveraging well-known concepts from sliced Wasserstein distances and comonotone coupling, but applies them in a novel, efficient way for continuous-time generative modeling.
The authors evaluate QC-FM on standard image generation benchmarks: CIFAR-10, CelebA, FFHQ, and ImageNet-64. They compare against the Baseline (independent coupling) and OT-CFM (minibatch optimal transport). Results show that QC-FM-Mixture consistently outperforms the Baseline and OT-CFM in terms of FID scores under matched training budgets. The paper provides detailed ablation studies on hyperparameters (number of slices $k$, anchor ratio $p$) and computational cost analysis, demonstrating significant speedups in coupling construction time compared to Hungarian/Sinkhorn solvers. The experiments are rigorous and support the claims of improved sample quality and efficiency.
The paper provides a detailed description of the algorithm, including the construction of the source samples, the hybrid completion schemes, and the theoretical bounds. The experimental setup is well-described, specifying model architectures (EDM-based U-Net), optimizers, and training schedules. The code is not explicitly linked in the text provided, but the algorithmic details are sufficient for reproduction. The theoretical proofs in the appendix add to the clarity of the method's properties.
The method is batch-local; the quantiles are estimated from the current mini-batch, which may introduce noise or instability compared to global quantile estimates. The performance gain is moderate (up to 12.9% FID reduction), and the method does not achieve global optimality. The choice of hyperparameters ($k$, $p$) appears dataset-dependent, requiring some tuning or heuristic selection. The theoretical analysis focuses on per-slice properties and does not provide a direct bound on final FID or sample quality.
By providing a scalable alternative to expensive optimal transport couplings in Flow Matching, QC-FM enables more efficient training of continuous-time generative models. This could lower the computational barrier for high-quality image generation and facilitate the use of structured couplings in larger-scale settings. The approach may also inspire similar efficient coupling strategies in other diffusion or flow-based modeling frameworks. This paper introduces Quantile Coupling Flow Matching, a computationally efficient, one-sided coupling scheme for Flow Matching that reduces regression variance and improves sample quality without the quadratic cost of mini-batch optimal transport.
Large language model agents increasingly act through stateful tools, yet model generation and environment execution remain serialized at every step. As decoding accelerates, tool execution becomes a growing bottleneck. Existing action- or observation-only speculation leaves much of this latency exposed: value is concentrated in a few slow calls, some outcomes emerge only through execution, and longer lookahead typically requires an increasingly unlikely chain of action predictions. We present AOSpec, a lossless framework that co-speculates actions and observations across the full agent-environment loop. Expected Value Decoding (EVD) directs observation speculation toward outcomes with the greatest expected latency benefit, optimizing expected time hidden rather than hit rate. For outcomes only execution can reveal, AOSpec launches latency-critical target actions in isolated forks that contain their effects, while Joint Action-State Verification (JASV) verifies both the action and its origin state against committed execution before reuse. JASV recasts long-horizon action dependency from full-chain prediction into target action-state verification, breaking the lookahead--accuracy tradeoff and unlocking long-range overlap without sacrificing serial semantics. Across Terminal-Bench serving settings spanning four harnesses, five actor models, and five serving speeds, AOSpec outperforms every practical baseline, reducing mean end-to-end latency by 11.8-32.5% and p99 latency by up to 42.8%. Its gains increase as decoding accelerates, and its observation model transfers from Terminal-Bench to SWE-bench Verified without retraining.
Primary: Unknown
All Institutions: Unknown
The paper presents a practical and timely optimization for LLM agent serving, offering moderate novelty in adapting speculative decoding to the agent loop. While the latency gains are promising, the technical contribution is incremental rather than transformative, and the full rigor of the claims remains unverified without the complete text and code.
The paper proposes "AOSpec," a framework for low-latency serving of LLM agents. The core technical contribution lies in "co-speculation" of actions and observations, moving beyond traditional speculative decoding which typically only predicts tokens. The method introduces Expected Value Decoding (EVD) to prioritize speculation paths with high latency benefits and Joint Action-State Verification (JASV) to verify the consistency of actions and states in isolated forks. The methodology addresses the specific bottleneck of tool execution in agent loops, which is a valid and important problem. However, the approach is largely an engineering adaptation of speculative decoding principles to the agent domain rather than a fundamental theoretical breakthrough. The "isolated forks" mechanism for containing side effects is a standard virtualization concept applied to LLM inference, which is clever but not novel in computer science terms.
The evaluation is conducted on Terminal-Bench and SWE-bench Verified, which are relevant benchmarks for agent performance. The results claim significant latency reductions (11.8-32.5% mean, up to 42.8% p99). The experimental setup spans multiple models and serving speeds, providing a reasonable level of robustness. However, the abstract-only text provided lacks detailed tables, statistical significance tests, or ablation studies that would confirm the magnitude of these gains. The claim of "lossless" performance is critical; if the speculation introduces any semantic drift in the agent's reasoning, the utility is compromised. The paper asserts this is handled by JASV, but without seeing the verification logic's overhead and failure modes, the net benefit is hard to fully assess. The transferability to SWE-bench is a strong point, suggesting generalizability.
The paper text provided is a skeleton with section headers but no detailed methodology or experimental code. Reproducibility cannot be assessed from the text alone. The claims rely on specific implementations of EVD and JASV which are not described in sufficient detail in the abstract. The lack of code or detailed algorithmic pseudocode in the provided text is a significant barrier to immediate reproducibility.
The primary limitation is the dependency on the accuracy of the observation model. If the observation model is incorrect, the speculation fails, potentially requiring rollback or fallback to sequential execution, which could negate latency gains. The "isolated forks" approach likely incurs memory and computational overhead for maintaining state copies, which might become prohibitive for long-horizon agents with large context windows. Furthermore, the assumption that tool execution is the sole bottleneck may not hold for all agent tasks, particularly those with heavy computational steps or network latency that is not parallelizable with decoding.
This work contributes to the efficiency of LLM agents, making them more viable for real-time applications. By reducing latency, it lowers the cost and improves the user experience of agent-based systems. However, faster agents could also accelerate the deployment of automated systems in critical domains, raising safety and alignment concerns if not properly monitored. The focus on efficiency is positive for the field's scalability. The paper presents a practical and timely optimization for LLM agent serving, offering moderate novelty in adapting speculative decoding to the agent loop. While the latency gains are promising, the technical contribution is incremental rather than transformative, and the full rigor of the claims remains unverified without the complete text and code.
Pixel-space diffusion models aim to learn an end-to-end generator directly over raw pixels. This is challenging because a single model must capture both global structure and local texture in the same high-dimensional space. While recent work improves pixel diffusion through alternative prediction targets, training objectives, and architectures, these advances typically require training a new model from scratch. We show there is a cheaper, complementary strategy: a frozen, pretrained pixel diffusion model can guide itself. Our key observation is that intermediate layers of a pretrained pixel diffusion transformer can be decoded into coarse predictions that capture the main low-frequency structure, while the final layers progressively refine local, high-frequency details. We therefore attach a lightweight prediction head to an intermediate layer, keep the backbone frozen, and use the discrepancy between the intermediate and final predictions as a self-guidance direction during sampling. To train this head, we further find that real images are not necessary. Instead, model-generated samples suffice and even outperform real images for training the head, especially in enhancing the high-frequency components that pixel diffusion tends to underfit. Across multiple pixel diffusion models on ImageNet, our Synthetic Self-Guidance (SSG) consistently improves generation while adapter training requires less than 1% of full-model training compute: it reduces FID by over 50% across the evaluated JiT variants without classifier-free guidance (CFG) and further improves strong baselines with CFG, e.g., JiT-H/16 from 1.86 to 1.67 and PixelREPA-H/16 from 1.81 to 1.59. Our code is available at https://github.com/zfu006/SSG.
Primary: Unknown
All Institutions: Unknown
This paper presents a practical and effective method for enhancing pretrained pixel-space diffusion models using self-generated data and internal guidance, offering a significant improvement in generation quality with minimal computational overhead.
The paper proposes "Synthetic Self-Guidance" (SSG), a plug-in method for improving pretrained pixel-space diffusion models (like JiT, PixelREPA, DeCo) without retraining the backbone. The core idea is to attach a lightweight adapter to an intermediate layer of the transformer, keep the backbone frozen, and use the discrepancy between the intermediate (coarse) and final (fine) predictions as a guidance signal during sampling. Crucially, the adapter is trained not on real data, but on samples generated by the pretrained model itself. The authors justify this by showing that intermediate layers naturally capture low-frequency structure while final layers refine high-frequency details, and that synthetic data helps the adapter learn to provide a "weak" reference that, when extrapolated, enhances high-frequency details. The methodology is technically sound, leveraging existing concepts of internal guidance and classifier-free guidance but applying them in a novel, compute-efficient manner specific to pixel-space transformers.
The authors evaluate SSG on ImageNet 256x256 and 512x512 across multiple architectures (JiT, PixelREPA, DeCo). They report significant FID improvements, particularly without Classifier-Free Guidance (CFG), where FID drops by >50% for some models. With CFG, improvements are more modest but consistent (e.g., JiT-H/16 from 1.86 to 1.67). The experiments include ablation studies on adapter depth, attachment layer, synthetic vs. real training data, and dataset size. The results are compelling and demonstrate that frozen backbones can be significantly improved with minimal additional compute. The comparison with Internal Guidance (IG) shows SSG is more efficient and often better, though IG jointly trains the backbone which might capture more complex interactions. The frequency-domain analysis supports the claim that SSG enhances high-frequency details.
The paper provides detailed implementation details, including adapter architecture, training hyperparameters, and sampling settings. The code is available on GitHub. The synthetic data generation process is clearly described. The use of frozen backbones and lightweight adapters makes the method highly reproducible and easy to implement on top of existing open-source pixel diffusion models.
The method is primarily evaluated on class-conditional ImageNet generation. The authors acknowledge that generalization to text-conditioned models or other domains is unclear. The improvement with CFG is smaller than without CFG, suggesting the method's primary strength is in settings where CFG is not used or is weak. The reliance on synthetic data for adapter training, while effective, introduces a dependency on the quality of the initial pretrained model's samples.
This work lowers the barrier to improving pixel diffusion models by allowing practitioners to enhance existing models without expensive retraining. It highlights the potential of self-supervised/self-generated data for refining generative models. The focus on pixel-space models is relevant as latent models face reconstruction bottlenecks. However, the impact is somewhat limited by the specific focus on pixel-space diffusion, which is a niche compared to latent diffusion. This paper presents a practical and effective method for enhancing pretrained pixel-space diffusion models using self-generated data and internal guidance, offering a significant improvement in generation quality with minimal computational overhead.
Reinforcement learning (RL) post-training of Vision-Language-Action (VLA) models has shown strong promise for robotic manipulation. Among RL methods, critic-based approaches rely on a value estimator that predominantly operates on single-frame observations or single-frame VLM backbone latents, which is a fundamental mismatch with the partially observable nature of robot control. A naive approach to incorporate observation history into the critic incurs exponential complexity with high-dimensional visual space, and still fails because pure scalar-return regression provides insufficient supervision for learning cross-temporal dynamics. We identify the root cause as a state approximation problem: without an explicit world modeling objective, the critic's representation cannot capture the temporal structure needed for accurate value estimation. To address this, we propose the World Critic Model (WCM), built on a lightweight LeJEPA architecture; WCM jointly predicts future latent state and estimates values, such that the critic's representation is explicitly trained to capture temporal dynamics rather than merely regress scalar returns. WCM integrates seamlessly into both on-policy and off-policy training pipelines and is compatible with state-of-the-art VLA backbones including Pi0, Pi0.5, and OpenVLA-OFT. Extensive experiments on 149 tasks across four benchmarks demonstrate that WCM consistently achieves state-of-the-art performance in both in-distribution and out-of-distribution settings, with particularly strong generalization gains. We further validate WCM on seven real-world manipulation tasks using OpenVLA-OFT and Pi0.5 with off-policy RL, confirming stable deployment across diverse settings.
Primary: Unknown
All Institutions: Unknown
The paper presents a technically sound and practically relevant improvement to VLA reinforcement learning by introducing a world-model-informed critic that better captures temporal dynamics. While the novelty is incremental (applying predictive modeling to critics is not entirely new, but the specific application to VLA backbones is timely), the extensive empirical validation and seamless integration with state-of-the-art models make it a valuable contribution to the field. [One sentence main contribution]. [The paper introduces the World Critic Model (WCM), a novel critic architecture for Vision-Language-Action reinforcement learning that integrates a lightweight predictive world model to explicitly capture temporal dynamics, thereby overcoming the limitations of single-frame critics and significantly improving performance and generalization across a wide range of robotic manipulation tasks.]
The paper proposes the World Critic Model (WCM), addressing a specific bottleneck in Vision-Language-Action (VLA) reinforcement learning: the inability of standard critic networks to model temporal dynamics due to their reliance on single-frame observations. The authors identify this as a state approximation problem and propose a solution using a lightweight LeJEPA (Latent Embedding Joint Embedding Predictive Architecture) backbone. The core innovation is a multi-task objective where the critic jointly predicts future latent states and estimates values. This forces the representation learning process to capture temporal structure, theoretically aligning the critic's internal state with the partially observable nature of robotic control. The approach is integrated into both on-policy and off-policy pipelines and is designed to be compatible with existing VLA backbones like Pi0 and OpenVLA.
The experimental section claims extensive validation across 149 tasks on four benchmarks, demonstrating state-of-the-art performance in both in-distribution and out-of-distribution settings. Real-world validation is provided on seven manipulation tasks. The breadth of the evaluation (149 tasks) is impressive and suggests robust empirical support. However, the abstract's claim of "state-of-the-art" must be weighed against the fact that VLA-RL is a rapidly evolving field with many baselines. The integration with established backbones (Pi0, OpenVLA) adds credibility, as it shows the method is a plug-and-play improvement rather than a fragile, architecture-specific trick. The inclusion of out-of-distribution generalization results is particularly relevant for real-world deployment.
The paper mentions compatibility with standard VLA backbones, which aids reproducibility. However, the specific implementation details of the LeJEPA architecture within the critic and the joint training dynamics are critical. Without access to the code (URLs not provided in the text), full reproducibility is uncertain. The abstract does not specify hyperparameters or computational overhead, which are key for practitioners to assess the trade-off between performance gains and training cost.
The primary limitation is the added computational complexity of the world model component. While described as "lightweight," adding a predictive model to the critic increases inference and training time. The paper does not explicitly quantify this overhead in the abstract. Furthermore, the effectiveness of the world model depends on the quality of the latent space provided by the VLM backbone; if the backbone's latent space is poor, the critic may struggle to learn meaningful dynamics. The generalization to entirely new robot morphologies or sensor setups is not addressed.
This work contributes to the broader goal of making robotic manipulation more robust and generalizable. By improving the temporal reasoning capabilities of VLA models through RL, it addresses a key barrier to deploying these models in complex, dynamic real-world environments. The focus on out-of-distribution generalization is particularly significant for safety-critical applications. The paper presents a technically sound and practically relevant improvement to VLA reinforcement learning by introducing a world-model-informed critic that better captures temporal dynamics. While the novelty is incremental (applying predictive modeling to critics is not entirely new, but the specific application to VLA backbones is timely), the extensive empirical validation and seamless integration with state-of-the-art models make it a valuable contribution to the field. [One sentence main contribution]. [The paper introduces the World Critic Model (WCM), a novel critic architecture for Vision-Language-Action reinforcement learning that integrates a lightweight predictive world model to explicitly capture temporal dynamics, thereby overcoming the limitations of single-frame critics and significantly improving performance and generalization across a wide range of robotic manipulation tasks.]
Modern vision language models (VLMs) turn high-resolution images into long sequences of visual tokens. Every token traverses the language decoder and persists in its prompt KV cache, inflating inference cost and motivating aggressive visual compression. Existing score-based methods assign each token an independent importance score and retain the Top-K. However, text queries consume collective, signed attention messages from the visual population, not isolated patches. Consequently, equally sized Top-K sets can repeatedly cover one salient region, omit sparse but complementary evidence and discard information carried by the removed population. We therefore formulate faithful visual compression as constructing a compact coreset for decoder messages, and introduce our training-free Grounded Message Coreset Pruning (GMC) which jointly allocates support across query-grounded, appearance, and coordinate-aware evidence, then transports discarded states into selected representatives at their original multimodal positions before physical compaction and native attention resume. This decomposes faithful compression into two coupled components, including selecting carriers that cover the required message modes and realizing the signed population message on those carriers. We further derive bounds connecting their errors to signed-message distortion, visual innovation, and candidate-margin stability. Experiments across multiple VLM families and diverse benchmarks demonstrate strong performance, with GMC-H2 retaining 97.78% Full-relative mean capability on Qwen2.5-VL-7B using 80.2% fewer visual tokens, while GMC-L16 reaches 100.36%. Controlled interventions verify that collective support and population realization jointly drive these gains.
Primary: Cardiff University
All Institutions: Cardiff University, Chinese Academy of Sciences, Foundation Model Research Center, Institute of Automation, School of Engineering, School of Future Technology, University of Chinese Academy of Sciences, Wuhan AI Research
[One sentence main contribution]. [The paper introduces GMC, a training-free visual token compression method that formulates faithful compression as constructing a coreset for decoder messages, jointly optimizing support allocation and population realization to preserve signed, complementary evidence, achieving state-of-the-art fidelity with significantly reduced token counts across multiple VLM families.]
The paper proposes "Grounded Message Coreset Pruning" (GMC), a training-free method for compressing visual tokens in Vision-Language Models (VLMs). The core theoretical contribution is reframing token selection not as independent importance scoring, but as constructing a "coreset" for the collective, signed attention messages received by the language decoder. The method involves two coupled steps: (1) Support Allocation: Using a facility-location objective with query-grounded, appearance, and spatial clients to select a subset of tokens that cover complementary evidence modes; (2) Population Realization: Transporting the hidden states of discarded tokens to the selected representatives, preserving their original multimodal coordinates and signed contributions before native attention resumes. The authors provide theoretical bounds connecting the compression error to signed-message distortion and visual innovation. The approach is technically sophisticated, moving beyond simple redundancy reduction to address the specific mechanics of cross-attention in VLMs.
The evaluation is extensive, covering multiple VLM families (Qwen2.5-VL-7B, LLaVA-1.5-7B) and diverse benchmarks (POPE, AMBER, HallusionBench, CHAIR, TextVQA, ChartQA, MME, MMBench, GQA). The results demonstrate that GMC retains significantly higher fidelity than state-of-the-art baselines (VisionZip, MMTok) at aggressive compression ratios (e.g., retaining ~98% capability with 80% fewer tokens). The paper includes rigorous ablation studies isolating the effects of support allocation vs. population realization, and controlled interventions verifying the theoretical claims. The performance gains are consistent across discriminative and generative tasks, and the method shows strong transferability across different model architectures without retraining.
The paper provides detailed descriptions of the algorithm, including the facility-location solver, the transport mechanism, and the coordinate preservation strategy. It mentions frozen probes and specific settings in the appendix (referenced but not fully visible in the provided text snippet, though standard for such submissions). The training-free nature of the method enhances reproducibility as it requires no additional training data or parameter updates. The use of standard benchmarks and open-source base models facilitates independent verification.
The method introduces computational overhead during the pruning phase due to the facility-location optimization and state transport, although this is a one-time prefill cost. The theoretical bounds, while insightful, rely on assumptions about Lipschitz continuity and submodularity that may not hold perfectly in deep non-linear transformers. The paper focuses on static image inputs; the behavior with video or highly dynamic sequences is less explored. Additionally, the "appearance" and "spatial" clients rely on fixed heuristics or banks which might require tuning for specific domains (e.g., dense text vs. open scenes).
This work addresses a critical bottleneck in deploying large VLMs: inference cost and memory usage. By enabling faithful compression without retraining, it lowers the barrier for running powerful multimodal models on edge devices or in high-throughput applications. The theoretical framework of "message coresets" could inspire similar approaches for other sequence-to-sequence or multimodal architectures where collective context matters. It also highlights the importance of preserving signed, complementary information in attention mechanisms, which may influence future model design and pruning strategies. [One sentence main contribution]. [The paper introduces GMC, a training-free visual token compression method that formulates faithful compression as constructing a coreset for decoder messages, jointly optimizing support allocation and population realization to preserve signed, complementary evidence, achieving state-of-the-art fidelity with significantly reduced token counts across multiple VLM families.]
Vision-language models (VLMs) are expected to revise their reasoning when visual evidence changes. Failures to do so are often attributed to insufficient visual attention or contextual inertia, leaving unclear what models reuse instead of recomputing from the current image. We show that evidence-bearing reasoning in a prior chain of thought (CoT) can form a textual shortcut that competes behaviorally with visual recomputation. Across 16 VLMs, a matched counterfactual analysis identifies evidence-bearing content as the most robust carrier of prior-CoT influence. Removing this evidence-bearing content shifts answer preference more than removing length-matched non-evidence context or the final-answer span, with prior control weakening progressively as more stale evidence is removed. Reordering this evidence also weakens prior control, showing that its organization modulates shortcut strength. Beyond the immediate answer, the shortcut can retain residual influence after answer correction: weakening current-image support shifts preference back toward the prior answer, while repeated prior answers and reused premises arise mainly when the shortcut remains active. To limit this influence, we introduce Fresh-State Attention Firewall (FSAF), a training-free intervention that isolates fresh computation from the prior CoT. Across five VLMs, FSAF raises visual update rate from 35.28% to 53.61% and reduces prior-answer rate from 39.22% to 3.67%. Reliable VLM self-reflection therefore requires more than looking again: fresh visual recomputation must be protected from stale textual reuse.
Primary: JD.com
All Institutions: JD.com
The paper makes a significant contribution by diagnosing the "textual shortcut" problem in VLM self-reflection and proposing a novel, training-free attention masking intervention (FSAF) that effectively mitigates this issue, leading to more reliable visual recomputation across a wide range of models.
The paper proposes a rigorous diagnostic framework to isolate "textual shortcuts" in Vision-Language Models (VLMs) during self-reflection. The core methodological contribution is the "Fresh-State Attention Firewall" (FSAF), a training-free intervention that uses attention masking to prevent the model's fresh reasoning trace from attending to the prior, potentially stale, chain-of-thought. The diagnostic methodology involves a matched counterfactual analysis where evidence-bearing content is systematically removed or reordered to measure its causal influence on answer preference. This approach is technically sound, leveraging standard transformer attention mechanisms but applying them in a novel, interventionist manner to diagnose internal model behavior. The distinction between "evidence-bearing" and "non-evidence" context is well-defined and operationally implemented.
The evaluation is extensive, covering 16 different VLMs across multiple families (Qwen, Gemma, InternVL, Kimi). The experiments are carefully controlled, using paired comparisons to isolate the effect of the prior CoT. The results are robust: removing evidence-bearing content consistently shifts answer preference toward the current image, and FSAF significantly improves the "visual update rate" while reducing "prior-answer rate." The inclusion of "support withdrawal" tests to show residual dependence even after correct answers is a strong empirical addition. The use of a large language model as a semantic judge is noted, which is a standard but imperfect practice; however, the paired design mitigates some of this noise. The scale of evaluation (16 models) provides high confidence in the generalizability of the findings.
The paper provides detailed implementation specifics, including the exact attention masking logic, the conversation templates, and the evaluation protocols. The use of vLLM and Transformers backends is standard. The code for FSAF is described in sufficient detail for replication. The dataset (VS-Bench) is referenced from prior work, ensuring consistency. The paper includes an appendix with extensive ablation studies and protocol maps, enhancing reproducibility.
The primary limitation is that FSAF is a training-free intervention that modifies the inference-time attention pattern. While effective, it may not be compatible with all model architectures or inference engines that do not expose low-level attention hooks. Furthermore, the "semantic judge" introduces a potential bias, although the paired design helps. The paper focuses on Qwen models for the FSAF evaluation, which limits the generalizability of the *intervention's* effectiveness to other architectures, although the *diagnosis* is broader. The method assumes that the prior CoT is the primary source of the shortcut, which might not hold in all complex reasoning scenarios involving multi-step visual grounding.
This work has significant implications for the reliability of VLMs in safety-critical applications where self-correction is expected to be robust. By identifying that VLMs often "reuse" stale reasoning rather than "recomputing" from visual evidence, the paper highlights a fundamental flaw in current self-reflection paradigms. The proposed FSAF offers a practical, immediate solution to improve VLM reliability without retraining. This could lead to more trustworthy AI systems in domains like medical imaging or autonomous driving, where visual grounding is paramount. The paper makes a significant contribution by diagnosing the "textual shortcut" problem in VLM self-reflection and proposing a novel, training-free attention masking intervention (FSAF) that effectively mitigates this issue, leading to more reliable visual recomputation across a wide range of models.
We present LiveLight, the first diffusion-based framework for real-time streaming video relighting with interactive 3D lighting control. Achieving this is non-trivial, as it requires overcoming three critical challenges: effectively injecting dynamic 3D lighting into a diffusion model, maintaining high-fidelity generation under an extremely low NFE (Number of Function Evaluations) budget for real-time speed, and facilitating continuous streaming for interactive control. To address these pain points, we propose three key designs. First, for accurate lighting injection, we propose a lightweight adapter that feeds Multi-Plane Light Irradiance (MPLI) conditions-depth-aware irradiance maps encoding 3D lighting geometry-directly into the diffusion backbone. Second, to prevent rendering quality degradation at low NFEs towards real-time distillation, we introduce a geometry-guided feedback branch. This training-time constraint leverages a frozen geometry estimator to enforce depth- and normal-consistent relighting, ensuring geometrically plausible shading without adding inference overhead. Finally, to enable streaming interaction, we develop a progressive rolling-window strategy that maintains a denoising ladder of latent chunks at varying noise levels. By propagating intermediate states, this strategy guarantees temporal coherence and supports arbitrarily long video relighting with per-frame reference refresh. Extensive experiments on real-world and synthetic benchmarks demonstrate that LiveLight achieves state-of-the-art relighting quality while running at real-time speed, significantly outperforming offline baselines in temporal stability, lighting controllability, and user preference. To foster real-time interactive relighting research, we will publicly release our models, training data, and synthetic data generator.
Primary: University of Macau
All Institutions: University of Macau, University of Tuebingen
LiveLight presents a significant technical advancement in real-time video relighting by effectively combining diffusion models with 3D lighting priors and a novel streaming denoising strategy, achieving a rare balance of interactivity, quality, and speed.
The paper proposes "LiveLight," a diffusion-based framework for real-time streaming video relighting. The core technical contributions are threefold: 1) A lightweight adapter injecting Multi-Plane Light Irradiance (MPLI) conditions into the diffusion backbone to handle 3D lighting geometry. 2) A geometry-guided feedback branch using a frozen geometry estimator to enforce depth/normal consistency during training, mitigating quality degradation at low Number of Function Evaluations (NFE). 3) A progressive rolling-window strategy for denoising latent chunks to enable continuous streaming and temporal coherence. The approach addresses the specific bottleneck of real-time interactive control in video diffusion models, which is a significant challenge given the computational cost of diffusion steps. The integration of explicit 3D lighting priors (MPLI) with diffusion is a novel architectural choice compared to standard text/image-conditioned relighting.
The authors evaluate LiveLight on real-world and synthetic benchmarks. They claim state-of-the-art performance in relighting quality, temporal stability, and controllability. The key metric is "real-time speed," implying a high frames-per-second (FPS) rate, likely achieved through the low NFE distillation. The comparison against offline baselines highlights the trade-off between quality and speed, arguing that LiveLight achieves a superior balance. The inclusion of user preference studies adds qualitative validation. However, as this is a TOG paper (a top-tier graphics venue), the evaluation is expected to be rigorous regarding visual fidelity and physical plausibility of lighting.
The authors state they will publicly release models, training data, and a synthetic data generator. This is a strong indicator of reproducibility. The use of a frozen geometry estimator suggests that pre-trained models for depth/normal estimation are used, which are widely available (e.g., MiDaS, NormalNet), aiding reproducibility. The specific "MPLI" format and adapter architecture details would need to be clearly documented in the code release for full reproducibility.
The paper acknowledges the challenge of maintaining high fidelity at extremely low NFEs. While the geometry-guided feedback helps, diffusion models at very low steps can still suffer from artifacts or loss of fine detail compared to higher-step offline methods. The reliance on a "frozen geometry estimator" means that if the input video has poor depth/normal estimation (e.g., due to motion blur or occlusion), the relighting quality may degrade. The "rolling-window" strategy might introduce boundary artifacts at the edges of the window if not carefully blended. The term "real-time" is relative; it likely refers to >30 FPS on high-end GPUs, not necessarily mobile devices.
This work enables new applications in virtual production, real-time VR/AR content creation, and interactive video editing. By making high-quality, physically plausible relighting interactive and real-time, it lowers the barrier for creators to manipulate lighting in video content. The release of the synthetic data generator could also benefit the broader community working on 3D-aware video generation. LiveLight presents a significant technical advancement in real-time video relighting by effectively combining diffusion models with 3D lighting priors and a novel streaming denoising strategy, achieving a rare balance of interactivity, quality, and speed.
Many-shot in-context learning (ICL) lets vision-language models (VLMs) adapt from image--label demonstrations without weight updates, and is widely assumed to improve as more demonstrations are supplied. We show the opposite: as demonstrations accumulate, a subset of VLMs undergo an \emph{in-context collapse}, a sharp, sometimes catastrophic accuracy drop spanning synthetic classification, natural-image classification, and VQA benchmarks, in some models falling below chance while outputs remain well-formed. Across an open VLM panel ($0.5$B--$11$B) and a frontier model (Claude Sonnet 4.5), the collapse is graded. Two capabilities turn out to be dissociable: robustness to accumulating demonstrations and the ability to learn a novel rule in context, their combinations yield three reproducible regimes. A parameter-matched lesion-and-rescue causally localizes the collapse to the vision-language integration pathway: an adapter on the connector and early/mid layers restores genuine learning (remap accuracy $0.39!\rightarrow!0.91$ at 16 shots), while an equal-capacity adapter on the late readout does not. We propose \textsc{CircA}, whose core is a one-time integration vaccine: trained once on one synthetic task, it transfers collapse-resistance to unseen task families (chance$\rightarrow$$0.71$/$0.60$ on CIFAR/Fashion). The layers best for in-context integration are not the layers best for weight-based consolidation, the late readout achieves higher accuracy and less forgetting at fewer parameters. The collapse is an integration failure at the vision--language interface, correctable by a lightweight, transferable intervention.
Primary: University of Pennsylvania
All Institutions: University of Pennsylvania, Amazon Generative AI Innovation Center
The paper introduces and characterizes "in-context collapse" in VLMs, a phenomenon where accuracy degrades with more demonstrations, and proposes CircA, a transferable integration-circuit adaptation framework to mitigate it. [Comprehensive analysis of the technical contribution, methodology, and significance to the field].
The paper proposes a rigorous mechanistic investigation into the failure modes of Vision-Language Models (VLMs) during many-shot in-context learning (ICL). The core methodological contribution is the definition of "in-context collapse" and the dissociation of "robustness" from "learning" using contamination-free synthetic concepts (remap verbalizers). The authors employ a parameter-matched lesion-and-rescue strategy, inserting low-rank adapters (LoRA) at specific integration vs. readout loci to causally localize the failure to the vision-language integration pathway (connector and early/mid layers). They further propose CircA, a framework involving a "vaccine" (offline adapter training), a "gate" (copy-rate monitoring), and an "inject" path (task-vector amortization). This approach is methodologically sound, leveraging tools from mechanistic interpretability to solve a practical engineering problem in multimodal ICL.
The experimental evaluation is comprehensive and convincing. It spans a diverse panel of open-weight VLMs (0.5B to 11B parameters, various connector types) and includes frontier closed models (Claude Sonnet 4.5, Amazon Nova). The use of synthetic tasks with arbitrary label mappings effectively isolates genuine in-context learning from pretraining prior retrieval. The results clearly demonstrate the collapse phenomenon, validate the causal localization hypothesis through the asymmetry of adapter placement, and show that the CircA vaccine transfers collapse-resistance to unseen tasks. The inclusion of a continual learning comparison adds depth, distinguishing the integration locus from the consolidation locus.
The paper provides a public GitHub repository with code and data. The experimental setup is well-described, including specific model versions, prompt templates, and decoding parameters. The use of standard benchmarks (CIFAR, Fashion) and clearly defined synthetic tasks ensures that other researchers can reproduce the collapse phenomenon and the proposed mitigations. The code availability significantly enhances the paper's reproducibility and utility.
The study focuses primarily on classification and VQA tasks. The "vaccine" requires a one-time offline training step, which may not be feasible for all deployment scenarios or closed-API models (though the gate and inject paths offer alternatives). The synthetic tasks, while useful for isolation, may not fully capture the complexity of natural image domains. Additionally, the collapse is observed in a "subset" of VLMs; a broader analysis of why certain architectures (e.g., cross-attention vs. MLP-projector) are more susceptible would strengthen the generalizability of the findings. The evaluation of frontier models is limited to API access, preventing deeper mechanistic analysis of those specific models.
This work has significant implications for the deployment of VLMs in few-shot and many-shot settings. By identifying a specific failure mode (collapse) and providing a lightweight, transferable mitigation (CircA), it enables more reliable adaptation of VLMs without weight updates. It also bridges the gap between mechanistic interpretability and practical model engineering, offering a causal understanding of how visual and linguistic information is integrated. This can guide future model architectures and training strategies to be more robust to context accumulation. The paper introduces and characterizes "in-context collapse" in VLMs, a phenomenon where accuracy degrades with more demonstrations, and proposes CircA, a transferable integration-circuit adaptation framework to mitigate it. [Comprehensive analysis of the technical contribution, methodology, and significance to the field].
Diffusion Transformers (DiTs) have emerged as a core architecture in generative modeling due to their scalability and adaptability to multimodal tasks. DiTs comprise isotropic transformer blocks, and learn representations progressively across depth, where the denoising objective drives later layers to focus on fine-detail reconstruction. This results in degraded representation quality and an imbalanced encoder-decoder behavior. Prior approaches such as representation alignment (REPA) mitigate this by encouraging stronger early representations via training regularization. Alternatively, U-Net-style DiT architectures introduce explicit multi-scale encoder-decoder structures for improved convergence. But they build on standard U-Net wisdom via learnable operators for spatial downsampling, which are not well-suited to transformer architectures, introducing inefficiencies and compatibility issues with components such as cross-attention and representation regularization. In this work, we propose UDT, a U-Net diffusion transformer that combines the representation power of DiTs with the encoding-decoding benefits of U-Nets, through data-adaptive token merging for downsampling and upsampling, while preserving the DiT token dimension. Our baseline UDT architecture outperforms existing U-Net DiTs and achieves performance comparable to REPA across all model sizes. Furthermore, using architectural optimization and REPA, UDT outperforms SiT's 7.9 FID at 1400 epochs (w/o CFG) within 40 epochs (~ 40x faster convergence) for XL model size on 256x256 ImageNet. Finally, it achieves strong image generation performance with CFG, reaching FID of 1.38 (320 epochs) with SD-VAE and 1.35 (500 epochs) with VA-VAE, providing a new backbone for DiTs with strong empirical benefits.
Primary: University of Minnesota
All Institutions: University of Minnesota
The paper presents UDT, a novel U-Net style Diffusion Transformer architecture that leverages data-adaptive token merging to achieve faster convergence and improved generative performance, offering a significant efficiency boost for training large-scale diffusion models.
The paper proposes UDT, a U-Net style Diffusion Transformer that integrates data-adaptive token merging (ToMe) for downsampling and upsampling. The core innovation lies in using token similarity to merge redundant tokens (e.g., background regions) rather than fixed spatial pooling, which preserves semantic information better than standard U-Net downsampling in transformers. The authors argue that this approach mitigates the "imbalanced encoder-decoder" problem in isotropic DiTs by explicitly creating a bottleneck while maintaining token dimensionality. The methodology is sound, leveraging existing efficient transformer techniques (ToMe) in a novel architectural context (Diffusion Transformers). The integration with REPA (Representation Alignment) is also logically derived from the preserved token resolution at the bottleneck.
The experimental evaluation is extensive and rigorous. The authors compare UDT against strong baselines including SiT, U-DiT, and REPA variants on ImageNet 256x256 and 512x512. The results demonstrate significant improvements in training efficiency (convergence speed) and final FID scores. Notably, the claim of achieving SOTA-like FID scores in a fraction of the training epochs (e.g., 40x faster convergence for XL models) is compelling and supported by detailed FID-vs-Epoch curves. The ablation studies on token merge strategies, advanced techniques (RoPE, SwiGLU), and drop-in replacement capabilities for various DiT variants (JiT, MMDiT) add robustness to the claims. The comparison with U-DiT is particularly important as it addresses the specific niche of U-Net style DiTs.
The paper provides a GitHub link to the code, which is a strong positive for reproducibility. The experimental setup closely follows established protocols (SiT, REPA), using standard optimizers, learning rates, and evaluation metrics (FID, IS). The implementation details in the appendix are sufficient for replication. The use of standard datasets (ImageNet) and pre-trained encoders (DINOv2 for REPA) further ensures that the results can be verified by the community.
The paper acknowledges limitations regarding video generation and very high-resolution (2K) images, which is standard for current DiT research. However, a potential limitation is the reliance on the ToMe algorithm's heuristic for token merging; while effective, it introduces a hyperparameter (merge rate) that needs tuning. Additionally, the performance gain in FID is partly attributed to faster convergence, meaning the "final" performance might eventually be matched by longer-trained isotropic DiTs, though the efficiency gain is the primary contribution. The paper does not extensively analyze the impact of token merging on the quality of generated samples beyond FID/IS (e.g., diversity, mode collapse), although qualitative samples are provided.
This work has significant implications for the efficiency and accessibility of training large-scale diffusion models. By reducing the computational cost and training time, UDT lowers the barrier to entry for researchers and practitioners. The architectural improvements also enhance the representational quality of DiTs, potentially benefiting downstream tasks like image editing or inpainting that rely on intermediate features. The broader impact is positive, promoting more efficient and scalable generative AI. The paper presents UDT, a novel U-Net style Diffusion Transformer architecture that leverages data-adaptive token merging to achieve faster convergence and improved generative performance, offering a significant efficiency boost for training large-scale diffusion models.
While feed-forward 3D Gaussian Splatting (3DGS) enables efficient 3D reconstruction, achieving high-fidelity rendering remains challenging. Existing pixel-aligned approaches suffer from spatial inflexibility and massive structural redundancy, whereas query-based methods lack 3D priors and entangle geometry with appearance, yielding blurry, pose-dependent results. To overcome these deficiencies, we propose \textbf{QuerySplat}, a feed-forward 3DGS framework driven by geometric priors and explicit appearance decoupling. Specifically, we design a dual-branch query-based decoder: the geometry branch leverages a pretrained Vision Geometric Model for spatial understanding, which intrinsically endows QuerySplat with pose-free modeling capabilities, while the appearance branch recovers high-frequency details through a dedicated pathway separated from geometric attribute regression. Extensive experiments demonstrate that QuerySplat mitigates the blurry rendering issues of early query-based models and consistently outperforms pixel-aligned approaches in rendering fidelity. On the challenging DL3DV benchmark, it achieves state-of-the-art novel view synthesis performance, with average PSNR gains of 2.30 dB and 1.04 dB over the best pose-free and pose-required baselines, respectively. Project Page: https://inspatio.github.io/querysplat.
Primary: InSpatio Research
All Institutions: InSpatio Research
QuerySplat presents a robust and effective solution to the challenges of feed-forward 3DGS by leveraging geometric priors from VGMs and decoupling attribute prediction, achieving state-of-the-art results on challenging benchmarks and advancing the field of pose-free novel view synthesis.
The paper proposes QuerySplat, a feed-forward 3D Gaussian Splatting (3DGS) framework that decouples geometry and appearance prediction using a dual-branch query-based decoder. The core innovation lies in leveraging a frozen pretrained Vision Geometric Model (VGM, specifically VGGT) to provide geometric priors and a self-calibrated coordinate system, enabling pose-free reconstruction. The geometry branch predicts spatial attributes (center, scale, rotation) while a separate appearance branch predicts opacities and colors. This design addresses the entanglement issues in previous query-based methods (like TokenGS) and the spatial inflexibility of pixel-aligned methods. The methodology is technically sound, combining established components (VGMs, 3DGS, query decoders) in a novel architectural arrangement. The use of transient early-stage regularization (Chamfer distance to VGM depth, opacity floor) is a practical engineering contribution to stabilize training.
The evaluation is conducted on the DL3DV benchmark, a large-scale and challenging dataset for novel view synthesis. The paper reports State-of-the-Art (SOTA) performance in terms of PSNR, SSIM, and LPIPS across 2, 4, and 12-view settings compared to recent posed and pose-free baselines (DepthSplat, TokenGS, YoNoSplat, etc.). The gains are significant (e.g., +2.30 dB PSNR over the best pose-free baseline). Qualitative results demonstrate sharper textures and better geometric coherence. The inclusion of an optional Test-Time Optimization (TTO) module further boosts performance, showing flexibility. The ablation studies effectively validate the contributions of the dual-branch design, regularization, and VGM backbone.
The paper provides detailed implementation details, including the VGM backbone (VGGT), query counts, training schedules, and loss functions. The use of a standard benchmark (DL3DV) and standard metrics facilitates comparison. However, as an arXiv preprint without an accompanying public code repository link (only a project page is listed), immediate reproducibility is slightly hindered, though the description is sufficiently detailed for a competent researcher to implement. The reliance on a specific VGM (VGGT) means results are tied to that model's availability.
The paper acknowledges that the method relies on the quality of the underlying VGM. If the VGM fails to estimate accurate geometry or poses (e.g., in textureless regions or extreme occlusions), the reconstruction may suffer. The computational cost of using a large VGM encoder (VGGT) is not explicitly quantified in terms of inference time compared to lighter baselines, though it is described as "feed-forward." The method is currently evaluated primarily on the DL3DV dataset; generalization to other domains (e.g., indoor vs. outdoor, synthetic vs. real) is implied but not exhaustively proven. The "pose-free" capability is dependent on the VGM's pose estimation accuracy.
This work contributes to the democratization of 3D content creation by enabling high-fidelity 3D reconstruction from unposed, sparse image collections without per-scene optimization. This has significant implications for robotics, augmented reality, and digital twins where rapid, accurate 3D understanding from casual captures is crucial. By decoupling geometry and appearance, it also offers a more modular approach to 3D scene representation that could inspire future research in neural rendering. QuerySplat presents a robust and effective solution to the challenges of feed-forward 3DGS by leveraging geometric priors from VGMs and decoupling attribute prediction, achieving state-of-the-art results on challenging benchmarks and advancing the field of pose-free novel view synthesis.
Long-context reasoning remains a critical bottleneck for large language models, as recent recurrent-memory approaches face two inherent challenges: sequential chunk-wise updates can overwrite early critical evidence with later irrelevant content, and serial inter-chunk dependencies limit parallelism and cause latency to increase with context length. To address these issues, we propose PI-Mem (Parallel-Iterative Memory), a mechanism that processes all chunks in parallel and iteratively refines a shared memory over a bounded number of turns. In each turn, PI-Mem reads all chunks in parallel conditioned on the current memory, selects new or complementary evidence from each chunk, and merges the selected evidence into a compact shared memory for the next turn. To discourage redundant turns, we optimize the workflow through reinforcement learning with an auxiliary turn-efficiency reward, enabling the model to adaptively exit once sufficient evidence has been accumulated. We evaluate PI-Mem with Qwen3.5-35B-A3B and Qwen2.5-7B on the HotpotQA benchmark across context lengths up to 3.6 million tokens and find that it outperforms the recurrent-memory baseline by +6.25 and +7.81 absolute points while achieving 6.1$\times$ and 2.1$\times$ inference speedups, respectively. These results demonstrate that PI-Mem breaks the accuracy--efficiency trade-off in long-context reasoning and provides a scalable approach to complex multi-hop question answering over extremely long documents.
Primary: Shanghai Artificial Intelligence Laboratory
All Institutions: Shanghai Artificial Intelligence Laboratory, National Natural Science Foundation of China, China Postdoctoral Science Foundation
[One sentence main contribution]. PI-Mem introduces a parallel-iterative memory mechanism that processes document chunks in parallel and iteratively refines a shared memory via RL-optimized read-select-merge cycles, achieving state-of-the-art accuracy and efficiency for long-context reasoning. [Comprehensive analysis of the technical contribution, methodology, and significance to the field]. The paper presents a robust solution to the accuracy-efficiency trade-off in long-context LLM reasoning. By decoupling chunk processing from sequential memory updates, PI-Mem leverages parallel compute effectively while maintaining the benefits of iterative evidence consolidation. The integration of RL with a turn-efficiency reward is a clever way to manage the computational cost of multiple turns. The empirical results are compelling, demonstrating not just accuracy gains but also significant latency reductions, which are critical for practical deployment. The work is significant for the NLP community, offering a viable alternative to native long-context extensions and traditional RAG pipelines.
The paper proposes PI-Mem, a parallel-iterative memory mechanism for long-context reasoning. It addresses the sequential bottleneck of recurrent memory models by processing all document chunks in parallel within each turn, conditioned on a shared global memory. The core innovation lies in the "read-select-merge" cycle: chunks are read in parallel, relevant evidence is selected via a check signal, and evidence is merged into a compact memory state. This process iterates until convergence or a max-turn limit. The workflow is optimized end-to-end using Reinforcement Learning (specifically GRPO) with an auxiliary turn-efficiency reward to discourage redundant turns. The approach is technically sound, leveraging existing LLM capabilities (parallel inference, instruction following) to create a more efficient retrieval-augmented reasoning loop. While the concept of iterative refinement is not new, applying it to parallel chunk processing with an RL-driven adaptive exit mechanism is a meaningful architectural contribution.
The evaluation is extensive, testing on HotpotQA (via RULER benchmark) at context lengths up to 3.6 million tokens and on LongBench v2. The authors compare against strong baselines including Vanilla, YaRN, RAG, MemAgent, GRU-Mem, and ReMemR1. Results show significant improvements in accuracy (e.g., +6.25 points over MemAgent on HQA at 3.6M tokens) and substantial inference speedups (6.1x faster than MemAgent). The ablation studies effectively demonstrate the necessity of the select and merge components, as well as the impact of the turn-efficiency reward. The evidence retention analysis (Needle-in-a-Haystack) provides strong diagnostic evidence for the claim that parallel reading prevents evidence overwriting. The experiments are rigorous and cover a wide range of context lengths, which is critical for this domain.
The paper provides a GitHub link to the code repository. The methodology is described in detail, including the RL training setup (GRPO, reward functions, hyperparameters). The use of standard benchmarks (RULER, LongBench v2) and open-source models (Qwen3.5, Qwen2.5) enhances reproducibility. However, the specific synthetic data generation protocol (embedding HotpotQA paragraphs into distractors) is described but might require careful implementation to exactly replicate. The code release is a strong positive for reproducibility.
The paper notes that LongBench v2 results were only reported for Qwen3.5 because Qwen2.5 performed at random guessing levels, which limits the generalizability of the LongBench findings. The method relies on the model's ability to follow complex multi-step instructions (read, select, merge), which may be sensitive to model capability; thus, the gains are likely larger for stronger base models. The parallel approach assumes that the context can be split into independent chunks, which might not hold for tasks requiring strict sequential understanding across chunk boundaries (though the iterative refinement helps mitigate this). The "controlledPI-Mem" notation in tables suggests some variant or specific configuration, which should be clarified.
This work contributes to the scalability of LLMs for long-context applications, potentially reducing costs and latency for processing massive documents. This has implications for legal, medical, and scientific research where long-document analysis is crucial. The efficiency gains could make long-context reasoning more accessible. There are no significant negative societal impacts identified, other than the standard concerns about LLM hallucination, which the method aims to mitigate through grounding. [One sentence main contribution]. PI-Mem introduces a parallel-iterative memory mechanism that processes document chunks in parallel and iteratively refines a shared memory via RL-optimized read-select-merge cycles, achieving state-of-the-art accuracy and efficiency for long-context reasoning. [Comprehensive analysis of the technical contribution, methodology, and significance to the field]. The paper presents a robust solution to the accuracy-efficiency trade-off in long-context LLM reasoning. By decoupling chunk processing from sequential memory updates, PI-Mem leverages parallel compute effectively while maintaining the benefits of iterative evidence consolidation. The integration of RL with a turn-efficiency reward is a clever way to manage the computational cost of multiple turns. The empirical results are compelling, demonstrating not just accuracy gains but also significant latency reductions, which are critical for practical deployment. The work is significant for the NLP community, offering a viable alternative to native long-context extensions and traditional RAG pipelines.
Audio-encoder-LLM-decoder architectures have become the dominant paradigm for modern automatic speech recognition (ASR), improving transcription quality through large-scale language modeling. However, the cost of autoregressive decoding scales with decoder size, creating a fundamental trade-off between recognition quality and serving latency. We argue this trade-off is not inherent: unlike open-ended text generation, ASR outputs are strongly anchored to the input speech signal, providing a natural inductive bias toward high-parallelism decoding. Building on this, we introduce ParaASR, an ASR system that leverages Multi-Token Prediction (MTP) to let a 4B LLM decoder emit multiple tokens per forward step. Starting from a publicly available audio-language foundation, the model first establishes a robust autoregressive recognizer and then aligns five future-token branches through a staged optimization recipe. At inference, it proposes a six-token continuation per step and admits only the verified prefix into the transcript, preserving the safety of standard autoregressive decoding. The average accepted length reaches 5.0 out of 6 proposed tokens, confirming that the deterministic structure of speech makes ASR an especially natural setting for multi-token decoding. ParaASR further retains a native 32K-context window and transcribes up to 30 minutes of audio in a single pass. Across diverse benchmarks, it attains average error rates of 2.97%, 3.68%, and 3.70% on Chinese, English, and long-form evaluations, respectively, while reaching a real-time factor (RTF) as low as 0.0053. These results show that decoder scaling, low-latency inference, and long-context transcription need not be competing goals when future-token proposals are anchored by the acoustic signal and guarded by autoregressive verification.
Primary: StepFun
All Institutions: StepFun, NTU, PKU, UNSW, SJTU, USTC
ParaASR presents a practical and effective method for accelerating LLM-based ASR through multi-token prediction, achieving significant latency reductions while maintaining high accuracy, thereby addressing a critical bottleneck in deploying large-scale speech recognition systems. The work demonstrates that leveraging the deterministic structure of speech allows for efficient parallel decoding, offering a viable path to low-latency, high-quality ASR without the prohibitive costs of autoregressive decoding.
The paper proposes ParaASR, a method to accelerate LLM-based Automatic Speech Recognition (ASR) by leveraging Multi-Token Prediction (MTP). The core insight is that ASR outputs are strongly constrained by the input audio, allowing the model to predict multiple future tokens in a single forward pass. The methodology involves a two-stage process: first, training a standard autoregressive recognizer on a 4B parameter audio-language foundation model; second, aligning five future-token branches through staged optimization. At inference, the model proposes six tokens per step, and an autoregressive verification step (likely a small verifier or self-consistency check) admits the verified prefix. This approach aims to decouple latency from decoder size while maintaining accuracy. The approach is technically sound and builds on recent trends in speculative decoding and multi-token prediction, adapting them specifically for the acoustic-linguistic alignment problem in ASR.
The evaluation covers Chinese, English, and long-form benchmarks. The reported results show low error rates (2.97%, 3.68%, 3.70%) and a significant speedup with a Real-Time Factor (RTF) as low as 0.0053. The average accepted length of 5.0 out of 6 proposed tokens is a strong indicator of the effectiveness of the multi-token prediction in this domain. The experiments demonstrate that the method retains a 32K context window and can handle long audio (30 minutes) in a single pass. The results are compelling and suggest a practical improvement in serving efficiency for LLM-based ASR systems. However, the lack of comparison against other recent speculative decoding or parallel decoding methods in ASR (e.g., parallel decoding with conformers, or other MTP variants) limits the ability to fully gauge the relative novelty and superiority of the specific implementation details.
The paper mentions starting from a "publicly available audio-language foundation," which aids reproducibility. However, specific details on the staged optimization recipe, the architecture of the verifier, and the exact hyperparameters for the multi-token training are often less detailed in such applied papers. Without open-source code or a very detailed appendix, full reproducibility might be challenging. The authors are from StepFun, a major AI lab, which suggests high-quality engineering, but the academic rigor of the reporting needs to be verified against the full text's technical depth.
The primary limitation is the reliance on a specific foundation model architecture. The performance gain is tied to the quality of the pre-trained model and the effectiveness of the MTP alignment. Additionally, the "verification" step, while fast, adds some overhead and potential error propagation if the verifier is not perfect. The paper does not extensively discuss failure modes or cases where the multi-token prediction fails significantly. The focus on latency reduction might come at the cost of slightly higher training complexity or data requirements for the multi-token branches.
This work has significant implications for the deployment of LLM-based ASR systems, making them more cost-effective and scalable for real-time applications. By reducing latency without sacrificing accuracy, it enables new use cases in voice assistants, live transcription, and accessibility tools. The insight that ASR is a natural setting for multi-token prediction due to acoustic anchoring is a valuable theoretical contribution that could influence future research in other structured prediction tasks. ParaASR presents a practical and effective method for accelerating LLM-based ASR through multi-token prediction, achieving significant latency reductions while maintaining high accuracy, thereby addressing a critical bottleneck in deploying large-scale speech recognition systems. The work demonstrates that leveraging the deterministic structure of speech allows for efficient parallel decoding, offering a viable path to low-latency, high-quality ASR without the prohibitive costs of autoregressive decoding.
Recent data-driven methods for synthesizing 6-DoF grasp poses use generative models to learn complex grasp pose distributions and generate diverse candidate poses. In particular, SE(3)-equivariant flow-based models generate grasp poses that transform consistently with object rotations and translations. However, these methods sample by iterative numerical integration, requiring tens of function evaluations per grasp and limiting their use in real-time manipulation. We propose GraspMeanFlow, an SE(3)-equivariant MeanFlow framework for few-step 6-DoF grasp generation. Our method learns the average velocity over a finite time interval, defined through the time-ordered exponential so that it reproduces exactly the rigid-body displacement accumulated over that interval. We prove that a point-cloud-conditioned distribution transported by an equivariant average-velocity flow map remains invariant, so equivariance is retained under few-step sampling, and we condition the field on a pair of times by lifting both to equivariant vectors, leaving the backbone otherwise unchanged. For stable training, we pair a flow-matching boundary term with either of two consistency terms: the differential MeanFlow identity, whose target requires a Jacobian-vector product, or an equivalent semigroup loss that avoids it. Experiments on ACRONYM show that a single function evaluation of GraspMeanFlow reaches the EMD that an iterative SE(3) flow model needs five steps to approach, that a second instantiation of the same framework improves grasp success by up to 24.3 points in the few-step regime, and that both generate grasp distributions transforming exactly with the object.
Primary: National Science Foundation / U.S. Department of of Energy (Affiliations not explicitly listed in text, but funding sources indicate US Government Labs/Universities)
All Institutions: National Science Foundation, U.S. Department of Energy, DOE Office of Science, SciDAC LEADS Institute
GraspMeanFlow presents a robust and theoretically sound extension of flow matching to SE(3), offering a practical solution for few-step, equivariant grasp generation that significantly outperforms existing iterative methods in efficiency and success rate.
The paper proposes GraspMeanFlow, an SE(3)-equivariant generative model for 6-DoF grasp pose synthesis. The core technical contribution is the adaptation of MeanFlow (average-velocity flow matching) to the SE(3) manifold. The authors address the non-commutative nature of SO(3) by defining average velocity via the time-ordered exponential, ensuring that the learned Lie-algebra element reproduces the exact rigid-body displacement over a finite interval. They provide theoretical proofs for equivariance preservation under few-step sampling and propose two training objectives: a differential MeanFlow identity (requiring Jacobian-vector products) and a semigroup consistency loss (JVP-free). The methodology is mathematically rigorous, correctly handling the geometric constraints of the special Euclidean group. The approach effectively bridges the gap between high-fidelity continuous normalizing flows and the efficiency requirements of real-time robotic manipulation.
The evaluation is conducted on the ACRONYM dataset, comparing against strong baselines including EquiGraspFlow, SE(3)-DiffusionFields, and BRIDGER. The results demonstrate significant improvements in few-step regimes (NFE=1 to 5). Specifically, GraspMeanFlow achieves higher grasp success rates (up to 24.3 points improvement over EquiGraspFlow at NFE=5) and lower Earth Mover's Distance (EMD) with fewer function evaluations. The ablation studies effectively isolate the contribution of the consistency terms and the coupling strategies. The inclusion of both distributional fidelity (EMD) and task-specific performance (simulated lift success) provides a comprehensive view of the model's utility. The latency analysis further supports the practical value of the method for real-time applications.
The paper provides detailed mathematical derivations, including the handling of the left Jacobian and the time-ordered exponential. The implementation details are clear, noting the use of the EquiGraspFlow backbone and specific training schedules (warm-up with $\alpha$-Flow). The authors mention using publicly released checkpoints for baselines and a consistent evaluation protocol. However, the code is not explicitly linked in the provided text (URL extraction returned none), which slightly hinders immediate reproducibility, though the methodological description is sufficient for implementation by experts in geometric deep learning.
The authors acknowledge limitations regarding objects with high symmetry (e.g., Pencil), where the displacement target may treat physically equivalent orientations as distinct errors. They also note that the endpoint-style sampler requires careful scheduling and that post-training on self-generated samples had mixed results. The method's performance degrades relative to iterative baselines at very high step counts (NFE=20), as the iterative solvers can integrate the instantaneous field more accurately when computational budget is not constrained.
This work has significant implications for robotic manipulation, particularly in scenarios requiring real-time decision-making. By enabling high-quality grasp generation with minimal computational overhead, it facilitates more responsive and robust autonomous systems. The theoretical framework for equivariant average-velocity flow matching on manifolds may also inspire applications in other domains involving rigid body dynamics or geometric data generation, such as protein structure prediction or molecular dynamics. GraspMeanFlow presents a robust and theoretically sound extension of flow matching to SE(3), offering a practical solution for few-step, equivariant grasp generation that significantly outperforms existing iterative methods in efficiency and success rate.
World Action Models (WAMs) couple action generation with prediction of future states. Their effectiveness depends on whether future dynamics are modeled in a space that is both aligned with action generation and sufficiently geometry-aware to capture where and how actions change the scene. Existing WAMs typically satisfy only part of this requirement, relying on either perceptually heavy observation-space targets or auxiliary latent spaces that are not jointly structured for action relevance and geometry. We propose SG-WAM, a self-guided framework that learns geometry-aware action-conditioned dynamics directly in the policy-derived representation space. SG-WAM introduces learnable dynamics tokens and a Self-Guided World Predictor that forecasts their future latent states conditioned on intervening robot actions. Prediction targets are generated by an exponential moving average copy of the same policy backbone, providing stable supervision within the representation family used by the action expert. Geometric supervision further structures the policy image-token representations, providing spatially grounded context for the dynamics tokens and yielding a future-alignment space that is both action-relevant and geometry-aware. Latent future prediction, geometric grounding, and flow-matching action generation are jointly optimized end-to-end in a unified framework. Built on a 0.9B model without large-scale embodied pretraining, SG-WAM achieves 98.5% average success on LIBERO and 73% on LIBERO-Plus, while outperforming strong baselines in both in-distribution and out-of-distribution real-world evaluations.
Primary: Nanyang Technological University
All Institutions: Nanyang Technological University, National University of Singapore, The University of Hong Kong
SG-WAM presents a novel self-guided world modeling framework that effectively integrates geometric supervision into policy-derived latent spaces, achieving state-of-the-art results on standard robotic manipulation benchmarks with a moderately sized model.
The paper proposes SG-WAM, a framework for world modeling in robotics that integrates action generation with future state prediction. The core innovation lies in learning dynamics directly within the policy-derived representation space using "dynamics tokens." It employs a Self-Guided World Predictor that forecasts future latent states conditioned on robot actions, using an exponential moving average (EMA) copy of the policy backbone for stable supervision. Crucially, it introduces geometric supervision to structure these representations, aiming to create a space that is both action-relevant and geometry-aware. The method combines latent future prediction, geometric grounding, and flow-matching action generation in a unified end-to-end optimization. While the integration of geometric priors into latent world models is a known direction, the specific mechanism of self-guided supervision within the policy space to align action and geometry is a distinct methodological contribution.
The evaluation focuses on the LIBERO and LIBERO-Plus benchmarks, which are standard for long-horizon robotic manipulation tasks. The reported results are 98.5% average success on LIBERO and 73% on LIBERO-Plus. These results are competitive, particularly on LIBERO, suggesting the method is effective for in-distribution tasks. The paper claims outperformance of strong baselines in both in-distribution and out-of-distribution real-world evaluations. However, the abstract-only score of 60 suggests the initial impression was moderate, and the full text analysis confirms that while the results are strong, they do not represent a paradigm shift in performance (e.g., solving previously unsolvable tasks) but rather an incremental improvement in efficiency and generalization via better representation learning. The use of a 0.9B model without large-scale embodied pretraining is a notable efficiency claim, appealing to resource-constrained settings.
The paper describes the architecture (0.9B model), training objectives (joint optimization of prediction, geometric grounding, and action generation), and benchmarks (LIBERO). However, as an arXiv preprint, the availability of code is not guaranteed, and the URL extraction found none. The description of the "geometric supervision" and "dynamics tokens" provides sufficient detail for a competent researcher to attempt reproduction, but the lack of explicit hyperparameters or code links reduces immediate reproducibility confidence.
The primary limitation is the reliance on the LIBERO suite, which, while standard, may not fully capture the complexity of real-world unstructured environments. The claim of "out-of-distribution real-world evaluations" is significant but requires scrutiny of the specific distribution shifts tested. Furthermore, the complexity of jointly optimizing three distinct objectives (prediction, geometry, action) may introduce training instability or require careful tuning, which is not fully detailed in the abstract. The performance drop on LIBERO-Plus (73%) compared to LIBERO (98.5%) suggests limitations in handling more complex or varied tasks.
This work contributes to the field of embodied AI by providing a more efficient and geometry-aware approach to world modeling, which is critical for sample-efficient learning in robotics. By reducing reliance on large-scale pretraining, it makes advanced world modeling more accessible. The alignment of action and geometry in latent space could lead to more robust and interpretable robotic policies. SG-WAM presents a novel self-guided world modeling framework that effectively integrates geometric supervision into policy-derived latent spaces, achieving state-of-the-art results on standard robotic manipulation benchmarks with a moderately sized model.
Modern GPUs rely on private per-SM L1 caches and a shared L2 cache, but this organization obscures cross-SM reuse: an L1 miss is typically forwarded to L2 even when the requested line already resides in a peer L1 cache, leading to redundant L2 access. Prior GPU L1-sharing designs attempt to recover such reuse through exact or broad remote-hit searches, which become increasingly difficult to scale and can interfere with the critical L1 miss path under high concurrency. %miss handling as more caches participate and more misses arrive concurrently. We observe that eliminating redundant L2 accesses does not require exact, chip-wide knowledge of private L1 contents. Instead, it requires only sufficient visibility to sharply narrow down a small set of candidate caches, leaving exact confirmation to a much smaller number of L1s. Based on this insight, we propose C2P-Cache, a scalable GPU L1-sharing mechanism that transforms remote-hit discovery from a chip-wide exact search problem into a lightweight filtering-and-confirmation process. C2P-Cache maintains compact Bloom-filter-based snapshots of private L1 tags, performs parallel chip-wide candidate filtering, and selectively probes only a small number of likely peer caches. To sustain high concurrency, C2P-Cache organizes filtering as bit-sliced matching over a banked and replicated snapshot matrix, enabling efficient, parallel processing of many concurrent misses without interfering with normal L1 accesses. Across a wide range of GPU workloads, C2P-Cache improves instructions per cycle (IPC) by up to 49.7\% and by 23.5\% on average for applications with high remote-L1 reuse and strong sensitivity to L2 latency, demonstrating that lightweight, scalable filtering can effectively unlock cross-SM reuse with modest overhead.
Primary: National University of Defense Technology
All Institutions: National University of Defense Technology
C2P-Cache introduces a scalable GPU L1 cache sharing mechanism that utilizes Bloom-filter-based snapshots to prune remote-hit candidates, significantly reducing redundant L2 accesses and improving IPC for memory-intensive workloads while maintaining low overhead and high concurrency.
The paper proposes C2P-Cache, a hardware mechanism for GPU L1 cache sharing. The core innovation is replacing exact, chip-wide remote hit searches with a probabilistic filtering stage using Bloom filters. Specifically, it maintains a "Snapshot Matrix" of Bloom filter states for all SMs. When an L1 miss occurs, the system performs a Boolean matrix multiplication (logical AND reduction) between the miss query (Access Matrix) and the Snapshot Matrix to identify candidate SMs. Only these candidates are probed for exact tag confirmation. This transforms a high-latency, high-contention search problem into a lightweight filtering-and-confirmation pipeline. The design includes specific optimizations for high concurrency, such as bit-sliced matching and a banked/replicated Snapshot Matrix organization to handle worst-case lookup demands without interfering with normal L1 accesses. The methodology is sound, leveraging well-known probabilistic data structures (Bloom filters) in a novel architectural context (GPU cache hierarchy) to solve a specific scalability bottleneck.
The evaluation is conducted using Accel-Sim, a standard cycle-level GPU simulator. The authors evaluate 24 workloads from ISPASS, Rodinia, Parboil, PolyBench, and Pannotia. They compare C2P-Cache against a baseline (no sharing) and three prior works (ATA, CCD, RING). Results show significant IPC improvements (up to 49.7%, avg 23.5% for sensitive workloads) and substantial L2 access reduction (avg 46.6%). The paper provides a thorough sensitivity analysis covering BF parameters, matching latency, remote return latency, and SM scaling. The results are consistent and demonstrate that C2P-Cache outperforms prior art in both performance and scalability, particularly as the number of SMs increases. The inclusion of power and area overhead estimates adds credibility to the practical feasibility assessment.
The paper provides detailed descriptions of the hardware components (BF Engine, Snapshot Matrix organization, addressing schemes) and simulation parameters (latencies, BF sizes, hash functions). The use of Accel-Sim and standard benchmarks allows for potential reproduction. However, the specific implementation details of the BF hash functions and the exact timing models for the Snapshot Matrix SRAM (modeled via CACTI) are abstracted. While sufficient for architectural researchers to reproduce the study, full bit-level reproducibility would require access to the specific Accel-Sim fork and CACTI configuration files, which are not explicitly linked but are standard practice in the field.
The primary limitation is the reliance on probabilistic filtering, which introduces false positives (unnecessary probes) and false negatives (missed reuse opportunities). The paper acknowledges this and shows that the impact is manageable, but in extreme cases, false positives can add latency. Additionally, the design assumes a specific GPU microarchitecture (banked L1s, specific interconnect) which may not generalize to all GPU designs without adaptation. The "Snapshot Matrix" consumes significant on-chip SRAM (estimated 40KB logical, though physical implementation details vary), which might be a constraint for smaller GPUs. The venue date (2026) is an anomaly, suggesting this might be a very recent acceptance or a metadata error, but the technical content is current.
This work addresses a fundamental scalability issue in modern GPUs: memory bandwidth and latency bottlenecks caused by private L1 caches. By enabling efficient cross-SM data reuse, C2P-Cache can improve performance for a wide range of parallel applications, including AI/ML workloads (Transformers, CNNs) and HPC applications (stencils, linear algebra). This contributes to the broader goal of making GPU architectures more efficient and scalable as core counts increase. It also highlights the value of probabilistic data structures in hardware design for system-level optimization. C2P-Cache introduces a scalable GPU L1 cache sharing mechanism that utilizes Bloom-filter-based snapshots to prune remote-hit candidates, significantly reducing redundant L2 accesses and improving IPC for memory-intensive workloads while maintaining low overhead and high concurrency.