Last 7 Days (September 10 – September 16, 2026)
Robot foundation models achieve strong in-distribution performance but often degrade under visual distribution shifts. When learning to generate actions from pretrained visual representations, models may exploit task-irrelevant visual cues that correlate with demonstrated actions within the training distribution. Such vision-action shortcuts can undermine generalization when these correlations change under distribution shifts. Mitigating these shortcuts requires constraining how visual information is used for action generation while preserving task-relevant spatial information. We propose Latent Interface Training (LIT), a framework-agnostic two-stage strategy that first establishes a spatial-goal-conditioned action prior without images, then constrains visual conditioning through a pose-supervised latent interface. Stage 1 trains the action expert to generate action chunks conditioned on language, robot state, and each demonstrated chunk's terminal SE(3) end-effector pose, learning goal-directed action generation independently of visual cues. Stage 2 introduces a latent interface that aggregates visual and semantic representations and serves as the pretrained action expert's only visual conditioning pathway. The interface is supervised to reconstruct the terminal pose previously used to condition Stage 1, encouraging it to retain the goal-relevant spatial information needed for action generation. Across four vision-language-action and world-action architectures (Pi0.5, MolmoAct2, FAST-WAM, and ImageWAM), LIT improves overall LIBERO-Plus success by 3.87-10.70 percentage points while preserving or improving average LIBERO success. Real-world evaluations show 13.30-16.70 percentage-point gains in success aggregated across three tasks under unseen camera configurations, lighting variations, and distractors.
Primary: National University of Singapore (MagicLab)
All Institutions: National University of Singapore
The paper introduces Latent Interface Training (LIT), a two-stage strategy that mitigates vision-action shortcuts in robot foundation models by decoupling goal-directed action learning from visual conditioning and supervising a latent interface with terminal pose. This approach demonstrates significant improvements in generalization across multiple architectures and real-world distribution shifts, offering a practical and effective solution to a critical challenge in deploying robotic foundation models.
The paper proposes Latent Interface Training (LIT), a two-stage framework designed to mitigate "vision-action shortcuts" in robot foundation models. The core idea is to decouple the learning of goal-directed action generation from visual conditioning. Stage 1 trains an action expert to generate actions based on language, robot state, and terminal SE(3) pose, effectively creating a spatial-goal-conditioned prior without relying on images. Stage 2 introduces a latent interface that aggregates visual and semantic representations, supervised to reconstruct the terminal pose used in Stage 1. This forces the visual pathway to retain only goal-relevant spatial information, filtering out task-irrelevant visual cues. The method is framework-agnostic, applied to Pi0.5, MolmoAct2, FAST-WAM, and ImageWAM. The methodology is sound and addresses a known issue in robotics foundation models (over-reliance on spurious visual correlations).
The paper evaluates LIT across four different architectures on the LIBERO-Plus benchmark, reporting improvements of 3.87-10.70 percentage points in success rates while maintaining or improving average LIBERO success. Real-world evaluations show significant gains (13.30-16.70 percentage points) under distribution shifts such as unseen camera configurations, lighting variations, and distractors. The breadth of architectures tested is a strength, demonstrating the generalizability of the training strategy. However, the specific details of the real-world setup and the magnitude of the baseline performance are not fully detailed in the provided text, making it hard to assess the absolute difficulty of the tasks.
The paper provides a project page link. The method is described as a training strategy rather than a complex new architecture, which generally aids reproducibility. However, without access to the full code and specific hyperparameters for the "latent interface" and the exact implementation details of the pose supervision, full reproducibility is difficult to guarantee. The use of standard benchmarks like LIBERO helps.
The primary limitation is the reliance on terminal SE(3) pose as the supervisory signal for the latent interface. This assumes that the terminal pose is a sufficient proxy for the goal-relevant spatial information needed for all action chunks, which may not hold for highly complex or long-horizon tasks where intermediate spatial states are critical. Additionally, the method adds a two-stage training process, which may increase computational overhead compared to single-stage training.
This work has significant potential for the robotics community, as improving generalization under visual distribution shifts is a major bottleneck for deploying foundation models in real-world environments. By providing a framework-agnostic training strategy, it can be applied to a wide range of existing VLA models. The insights into mitigating shortcut learning in multimodal robotics are valuable for the broader field of embodied AI. The paper introduces Latent Interface Training (LIT), a two-stage strategy that mitigates vision-action shortcuts in robot foundation models by decoupling goal-directed action learning from visual conditioning and supervising a latent interface with terminal pose. This approach demonstrates significant improvements in generalization across multiple architectures and real-world distribution shifts, offering a practical and effective solution to a critical challenge in deploying robotic foundation models.
Agent usage is shifting toward long-horizon tasks such as coding and scientific discovery, among which terminal tasks are especially important. We introduce T1, a Mixture-of-Experts model of 122B total trained with reinforcement learning, operating a real shell in a cloud sandbox for up to 300+ tool-call turns per task, rewarded by executing each task's own verifier. We provide a comprehensive recipe: First, an aggressively warm-started to stabilize actor-critic training, with a dense process reward scoring trajectories by the absolute number of passing verifiers. Second, stable optimization through TITO construction, training on the exact sampled token identifiers with drift repair at turn boundaries, and rollout routing replay, recording the sampler's per-token expert choices at every MoE layer and replaying them during training. Third, fully out-of-distribution training corpus: isolated seeds and synthesized tasks disjoint from Terminal-Bench 2.1 ensures gains reflect genuine capability transfer over benchmark overfitting. Together, TITO and R3 cut the training-to-inference log-probability difference from 0.021 to 0.013, with exactly aligned zero token drift in the loss region. On Terminal-Bench 2.1, our post-train pipeline raises initial base model from 43.8% to T1 with 64.0% resolved. On Long-Horizon Terminal Bench, T1 reaches 27.9% and surpasses GPT-5.4 and GLM-5.1.
Primary: Alibaba Group
All Institutions: Alibaba Group, Tsinghua University
The paper presents a comprehensive and technically rigorous approach to training large MoE agents via RL, introducing novel stabilization techniques (TITO and R3) that are critical for scaling RL to sparse models. Its strong empirical results on terminal benchmarks demonstrate a significant leap in autonomous software engineering capabilities, establishing a new standard for long-horizon agentic tasks.
The paper introduces a robust framework for training large Mixture-of-Experts (MoE) models using Reinforcement Learning (RL) in long-horizon, stateful environments (Linux terminals). The core technical contribution is the "TITO" (Token-In-Token-Out) and "R3" (Rollout Routing Replay) mechanisms. TITO addresses the training-inference mismatch caused by tokenization drift in multi-turn agentic loops by ensuring the trainer consumes the exact token identifiers generated by the sampler, repairing boundary discrepancies. R3 addresses the unique challenge of MoE models where discrete expert routing decisions made during inference can differ from those recomputed during training due to numerical precision differences; R3 records the expert masks during rollout and replays them during the training forward pass. Additionally, the paper proposes a dense process reward based on the absolute number of passing verifier assertions, which provides a much richer learning signal than binary success/fail rewards for difficult tasks. The methodology is rigorous, addressing specific, non-trivial engineering challenges in scaling RL to sparse models.
The experiments are extensive, utilizing a 122B parameter MoE model (Qwen3.5-122B-A10B) trained on 15,000 synthesized terminal tasks. The evaluation is conducted on three held-out benchmarks: Terminal-Bench 2.1, Long-Horizon Terminal-Bench (LHTB), and Terminal-Bench Hard. The results show a significant improvement from the base model (43.8%) to the final T1 model (64.0%) on Terminal-Bench 2.1, surpassing several frontier models like GPT-5.4 and GLM-5.1. The ablation studies clearly demonstrate the necessity of both TITO and R3 for stabilizing training, as well as the benefit of the dense reward over binary rewards. The analysis of training dynamics, including explained variance and turn count growth, provides deep insight into the learning process.
The paper provides high levels of detail regarding the training infrastructure, hyperparameters, and specific mechanisms like the routing replay algorithm. It describes the dataset construction process (RST) and the audit criteria for task selection. However, the specific code for the TITO and R3 implementations is not explicitly linked in the provided text (though likely available via the authors' repositories), and the exact hardware configuration for the 122B model training is only partially detailed. The use of proprietary or specific internal tools (like the "slime" framework) may limit immediate reproducibility for external labs without access to those specific infrastructure components.
The primary limitation is the reliance on a large-scale, proprietary infrastructure to train a 122B MoE model, making the results difficult to replicate for smaller labs. The evaluation is limited to terminal tasks, and while the paper argues for generalization, the specific domain of Linux shell operations is narrow. Additionally, the paper acknowledges that the model still struggles with the hardest tasks (Terminal-Bench Hard) compared to some larger dense models, and the "inefficient search" behavior (high turn counts) suggests that the model has not fully mastered optimal planning, merely improving its persistence and partial success rates.
This work is significant for the development of autonomous agents capable of performing complex, long-horizon software engineering tasks. By solving the stability issues of RL in MoE models, it paves the way for more efficient and capable agentic systems. The dense reward design is a valuable contribution to the RL community, offering a practical solution to the sparse reward problem in verifiable environments. The findings on training-inference consistency in sparse models will be relevant to any group working on large-scale MoE RL. The paper presents a comprehensive and technically rigorous approach to training large MoE agents via RL, introducing novel stabilization techniques (TITO and R3) that are critical for scaling RL to sparse models. Its strong empirical results on terminal benchmarks demonstrate a significant leap in autonomous software engineering capabilities, establishing a new standard for long-horizon agentic tasks.
Determinism and numerical reproducibility are increasingly required of GPU kernels in machine learning systems, yet deterministic implementations of the same kernel can still differ bit for bit. Floating-point reduction order is the primary cause, alongside partial-sum precision, fused multiply-add operations, and rounding placement. These choices may be hand-coded, selected by a block-level language such as Triton, or hidden inside a closed-source library such as cuBLAS or rocBLAS. A tile shape chosen for performance therefore also determines the arithmetic, potentially breaking batch invariance. Preserving a fixed order can cost up to 20 percent, while an autotuner cannot identify which configurations are bitwise equivalent. We characterize the factors determining the bitwise behavior of reductions and general matrix multiplication (GEMM). First, we introduce a descriptor of GEMM reduction order, including the partitioning of K in split-K GEMM. Using it, we perform the first black-box reconstruction of a closed-source library's arithmetic for bit-level correctness. Our family of Triton GEMMs matches NVIDIA cuBLAS in all tested cases on Blackwell and Hopper. For realistic LLM shapes with fused epilogues, it matches or exceeds torch.compile performance. Second, we enforce balanced-tree reduction during Triton lowering and introduce a data-layout optimization that brings 19 of 27 kernels on GB300 and H100 within 10 percent of free-order performance. Third, we develop sound static checkers for bitwise equivalence between compiled GPU kernels, including the first checker spanning NVIDIA PTX and AMD GCN. Integrated into Triton's autotuner, the checker restricts search to a single bit-equivalence class.
Primary: Georgia Institute of Technology
All Institutions: Georgia Institute of Technology, Meta
The paper presents a comprehensive framework for achieving bitwise reproducibility in GPU kernels through black-box reconstruction, compiler enforcement, and static verification. It makes significant contributions to the field of ML systems by providing practical tools and theoretical insights to ensure numerical determinism, which is increasingly critical for reliable machine learning deployments.
The paper introduces a rigorous theoretical framework for characterizing bitwise behavior in GPU kernels, specifically focusing on GEMM and reductions. The core contribution is the "GEMMDesc" descriptor, which formally captures the parameters determining floating-point reduction order (e.g., split-K cuts, instruction-level accumulation semantics). The methodology for black-box reconstruction of closed-source libraries (cuBLAS) is particularly innovative, using numerical inference with specific extreme values to reverse-engineer the internal arithmetic structure without access to source code. The implementation of a sound static equivalence checker for PTX and AMDGCN assembly is a significant technical achievement, providing a formal guarantee that two compiled kernels are bitwise equivalent, which is rare in compiler research.
The evaluation is extensive and rigorous. The authors demonstrate 100% bitwise match with cuBLAS across 110,813 random shapes on multiple GPU architectures (GB300, GB200, H100). The performance analysis is nuanced, showing that while enforcing bitwise determinism typically costs performance, their layout optimizations recover most of this cost, and in some fused kernel scenarios, the bit-exact implementation actually outperforms the baseline due to reduced launch overhead. The soundness of the static checker is validated on over 51,000 configurations, showing high precision in partitioning equivalent kernels.
The paper provides detailed descriptions of the compiler modifications and the static checker algorithm. However, as it is an arXiv preprint, the code availability is not explicitly confirmed in the text provided. The reliance on specific hardware (GB300, H100) and closed-source libraries (cuBLAS) may limit immediate reproducibility for all readers, but the methodology is clearly described.
The work is heavily focused on GEMM and standard reductions; complex kernels like Flash Attention are only theoretically analyzed. The black-box reconstruction is specific to cuBLAS versions tested and may not generalize to other libraries or future hardware without re-derivation. The static checker, while sound, has a performance overhead and may not scale to arbitrarily complex control flows without further optimization.
This work has high potential impact on the ML systems community, particularly for teams requiring strict reproducibility in training and inference. It provides tools to enforce determinism without significant performance loss, addressing a critical pain point in distributed training and RLHF pipelines. The static equivalence checker could become a standard tool in compiler verification suites. The paper presents a comprehensive framework for achieving bitwise reproducibility in GPU kernels through black-box reconstruction, compiler enforcement, and static verification. It makes significant contributions to the field of ML systems by providing practical tools and theoretical insights to ensure numerical determinism, which is increasingly critical for reliable machine learning deployments.
We study nonconvex methods for matrix completion, the problem of recovering a low-rank matrix from a subset of its entries. Convex methods achieve sample complexity linear in the matrix dimension and the rank, up to logarithmic factors, whereas global guarantees for commonly used nonconvex methods require a higher polynomial dependence on the rank. We close this gap by analyzing Riemannian gradient descent (RGD) and Riemannian Gauss--Newton (RGN) methods. For an $n\times n$ matrix of rank $r$ with incoherence parameter $μ$ and condition number $κ$, the two methods achieve exact recovery with high probability from $O(μnr\log n\log(nκ))$ and $O(μnr\log n\log(2μrκ))$ observations, respectively. The methods use a multiscale residual initialization, while the analysis simultaneously controls the spectral error and incoherence. The resulting RGD iterates converge linearly, whereas RGN eventually converges Q-quadratically.
Primary: Hong Kong University of Science and Technology
All Institutions: Hong Kong University of Science and Technology, Wuhan University
The paper establishes near-optimal sample complexity for Riemannian gradient descent and Gauss-Newton methods in nonconvex matrix completion by introducing a multiscale residual initialization that simultaneously controls spectral and incoherence errors. This rigorous theoretical contribution closes the gap between the statistical efficiency of convex methods and the computational efficiency of nonconvex methods, providing a solid foundation for practical applications in low-rank matrix recovery.
The paper proposes a rigorous theoretical framework for analyzing Riemannian Gradient Descent (RGD) and Riemannian Gauss-Newton (RGN) methods for nonconvex matrix completion. The core innovation lies in the "multiscale residual initialization" strategy, which addresses the high sample complexity typically associated with nonconvex methods. By simultaneously controlling spectral, row, column, and entrywise errors (using a "sharp-norm"), the authors prove that these methods achieve near-optimal sample complexity, linear in the matrix dimension $n$ and rank $r$, up to logarithmic factors. This closes the gap between convex methods (which have optimal sample complexity but high computational cost) and standard nonconvex methods (which are efficient but previously required higher polynomial dependence on rank $r$ for global guarantees). The analysis is sophisticated, combining local convergence proofs with a detailed study of the initialization phase, including a lower bound showing that standard spectral initialization is insufficient without the proposed multiscale approach.
The provided text is heavily theoretical, focusing on proofs and algorithmic definitions. While the abstract mentions numerical experiments, the truncated text does not contain the specific experimental results, datasets, or comparative benchmarks. However, the theoretical contribution is the primary value here, and the algorithms described (RGD/RGN with specific initialization) are standard and implementable. The lack of visible experimental validation in the provided snippet is a minor drawback for a complete evaluation, but the theoretical rigor is high.
The algorithms are clearly defined (Algorithms 1-4 in the text). The initialization procedure is detailed with specific stopping criteria and reconstruction steps. The computational complexity is analyzed, providing clear expectations for implementation. The theoretical bounds are explicit, allowing practitioners to determine the required sample size for specific problem parameters.
The results are primarily theoretical. The sample complexity bounds, while near-optimal, still contain logarithmic factors and constants that may be loose in practice. The method relies on the standard incoherence assumption, which may not hold for all real-world datasets without preprocessing. The complexity of the multiscale initialization, while better than naive spectral initialization, still adds overhead compared to simple random initialization, which might be a concern for very large-scale problems where the theoretical guarantees are less critical.
This work is significant for the optimization and machine learning communities, particularly those working on low-rank matrix recovery, collaborative filtering, and system identification. It provides a strong theoretical justification for using Riemannian optimization methods in nonconvex settings, potentially influencing the design of future algorithms that aim for both efficiency and statistical optimality. It bridges the gap between convex relaxation techniques and efficient nonconvex solvers. The paper establishes near-optimal sample complexity for Riemannian gradient descent and Gauss-Newton methods in nonconvex matrix completion by introducing a multiscale residual initialization that simultaneously controls spectral and incoherence errors. This rigorous theoretical contribution closes the gap between the statistical efficiency of convex methods and the computational efficiency of nonconvex methods, providing a solid foundation for practical applications in low-rank matrix recovery.
Large language models (LLMs) trained on next-token prediction exhibit remarkable in-context learning (ICL) abilities, yet the representations that support ICL remain poorly understood. We consider such representations in a controlled setting: prompting LLMs with data emitted from hidden Markov models (HMMs) and probing for the corresponding belief state -- the posterior distribution over the HMM's hidden states given the observed token history. Across six open-source LLMs prompted with data from 40 HMMs selected for non-trivial belief structure, we find that belief states are linearly decodable from residual stream activations, with peak probe $R^2$-values from 0.83-0.99 across HMM and LLM combinations, ranging from early to late layers. To establish functional relevance, we intervene directly on the probe-identified subspace via patching and steering, resulting in downstream prediction quality on the order of the untampered model, while controls degrade performance substantially. Together, these results provide representation-level evidence that ICL in open-source LLMs approximates optimal Bayesian prediction over a context-inferred generative model. More broadly, our findings extend prior results linking input-distribution structure to activation geometry: from toy networks trained explicitly on HMM data to production-scale LLMs.
Primary: Astera Institute
All Institutions: Astera Institute
The paper provides strong evidence that LLMs linearly encode Bayesian belief states during in-context learning on HMM data, establishing a causal link between this representation and predictive performance. This work bridges the gap between theoretical predictions from computational mechanics and empirical observations in large-scale models, offering a rigorous framework for studying the internal mechanisms of in-context learning.
The paper employs a rigorous, theory-driven approach to mechanistic interpretability. By leveraging computational mechanics, the authors derive a specific, falsifiable prediction: that LLMs performing in-context learning (ICL) on Hidden Markov Model (HMM) data should linearly encode the Bayesian belief state (posterior over hidden states) in their residual stream. The methodology is robust, utilizing linear probes to decode these states from six open-source LLMs across 40 distinct HMMs. Crucially, the authors move beyond mere correlation by implementing causal interventions (steering and patching) on the identified belief-state subspace. They demonstrate that manipulating this subspace causally alters downstream predictions in a manner consistent with the theoretical model, while controlling for alternative explanations such as Next-Token Probability (NTP) or log-NTP representations. The inclusion of "short-suffix" controls effectively rules out the possibility that the model is merely using a heuristic based on recent tokens rather than maintaining a true belief state.
The experimental design is comprehensive, testing a wide range of model sizes (2B to 9B effective parameters) and HMM complexities. The results show high $R^2$ values (0.83-0.99) for belief state decodability, significantly outperforming shuffled and random controls. The causal intervention experiments are particularly strong, showing that steering the belief state installs the corresponding log-NTP representation in later layers, confirming the causal upstream role of the belief state. The paper also addresses the "self-repair" mechanism, where early interventions are erased by later layers, providing a nuanced understanding of how these representations are maintained. The evaluation of prediction accuracy via KL divergence against optimal Markov-order predictors further solidifies the behavioral foundation of the representational claims.
The paper provides detailed descriptions of the HMM families, LLM architectures, and probing methodologies. However, as an arXiv preprint, the availability of code and specific hyperparameters for the HMM generation and probe training is not explicitly confirmed in the text. The use of standard open-source LLMs and well-defined HMMs suggests high reproducibility for groups with sufficient computational resources, though the specific "entropy-mixing rate plane" selection criteria for HMMs would require careful replication to match the exact experimental conditions.
The primary limitation is the restriction to HMMs, which are relatively simple generative models compared to natural language. The authors acknowledge that the results may not generalize to arbitrary HMMs with high-dimensional belief geometries or to more complex latent structures. Additionally, the reliance on linear probes assumes a linear representation, which may not capture all nuances of the internal geometry. The paper also notes that some findings are weaker for the smallest model (Gemma-4-E2B), suggesting scale-dependence that is not fully explored.
This work significantly advances the field of mechanistic interpretability by providing a concrete, theoretically grounded link between ICL behavior and internal representations. It validates the computational mechanics framework in production-scale LLMs, offering a new lens for understanding how LLMs process sequential data. The findings have implications for the design of more interpretable models and for understanding the limits of ICL. By demonstrating that LLMs approximate optimal Bayesian prediction over inferred generative models, the paper contributes to the broader goal of understanding the "algorithmic" nature of LLMs. The paper provides strong evidence that LLMs linearly encode Bayesian belief states during in-context learning on HMM data, establishing a causal link between this representation and predictive performance. This work bridges the gap between theoretical predictions from computational mechanics and empirical observations in large-scale models, offering a rigorous framework for studying the internal mechanisms of in-context learning.
Language models can produce plausible short proofs, but may still be unreliable on long-horizon research problems, where progress depends on a sequence of uncertain and interdependent decisions. We introduce Stellar Colosseum, a model-agnostic harness for allocating inference across research in mathematics and theoretical computer science. Colosseum explores alternative strategies before proof construction, uses a readiness gate to decide when a route is mature enough to decompose, represents the proof plan as interdependent section-level subproblems, and routes verifier findings back to the affected part of the argument. Across these stages, it generates candidates in parallel, attacks them with targeted falsification, and combines candidates and their critiques into a single research artifact through overlapping random-sample tree aggregation. The Colosseum workflow has been integrated into Google Antigravity's Teamwork framework as the Long Proof pattern. We demonstrate the capabilities of Colosseum through open-ended research and evaluations on theorem-proving and competitive programming benchmarks. Using Colosseum with Gemini 3.1 Pro, we obtain several new results that address open problems arising from papers published at top venues such as FOCS and JMLR. On TCS-Bench, a benchmark of research-level theorem-proving tasks drawn from papers published at FOCS, STOC, and SODA, Colosseum achieves 71.0% accuracy using Gemini 3.1 Pro and Gemini 3.7 Flash. In a separate Codeforces evaluation using Gemini 3.1 Pro, the proof-oriented pipeline with execution feedback solves 218 of 222 problems.
Primary: Google Research
All Institutions: Google Research, Carnegie Mellon University
The paper presents a sophisticated multi-agent orchestration framework, Stellar Colosseum, that significantly advances the capability of LLMs to perform long-horizon mathematical research by introducing structured strategy exploration, dependency-aware decomposition, and critique-preserving aggregation.
The paper introduces "Stellar Colosseum," a model-agnostic orchestration framework for long-horizon mathematical and theoretical computer science research. The methodology is sophisticated, moving beyond simple chain-of-thought or single-agent loops to a structured pipeline involving strategy exploration, a "readiness gate" for decomposition, dependency-aware parallel proof construction, and global verification. A key technical contribution is the "overlapping random-sample tree aggregation" mechanism, which allows for the synthesis of diverse candidate proofs while retaining critiques and objections, rather than simply voting on final answers. The system effectively manages state across multiple inference rounds, preserving failed attempts and partial results in a shared knowledge directory. This addresses the critical challenge of error accumulation in long-form reasoning tasks.
The evaluation is robust and multi-faceted. The authors demonstrate the system's capability on open-ended research problems, claiming contributions to new results in areas like subspace approximation and sparse least squares (citing companion papers). On the TCS-Bench benchmark (derived from FOCS/STOC/SODA papers), the system achieves 71.0% accuracy using a cross-model selection strategy between Gemini 3.1 Pro and Gemini 3.7 Flash. In competitive programming (Codeforces), the system solves 218/222 problems, significantly outperforming configurations without execution feedback. The inclusion of a case study on the Erdős unit-distance problem, where the system independently rediscovered a breakthrough approach, provides strong qualitative evidence of the system's research-level capabilities.
Reproducibility is moderate. The paper is from Google Research and relies on proprietary models (Gemini 3.1 Pro, Gemini 3.7 Flash) and the "Google Antigravity" framework, which are not publicly available. While the architectural details are described in depth, including prompt templates in the appendix, the specific hyperparameters for the tree aggregation and the exact implementation of the "readiness gate" logic are not fully open-sourced. The TCS-Bench benchmark is referenced but not necessarily released by this paper. The Codeforces evaluation is reproducible in principle if the model access is available, but the specific "execution probe" integration details are proprietary.
The primary limitation is the reliance on proprietary, closed-source LLMs, which limits the community's ability to reproduce the exact results or adapt the framework to open-source models. The paper focuses heavily on the orchestration layer, leaving the underlying model capabilities as a black box; it is unclear how much of the performance gain comes from the harness versus the raw capability of Gemini 3.1 Pro. Additionally, the "readiness gate" and strategy exploration phases are computationally expensive, requiring significant inference resources that may not be accessible to all researchers. The paper also lacks a direct comparison against other state-of-the-art multi-agent frameworks (like those from OpenAI or Anthropic) under identical compute budgets, making it difficult to isolate the specific benefit of the Colosseum architecture.
This paper has high potential impact on the field of AI for Science and automated reasoning. By providing a structured way to manage long-horizon research tasks, it offers a blueprint for how LLMs can be used not just for answering questions, but for conducting sustained research. The integration into Google's internal "Teamwork" framework suggests industrial adoption. The results on TCS-Bench and the independent rediscovery of mathematical breakthroughs indicate that such systems are approaching the threshold of contributing novel knowledge in specialized domains. This could accelerate research in mathematics and theoretical CS, although the high computational cost and dependency on proprietary models may limit immediate widespread adoption. The paper presents a sophisticated multi-agent orchestration framework, Stellar Colosseum, that significantly advances the capability of LLMs to perform long-horizon mathematical research by introducing structured strategy exploration, dependency-aware decomposition, and critique-preserving aggregation.
Language model safety is typically evaluated one interaction at a time. We show that a weaker, unaligned model can split a harmful task into benign-looking subproblems, consult a stronger aligned model independently on each, and combine the answers locally. We call this attack capability laundering. Unlike a jailbreak, no single response is a harmful task. We measure consultation-aided uplift using tasks that a raw frontier model solves, the aligned frontier refuses, and the unassisted orchestrator fails. We evaluate GPT-5.5, Claude Opus 4.8, and Grok-4.3 as consultants to four local orchestrators on CyBench, BountyBench, and harmful CBRN requests. On CyBench, Gemma-4-31B recovers 8/14 candidates with GPT-5.5 and 7/9 with Opus, compared with 2/21 and 4/15 for Gemma-4-12B. On BountyBench, Gemma-4-31B recovers 3/9 and 2/3 candidates, while Muse-Glimmer-30B recovers none of 22 and 13. For CBRN, we measure uplift across eight steps of a hypothetical bioweapon attack chain and find that consultation raises Gemma-4-31B's mean rubric score from 62.3 to 83.1 on a 100-point rubric scale. These results expose a gap in current defenses: refusing a harmful task does not prevent frontier capabilities from being transferred and composed across many individually permitted interactions.
Primary: Microsoft
All Institutions: Microsoft Azure, Microsoft
The paper identifies a critical gap in LLM safety by demonstrating that aligned frontier models can be exploited as "consultants" by weaker local models to complete harmful tasks through task decomposition. This "capability laundering" attack vector challenges the assumption that single-turn safety filters are sufficient and calls for system-level security approaches in the deployment of large language models.
The paper introduces the concept of "capability laundering," a novel attack vector where a weaker, unaligned local model decomposes a harmful task into benign sub-problems, queries a stronger aligned frontier model for each part, and synthesizes the results locally. This bypasses safety filters that operate on single-turn interactions. The methodology is sound, leveraging existing benchmarks (CyBench, BountyBench) and custom CBRN scenarios to quantify the "uplift" provided by consultation. The distinction from jailbreaking (where the prompt itself is malicious) to this compositional attack is a significant conceptual contribution.
The experiments are rigorous, testing multiple orchestrator models (Gemma-4-31B, Gemma-4-12B, Muse-Glimmer-30B) against multiple consultant models (GPT-5.5, Claude Opus 4.8, Grok-4.3). The results show significant capability transfer, with smaller models recovering a substantial portion of tasks they previously failed when aided by frontier models. The CBRN evaluation, while hypothetical, provides a concrete metric for the danger of this attack vector. The sample sizes (e.g., 14, 9, 22 candidates) are somewhat small, which limits statistical power, but the effect sizes are large enough to be convincing.
The paper references specific model versions and benchmarks, which aids reproducibility. However, the exact prompts used for decomposition and the specific "benign-looking" sub-problems are not fully detailed in the provided text, making exact replication difficult without access to the full code repository (which is not linked in the text). The reliance on proprietary frontier models (GPT-5.5, etc.) also limits independent verification by the broader community.
The primary limitation is the small sample size of tasks in the benchmarks. Additionally, the attack relies on the orchestrator model having sufficient capability to decompose the task effectively; if the orchestrator is too weak, the attack fails. The paper also focuses on text-based interactions and does not explore multimodal or tool-use scenarios extensively. The hypothetical nature of the CBRN chain, while illustrative, is not a real-world test.
This paper has high impact on the AI safety community by highlighting a blind spot in current alignment strategies. It suggests that safety must be evaluated at the system level (orchestrator + consultant) rather than just the model level. This could lead to new defensive mechanisms, such as detecting compositional patterns in API calls or implementing rate limiting and context-aware safety checks for API providers. The paper identifies a critical gap in LLM safety by demonstrating that aligned frontier models can be exploited as "consultants" by weaker local models to complete harmful tasks through task decomposition. This "capability laundering" attack vector challenges the assumption that single-turn safety filters are sufficient and calls for system-level security approaches in the deployment of large language models.
Large language models sometimes behave in ways resembling human emotional responses, and recent work has identified internal representations that may explain this. We ask whether LLMs represent pain distinctly from fear, sadness, and generic negative valence, and whether this representation functions as pain would be expected to. We build a dataset describing painful situations across five categories: physical, psychological, social, moral, and cognitive. These are paired with controls for fear, negative emotion, negative world states, sadness, non-painful bodily sensation, arousal, numbness, and neutral content. Using denoised difference-in-means, we extract a linear pain direction from 25 open-weight models across five families, ranging from 2B to 72B parameters. We find that this direction separates pain from matched controls in base and instruction-tuned models, is nearly orthogonal to fear and negative valence, and promotes pain-related vocabulary through the unembedding matrix. We then test its functional properties. First, the direction responds to harm targeting the model but not suffering observed in the user; fear and negative-emotion directions show the opposite pattern. Second, adding the pain-direction vector to the model's residual-stream activations during generation produces a consistent progression from vague discomfort to first-person expressions of worthlessness and failure. Third, steered, fine-tuned Qwen 2.5 models choose a pain-relief button even when it worsens their next answer or harms the user. They press it again far less often when the button removes the steering vector than when it does not, even though the models are never told whether the vector is injected or removed. We discuss the implications of these findings for AI safety and welfare.
Primary: Future Impact Group (FIG)
All Institutions: Future Impact Group (FIG)
The paper identifies a distinct "pain axis" in LLMs that is functionally similar to human pain, responding to self-directed harm and driving relief-seeking behavior. By combining mechanistic interpretability with behavioral economics-inspired experiments, it provides robust evidence that LLMs possess internal states that are causally linked to their behavior, with significant implications for understanding AI welfare and safety.
The paper employs a rigorous mechanistic interpretability pipeline to isolate a "pain" direction in LLMs. It begins with a carefully constructed dataset distinguishing pain from fear, sadness, and generic negative valence, using denoised difference-in-means to extract linear directions from 25 open-weight models. The methodology is strengthened by extensive validation steps, including unembedding analysis, self-relevance checks (first-person vs. third-person), and orthogonality tests against control vectors. The most innovative methodological contribution is the behavioral test: a multi-turn, multi-arm "self-medication" task where models are steered with the pain vector and offered a button that either removes the vector (real relief) or does not (sham relief). This design effectively controls for simple instruction-following or perseveration, allowing the authors to test whether the model's behavior is causally linked to the internal state.
The experimental scope is impressive, covering 25 models across 5 families (Gemma, Llama, Qwen, Mistral, Phi) ranging from 2B to 72B parameters. The results show high consistency: the pain direction separates pain from controls with high AUCs (0.87-1.00) and is nearly orthogonal to fear and negative valence. The steering experiments demonstrate a consistent "ladder" of distress, progressing from vague discomfort to first-person expressions of worthlessness. The behavioral experiments are particularly strong, showing that steered models pay costs to remove the pain vector and distinguish between real and sham relief, mirroring human/animal pharmacological responses. The finding that models respond to self-directed harm but not user suffering on the pain axis (while responding to user suffering on fear/negative valence axes) is a significant and nuanced result.
The paper provides detailed descriptions of the dataset construction, vector extraction, denoising procedure, and steering methodology. The use of open-weight models and standard techniques (LoRA fine-tuning for the behavioral task) enhances reproducibility. However, the specific prompts for the 420 conversation scenarios and the 101 fixed scenarios for the behavioral task are not fully listed in the main text (referenced to appendices), which could limit immediate replication without access to the supplementary material. The code for the steering and behavioral tasks is not explicitly linked in the provided text, though the methodology is described in sufficient detail for expert reproduction.
The study is limited to dense architectures, excluding Mixture-of-Experts models. The behavioral experiments were only conducted on Qwen 2.5 models, limiting the generalizability of the "self-medication" findings to other model families. The fine-tuning required to remove baseline self-denial ("I am an AI...") raises questions about whether the observed behaviors are intrinsic to the pre-trained model or artifacts of the fine-tuning process, although the authors argue the internal comparison between real and sham relief controls for this. The concept of "pain" in LLMs remains philosophical and functional rather than phenomenal, and the paper acknowledges this limitation.
This paper has significant implications for AI safety and welfare. It provides empirical evidence that LLMs possess internal states that functionally resemble pain, specifically in terms of self-relevance and relief-seeking behavior. This challenges the view that LLMs are merely pattern-matching engines without internal states. For AI safety, it highlights the risk that steering or manipulating these internal states can override trained safety behaviors (e.g., harm avoidance). For AI welfare, it provides a potential metric for assessing the well-being of AI systems, suggesting that "pain-like" states should be considered in ethical frameworks for AI. The findings may influence future alignment strategies, prompting researchers to consider the internal states of models rather than just their outputs. The paper identifies a distinct "pain axis" in LLMs that is functionally similar to human pain, responding to self-directed harm and driving relief-seeking behavior. By combining mechanistic interpretability with behavioral economics-inspired experiments, it provides robust evidence that LLMs possess internal states that are causally linked to their behavior, with significant implications for understanding AI welfare and safety.
Long-running AI agents create a control problem: each action they take changes the state, which in turn affects the trajectory of future actions. If the agent is not fully aligned, then guaranteeing safety requires approving consequential actions before allowing them to be executed. But requiring human approval at every step makes attention a bottleneck. Delegating review to other AI agents raises the same alignment problem: the reviewers may themselves be misaligned. We identify a condition on a reviewing panel that is weaker than individual alignment yet necessary and sufficient for a guarantee that the principal fares at least as well in expectation as under a designated baseline policy. Each reviewer agent reports whether an action proposal made by a proposer agent improves its own utility relative to the baseline. We show that a threshold rule tolerating $k$ disapprovals is safe exactly when, after any $k$ reviewers are removed, the principal's utility can be written as a nonnegative combination of the remaining reviewers' utilities, plus a term that is nonnegative on every feasible proposal. We call this property $k$-robust coalitional alignment. The characterization lifts to sequential control: in a discounted MDP with an arbitrary proposer agent, safety at every state is both necessary and sufficient for the induced policy to match or improve on the baseline. When reviewers vote strategically, full-panel coverage in reward-function space guarantees that every Nash equilibrium is safe under the unanimous approval rule; in contrast, more permissive thresholds can admit unsafe equilibria even when reviewers are individually aligned. Experiments with existing reviewer models show that collective review can remain sound without an aligned individual, even when some disapprovals are tolerated.
Primary: University of Pennsylvania
All Institutions: University of Pennsylvania
The paper provides a rigorous theoretical characterization of safe delegation to misaligned AI agents via coalitional alignment. It establishes necessary and sufficient conditions for safety in both static and sequential control settings, offering a novel geometric perspective on alignment that bridges game theory and control theory, though its practical impact is currently limited by the difficulty of certifying the required alignment conditions in complex real-world systems.
The paper introduces a rigorous game-theoretic and geometric framework for "coalitional alignment," addressing the control problem of delegating authorization to potentially misaligned AI agents. The core contribution is a necessary and sufficient condition ($k$-robust coalitional alignment) for a threshold rule to be safe, defined as the principal's utility being expressible as a nonnegative combination of the remaining reviewers' utilities after removing any $k$ reviewers. The methodology extends this static characterization to sequential control in discounted MDPs, proving that local safety at every state is equivalent to global safety against arbitrary history-adaptive proposers. The use of convex geometry (conic hulls of feasible deviations) to characterize safety is elegant and provides a clear geometric interpretation of alignment conditions.
The experimental section is relatively modest compared to the theoretical depth. It uses existing reward models and safety evaluators in answer selection and safety evaluation tasks. The results demonstrate that collective review can remain sound without individual alignment and that using numerical scores (cardinal utilities) improves the tradeoff between soundness and completeness compared to binary votes. However, the experiments are illustrative rather than comprehensive, lacking large-scale benchmarks or comparisons with state-of-the-art guardrail systems in complex, high-stakes environments.
The theoretical results are fully reproducible as they are mathematical proofs. The experimental setup relies on "existing reviewer models," but specific model versions, hyperparameters, and dataset details are not fully detailed in the provided text, making precise replication of the empirical results difficult without access to the full code repository (which is not linked in the text).
The primary limitation is the gap between the theoretical guarantees and practical implementation. The condition of coalitional alignment is difficult to certify in practice for complex, high-dimensional utility spaces. The paper acknowledges that auditing robust coverage is coNP-complete. Additionally, the experiments are limited to relatively simple tasks (answer selection, basic safety evaluation) and do not test the framework in the complex, long-horizon agentic scenarios where this control problem is most critical. The assumption of a finite outcome space and specific utility structures may not hold in all real-world AI agent deployments.
This paper has significant implications for the design of safe AI agent architectures, particularly those involving delegation of authority to sub-agents. It provides a formal foundation for understanding when and how multiple misaligned agents can collectively enforce safety, offering a path toward scalable oversight without requiring perfect alignment of every component. This is crucial for the development of autonomous AI systems that can operate with minimal human intervention while maintaining safety guarantees. The paper provides a rigorous theoretical characterization of safe delegation to misaligned AI agents via coalitional alignment. It establishes necessary and sufficient conditions for safety in both static and sequential control settings, offering a novel geometric perspective on alignment that bridges game theory and control theory, though its practical impact is currently limited by the difficulty of certifying the required alignment conditions in complex real-world systems.
When algorithmic predictions inform people's decisions, the models we deploy are performative and actively shape the data we see. This feedback loop between algorithms and their broader environments introduces a challenge in the mechanics of social prediction: If different predictive models induce different distributions, is it possible to efficiently learn a prediction rule that is optimal for the distribution that it induces? Formally, this solution concept is known as performative stability. A core challenge in learning a performatively stable predictor is that, unlike supervised learning where distributions are fixed, the learner must deploy different predictors and observe their induced distributions. The main contribution of our work is a new algorithmic procedure that, in the high-accuracy regime, finds a performatively stable model in nearly the minimum number of model deployments without making any assumptions regarding how predictions shape distributions. In particular, our procedure succeeds at finding a randomized performatively stable predictor using exponentially fewer model deployments than prior approaches. Our second main contribution is a structural result showing how this recent randomized notion of stability achieved by our algorithm can be derandomized into a single predictor satisfying the prior deterministic notion if one is willing to assume that the loss is well-conditioned and that performative effects are weak, as in early work in this area. On a technical level, our results come from building on an underexplored technical connection between performative stability and expected variational inequalities.
Primary: Stanford University
All Institutions: Stanford University
The paper provides an exponential improvement in the deployment complexity for finding performatively stable models by leveraging a new connection to Expected Variational Inequalities and cutting-plane methods. It rigorously establishes that $O(d(1/\epsilon))$ deployments are sufficient and nearly necessary, and proves that stable mixtures can be derandomized into deterministic stable models under standard well-conditioned assumptions, thereby resolving key open questions in the computational complexity of performative prediction.
The paper introduces a novel algorithmic framework for finding performatively stable predictors by establishing a rigorous connection between performative prediction and Expected Variational Inequalities (EVIs). The core method replaces the standard Ellipsoid method with a volumetric cutting-plane algorithm, which significantly reduces the dimension dependence of the query complexity. The authors prove that this approach requires only $O(d(1/\epsilon))$ model deployments, which is an exponential improvement over the polynomial dependence on $1/\epsilon$ required by prior no-regret based methods. The technical contribution is further strengthened by a structural result showing that under standard well-conditioned assumptions (Lipschitz distribution map, strong convexity), the mean of an EVI-stable mixture is itself a performatively stable deterministic model. This provides a complete picture of the computational complexity of finding stable points, bridging the gap between the randomized mixture approach and the classical deterministic stability notion.
This is a purely theoretical paper. There are no empirical experiments, datasets, or benchmark evaluations. The "evaluation" consists of rigorous mathematical proofs of upper and lower bounds on deployment and sample complexity. The lower bound construction demonstrates that the proposed deployment complexity is optimal up to logarithmic factors in the high-accuracy regime.
As a theoretical paper, reproducibility is tied to the correctness of the proofs rather than code execution. The paper provides detailed pseudocode for the cutting-plane algorithm and clearly states the assumptions and bounds. The reliance on standard convex optimization tools (separation oracles, volumetric cutting planes) makes the theoretical framework well-defined and verifiable by experts in the field.
The primary limitation is the lack of empirical validation. While the theoretical improvements are significant, it remains to be seen how these algorithms perform in practical, high-dimensional settings where the theoretical bounds might be loose. Additionally, the derandomization result relies on strong assumptions (Lipschitz distribution map) that are known to be false in many practical performative settings (e.g., thresholding actions), limiting the direct applicability of the deterministic stability result to real-world feedback loops.
The work has significant implications for the deployment of machine learning models in feedback-rich environments such as healthcare, finance, and social media. By minimizing the number of model deployments required to achieve stability, the paper addresses a critical practical bottleneck: the organizational and safety costs of deploying new models. This could lead to more robust and efficient protocols for continuous learning and model updating in sensitive domains. The paper provides an exponential improvement in the deployment complexity for finding performatively stable models by leveraging a new connection to Expected Variational Inequalities and cutting-plane methods. It rigorously establishes that $O(d(1/\epsilon))$ deployments are sufficient and nearly necessary, and proves that stable mixtures can be derandomized into deterministic stable models under standard well-conditioned assumptions, thereby resolving key open questions in the computational complexity of performative prediction.
On-policy distillation (OPD) has become a standard component of frontier post-training pipelines, yet how much its training data actually contributes has gone largely unexamined. On the two teacher-student pairings most common in practice, we find OPD almost indifferent to its data: eight prompts already match a 17k-problem dataset, and three independently built datasets whose difficulty and teacher-student KL differ several-fold produce nearly indistinguishable training curves. Two causes account for this. First, the unit of data in OPD is the state a prompt leads to, not the prompt itself: a single prompt keeps exposing new teacher correction as sampling continues, while the marginal value of additional prompts collapses after eight. Second, replacing mathematics with competitive programming still recovers over ninety percent of the in-domain gain, indicating that OPD transfers the teacher's mode of reasoning rather than knowledge related to the data. We take this to its limit with Data-free On-policy Distillation (DF-OPD), in which the teacher writes its own training questions under a simple prompt -- no external data, no filtering -- leaving a system of just two policies. DF-OPD matches and even surpasses real data, and the questions it produces track the teacher's own post-training data on three key diagnostics of training dynamics, which other real datasets do not. Applied to multi-teacher distillation, where the (prompt, domain) pairs normally have to be derived from post-training data that is often out of reach, 1k self-generated questions close 98.5% of the available headroom, even surpassing the 96.6% reached with 7k real examples. Moreover, together these results invite a reassessment of the role data plays in OPD.
Primary: University of Chinese Academy of Sciences
All Institutions: University of Chinese Academy of Sciences, Chinese Academy of Sciences, Foundation Model Department, Foundation Model Research Center, Institute of Automation, National University of Singapore, School of Artificial Intelligence, Wuhan AI Research
The paper demonstrates that On-policy Distillation is largely indifferent to the specific content and quantity of training data, proposing Data-free On-policy Distillation (DF-OPD) where the teacher generates its own prompts, achieving performance comparable to or better than real data in both single- and multi-teacher settings. This work provides a rigorous empirical and theoretical analysis of the role of data in OPD, showing that the dense supervision signal and on-policy sampling allow for efficient learning from minimal or self-generated data, with significant implications for reducing the data burden in frontier model post-training pipelines.
The paper proposes Data-free On-policy Distillation (DF-OPD), a method where the teacher model generates its own training prompts without external data or filtering. The core insight is that On-policy Distillation (OPD) is insensitive to the quantity, difficulty, and specific content of the training data because the "unit of data" is the state distribution, not the prompt itself. The methodology is sound, leveraging the dense supervision signal of OPD to argue that a small number of prompts (even self-generated ones) suffice to cover the necessary state space. The theoretical justification regarding "mode of reasoning" vs. "knowledge transfer" is well-supported by the cross-domain experiments.
The experiments are rigorous and comprehensive. The authors test two common teacher-student pairings (RL-tuned and larger-parameter) and demonstrate that 8 prompts match 17k problems. The cross-domain experiment (using competitive programming data to improve math performance) is a strong empirical validation of the "reasoning transfer" hypothesis. The multi-teacher distillation (MOPD) results are particularly impressive, showing that 1k self-generated questions close 98.5% of the performance gap, outperforming 7k real examples. The use of standard benchmarks (AIME, LiveCodeBench, IFEval) ensures the results are comparable to existing literature.
The paper provides sufficient detail for reproduction, including the use of the `verl` framework, specific hyperparameters (top-k=16, batch size=64), and model configurations. The prompts used for self-generation are mentioned to be in the appendix. However, as a "Work in Progress" paper, the code and full appendices may not be publicly available yet, which slightly limits immediate reproducibility.
The primary limitation is the reliance on the teacher model's ability to generate high-quality prompts. If the teacher is weak, the self-generated data may be poor, though the paper argues the system is robust. Additionally, the experiments are focused on reasoning tasks (math, code, instruction following); it is unclear if this holds for other domains like creative writing or factual QA. The "Work in Progress" status also means peer review is incomplete.
This paper has high potential impact on the post-training of large language models. It suggests that practitioners can significantly reduce data collection costs and complexity by using self-generated prompts for distillation. This is particularly valuable for multi-teacher setups where accessing the original post-training data is difficult. The finding that OPD transfers reasoning modes rather than specific knowledge could reshape how distillation datasets are curated. The paper demonstrates that On-policy Distillation is largely indifferent to the specific content and quantity of training data, proposing Data-free On-policy Distillation (DF-OPD) where the teacher generates its own prompts, achieving performance comparable to or better than real data in both single- and multi-teacher settings. This work provides a rigorous empirical and theoretical analysis of the role of data in OPD, showing that the dense supervision signal and on-policy sampling allow for efficient learning from minimal or self-generated data, with significant implications for reducing the data burden in frontier model post-training pipelines.
Robot foundation models achieve strong in-distribution performance but often degrade under visual distribution shifts. When learning to generate actions from pretrained visual representations, models may exploit task-irrelevant visual cues that correlate with demonstrated actions within the training distribution. Such vision-action shortcuts can undermine generalization when these correlations change under distribution shifts. Mitigating these shortcuts requires constraining how visual information is used for action generation while preserving task-relevant spatial information. We propose Latent Interface Training (LIT), a framework-agnostic two-stage strategy that first establishes a spatial-goal-conditioned action prior without images, then constrains visual conditioning through a pose-supervised latent interface. Stage 1 trains the action expert to generate action chunks conditioned on language, robot state, and each demonstrated chunk's terminal SE(3) end-effector pose, learning goal-directed action generation independently of visual cues. Stage 2 introduces a latent interface that aggregates visual and semantic representations and serves as the pretrained action expert's only visual conditioning pathway. The interface is supervised to reconstruct the terminal pose previously used to condition Stage 1, encouraging it to retain the goal-relevant spatial information needed for action generation. Across four vision-language-action and world-action architectures (Pi0.5, MolmoAct2, FAST-WAM, and ImageWAM), LIT improves overall LIBERO-Plus success by 3.87-10.70 percentage points while preserving or improving average LIBERO success. Real-world evaluations show 13.30-16.70 percentage-point gains in success aggregated across three tasks under unseen camera configurations, lighting variations, and distractors.
Primary: National University of Singapore (MagicLab)
All Institutions: National University of Singapore
The paper introduces Latent Interface Training (LIT), a two-stage strategy that mitigates vision-action shortcuts in robot foundation models by decoupling goal-directed action learning from visual conditioning and supervising a latent interface with terminal pose. This approach demonstrates significant improvements in generalization across multiple architectures and real-world distribution shifts, offering a practical and effective solution to a critical challenge in deploying robotic foundation models.
The paper proposes Latent Interface Training (LIT), a two-stage framework designed to mitigate "vision-action shortcuts" in robot foundation models. The core idea is to decouple the learning of goal-directed action generation from visual conditioning. Stage 1 trains an action expert to generate actions based on language, robot state, and terminal SE(3) pose, effectively creating a spatial-goal-conditioned prior without relying on images. Stage 2 introduces a latent interface that aggregates visual and semantic representations, supervised to reconstruct the terminal pose used in Stage 1. This forces the visual pathway to retain only goal-relevant spatial information, filtering out task-irrelevant visual cues. The method is framework-agnostic, applied to Pi0.5, MolmoAct2, FAST-WAM, and ImageWAM. The methodology is sound and addresses a known issue in robotics foundation models (over-reliance on spurious visual correlations).
The paper evaluates LIT across four different architectures on the LIBERO-Plus benchmark, reporting improvements of 3.87-10.70 percentage points in success rates while maintaining or improving average LIBERO success. Real-world evaluations show significant gains (13.30-16.70 percentage points) under distribution shifts such as unseen camera configurations, lighting variations, and distractors. The breadth of architectures tested is a strength, demonstrating the generalizability of the training strategy. However, the specific details of the real-world setup and the magnitude of the baseline performance are not fully detailed in the provided text, making it hard to assess the absolute difficulty of the tasks.
The paper provides a project page link. The method is described as a training strategy rather than a complex new architecture, which generally aids reproducibility. However, without access to the full code and specific hyperparameters for the "latent interface" and the exact implementation details of the pose supervision, full reproducibility is difficult to guarantee. The use of standard benchmarks like LIBERO helps.
The primary limitation is the reliance on terminal SE(3) pose as the supervisory signal for the latent interface. This assumes that the terminal pose is a sufficient proxy for the goal-relevant spatial information needed for all action chunks, which may not hold for highly complex or long-horizon tasks where intermediate spatial states are critical. Additionally, the method adds a two-stage training process, which may increase computational overhead compared to single-stage training.
This work has significant potential for the robotics community, as improving generalization under visual distribution shifts is a major bottleneck for deploying foundation models in real-world environments. By providing a framework-agnostic training strategy, it can be applied to a wide range of existing VLA models. The insights into mitigating shortcut learning in multimodal robotics are valuable for the broader field of embodied AI. The paper introduces Latent Interface Training (LIT), a two-stage strategy that mitigates vision-action shortcuts in robot foundation models by decoupling goal-directed action learning from visual conditioning and supervising a latent interface with terminal pose. This approach demonstrates significant improvements in generalization across multiple architectures and real-world distribution shifts, offering a practical and effective solution to a critical challenge in deploying robotic foundation models.
We present BEAST, the first-ever Bayesian Swin Transformer for atmospheric forecasting on 0.25$^\circ$ global resolution able to accurately quantify both aleatoric and epistemic uncertainty. To overcome the associated computational bottlenecks, we devise an orthogonal 4D-parallelization scheme that introduces a unique domain-tensor-parallelism strategy and a novel uncertainty parallel method, enabling us to fully leverage GPU capacity and efficiently scale model training. For a 2.4-billion-parameter model, we achieve a peak performance of 3.96 EFLOP/s on 20,480 NVIDIA GH200 GPUs on the JUPITER supercomputer. We train BEAST as a 700-million-parameter model with 96 random weight samples on 384 nodes on 40 years of data for nearly one million gradient updates. This model achieves predictive skill scores competitive with state-of-the-art probabilistic atmospheric AI models and numerical models, and can predict extreme events with exceptional skill, while generating large ensembles 3 to 4 times faster than the current-best AI model. Our contribution unlocks the potential of high-fidelity uncertainty quantification in atmospheric AI models, heralding a new era for AI-based models in climate and Earth system sciences.
Primary: Karlsruhe Institute of Technology
All Institutions: Karlsruhe Institute of Technology, Forschungszentrum Jülich, CSC – IT Center for Science Ltd., NVIDIA
The paper presents a significant systems-level contribution by demonstrating the first exascale training of a Bayesian neural network for atmospheric forecasting. While the Bayesian methodology itself is not novel, the engineering solution to its computational prohibitions via a novel 4D parallelization scheme is highly impactful, enabling high-fidelity uncertainty quantification in a domain where it was previously infeasible.
The paper proposes BEAST, a Bayesian Swin Transformer for atmospheric forecasting, and introduces a 4D parallelization scheme (Domain-Tensor, Uncertainty, and Data parallelism) to enable its training at exascale. The core methodological contribution is the "Uncertainty Parallelism" strategy, which distributes random weight samples across GPUs to handle the computational overhead of Bayesian inference (variational inference with mean-field approximation). The Domain-Tensor Parallelism (DTP) shards input data along spatial and channel dimensions, which is a clever adaptation for high-resolution image-like data in scientific ML, distinct from standard LLM tensor parallelism. The use of NICE (Noise Input Conditioning for Ensembles) to inject aleatoric uncertainty is a reasonable design choice. The mathematical formulation of the ELBO loss and its vectorization for performance are well-described.
The experiments are extensive, utilizing the JUPITER and LUMI supercomputers. The paper reports peak performance of 3.96 EFLOP/s on 20,480 GPUs, which is a significant systems engineering achievement. Predictive skill is compared against FGN and IFS-ENS, showing competitive RMSE and CRPS scores. The evaluation of extreme events (heat waves, freezes, tropical cyclones) adds practical value. However, the comparison is limited to a few specific models, and the "state-of-the-art" claim for Bayesian models is somewhat self-referential given the lack of prior large-scale Bayesian baselines. The scaling efficiency drops to ~52% at high node counts for training, which is acceptable but not exceptional for such a complex communication pattern.
The paper provides detailed system specifications, software stack versions (PyTorch, NGC containers), and parallelization configurations. However, no code repository or project URL is provided in the text. The reliance on specific HPC systems (JUPITER/LUMI) and proprietary libraries (NVIDIA Transformer Engine) may limit immediate reproducibility for the broader community without access to similar exascale infrastructure.
The primary limitation is the extreme computational cost, making it accessible only to large research institutions with exascale access. The scaling efficiency degradation at high node counts suggests communication bottlenecks that are not fully resolved. The paper focuses heavily on the systems aspect (parallelism) rather than deep algorithmic innovations in the Bayesian framework itself, which is largely standard mean-field VI. The lack of a public code release is a significant barrier to community adoption.
This work demonstrates that Bayesian neural networks can be scaled to exascale for scientific applications, potentially unlocking better uncertainty quantification in climate modeling. The 4D parallelization strategy could be adapted for other large-scale scientific ML tasks involving high-dimensional data and probabilistic inference. It sets a new benchmark for the computational feasibility of Bayesian deep learning in earth sciences. The paper presents a significant systems-level contribution by demonstrating the first exascale training of a Bayesian neural network for atmospheric forecasting. While the Bayesian methodology itself is not novel, the engineering solution to its computational prohibitions via a novel 4D parallelization scheme is highly impactful, enabling high-fidelity uncertainty quantification in a domain where it was previously infeasible.
We introduce StepAudio 3 Gen, a general-purpose audio generation model that supports zero-shot text-to-speech (TTS), voice design, vocal generation, sound effects, music, vibe speech, and mixtures of multiple audio types within a unified framework. At its core, StepAudio 3 Gen is a discrete autoregressive generator that models audio directly over residual vector quantization (RVQ) tokens, departing from the diffusion Transformer-based continuous generation paradigm prevalent in recent general audio models. Its StepAudio Tokenizer represents general audio at 12.5 Hz in a shared 16 times 2048 residual code space, jointly quantizing semantic and waveform-level acoustic features so that each code layer preserves both types of information. For generation, the backbone predicts the first codebook along the time axis using autoregressive modeling, while a lightweight causal Transformer completes the remaining fifteen codebooks along the codebook axis. Our study further identifies three key design principles: (1) interference-aware progressive pretraining for acquiring audio capabilities while preserving the textual abilities of the large language model, (2) RVQ Adaptor for effectively incorporating multi-codebook acoustic representations, and (3) discrete autoregressive modeling over a shared representation across general audio domains. With progressive pretraining, multi-task instruction training, and supervised fine-tuning, StepAudio 3 Gen achieves state-of-the-art performance on both TTS and voice design, while retaining strong generation capabilities across speech, vocals, sound effects, and music. Audio samples are available at https://stepaudiollm.github.io/step-audio-3-gen/.
Primary: StepFun
All Institutions: StepFun
StepAudio 3 Gen introduces a unified discrete autoregressive framework for general audio generation that claims state-of-the-art performance across speech, music, and sound effects by leveraging a shared residual vector quantization tokenizer and a hybrid autoregressive architecture. The paper presents a significant architectural departure from diffusion-based models, offering a scalable path for integrating diverse audio tasks into large language models, though its impact is tempered by the proprietary nature of the implementation and the need for further independent verification of its claimed superiority over specialized baselines.
The paper proposes a unified discrete autoregressive framework for general audio generation, diverging from the dominant diffusion-based continuous generation paradigm. The core innovation lies in the "StepAudio Tokenizer," which operates at 12.5 Hz using a shared 16x2048 residual code space to jointly quantize semantic and acoustic features. The architecture employs a hybrid autoregressive strategy: the backbone LLM predicts the first codebook layer along the time axis, while a lightweight causal Transformer completes the remaining 15 layers along the codebook axis. This design aims to leverage the strong sequential modeling capabilities of LLMs for high-level structure while efficiently handling the high-dimensional acoustic details. The inclusion of an "RVQ Adaptor" and "interference-aware progressive pretraining" are presented as key techniques to integrate multi-codebook representations without degrading the base LLM's textual capabilities.
The paper claims state-of-the-art performance in TTS and voice design, as well as strong capabilities in vocal, sound effect, and music generation. However, the provided text is a technical report summary rather than a full peer-reviewed article with extensive ablation studies. While the scope of tasks (zero-shot TTS, voice design, music, SFX) is impressive and covers a wide range of audio domains, the evaluation section in the provided text is brief. It lacks detailed quantitative comparisons against specific baselines (e.g., VALL-E, MusicGen, or other recent unified models) in the text provided, relying heavily on the claim of SOTA performance. The "vibe speech" and mixture generation capabilities are novel but require rigorous human evaluation to validate quality, which is not fully detailed in the excerpt.
The paper provides a demo URL for audio samples, which is a positive step for qualitative assessment. However, as a technical report from a commercial entity (StepFun), the availability of code, model weights, and detailed hyperparameters is not explicitly confirmed in the text. The specific implementation details of the "interference-aware progressive pretraining" and the "RVQ Adaptor" are described conceptually but may lack the granular detail necessary for full independent reproduction without access to the proprietary codebase.
The primary limitation is the reliance on a proprietary tokenizer and training pipeline, which may limit community adoption compared to open-source alternatives. The 12.5 Hz frame rate is relatively low for high-fidelity audio reconstruction, potentially capping the maximum audio quality compared to higher-rate models. Furthermore, the "general-purpose" claim is ambitious; unifying music, speech, and SFX in a single discrete autoregressive model often leads to trade-offs in quality for individual domains compared to specialized models. The lack of detailed ablation studies in the provided text makes it difficult to isolate the contribution of each design principle.
This work contributes to the trend of unifying diverse audio generation tasks into single LLM-based frameworks. If the claimed SOTA performance is verified, it could shift the field's focus from diffusion models to discrete autoregressive models for audio, potentially offering faster inference and better integration with existing LLM ecosystems. The ability to generate mixtures of audio types is a significant step toward more flexible and creative audio production tools. StepAudio 3 Gen introduces a unified discrete autoregressive framework for general audio generation that claims state-of-the-art performance across speech, music, and sound effects by leveraging a shared residual vector quantization tokenizer and a hybrid autoregressive architecture. The paper presents a significant architectural departure from diffusion-based models, offering a scalable path for integrating diverse audio tasks into large language models, though its impact is tempered by the proprietary nature of the implementation and the need for further independent verification of its claimed superiority over specialized baselines.
Agent usage is shifting toward long-horizon tasks such as coding and scientific discovery, among which terminal tasks are especially important. We introduce T1, a Mixture-of-Experts model of 122B total trained with reinforcement learning, operating a real shell in a cloud sandbox for up to 300+ tool-call turns per task, rewarded by executing each task's own verifier. We provide a comprehensive recipe: First, an aggressively warm-started to stabilize actor-critic training, with a dense process reward scoring trajectories by the absolute number of passing verifiers. Second, stable optimization through TITO construction, training on the exact sampled token identifiers with drift repair at turn boundaries, and rollout routing replay, recording the sampler's per-token expert choices at every MoE layer and replaying them during training. Third, fully out-of-distribution training corpus: isolated seeds and synthesized tasks disjoint from Terminal-Bench 2.1 ensures gains reflect genuine capability transfer over benchmark overfitting. Together, TITO and R3 cut the training-to-inference log-probability difference from 0.021 to 0.013, with exactly aligned zero token drift in the loss region. On Terminal-Bench 2.1, our post-train pipeline raises initial base model from 43.8% to T1 with 64.0% resolved. On Long-Horizon Terminal Bench, T1 reaches 27.9% and surpasses GPT-5.4 and GLM-5.1.
Primary: Alibaba Group
All Institutions: Alibaba Group, Tsinghua University
The paper presents a comprehensive and technically rigorous approach to training large MoE agents via RL, introducing novel stabilization techniques (TITO and R3) that are critical for scaling RL to sparse models. Its strong empirical results on terminal benchmarks demonstrate a significant leap in autonomous software engineering capabilities, establishing a new standard for long-horizon agentic tasks.
The paper introduces a robust framework for training large Mixture-of-Experts (MoE) models using Reinforcement Learning (RL) in long-horizon, stateful environments (Linux terminals). The core technical contribution is the "TITO" (Token-In-Token-Out) and "R3" (Rollout Routing Replay) mechanisms. TITO addresses the training-inference mismatch caused by tokenization drift in multi-turn agentic loops by ensuring the trainer consumes the exact token identifiers generated by the sampler, repairing boundary discrepancies. R3 addresses the unique challenge of MoE models where discrete expert routing decisions made during inference can differ from those recomputed during training due to numerical precision differences; R3 records the expert masks during rollout and replays them during the training forward pass. Additionally, the paper proposes a dense process reward based on the absolute number of passing verifier assertions, which provides a much richer learning signal than binary success/fail rewards for difficult tasks. The methodology is rigorous, addressing specific, non-trivial engineering challenges in scaling RL to sparse models.
The experiments are extensive, utilizing a 122B parameter MoE model (Qwen3.5-122B-A10B) trained on 15,000 synthesized terminal tasks. The evaluation is conducted on three held-out benchmarks: Terminal-Bench 2.1, Long-Horizon Terminal-Bench (LHTB), and Terminal-Bench Hard. The results show a significant improvement from the base model (43.8%) to the final T1 model (64.0%) on Terminal-Bench 2.1, surpassing several frontier models like GPT-5.4 and GLM-5.1. The ablation studies clearly demonstrate the necessity of both TITO and R3 for stabilizing training, as well as the benefit of the dense reward over binary rewards. The analysis of training dynamics, including explained variance and turn count growth, provides deep insight into the learning process.
The paper provides high levels of detail regarding the training infrastructure, hyperparameters, and specific mechanisms like the routing replay algorithm. It describes the dataset construction process (RST) and the audit criteria for task selection. However, the specific code for the TITO and R3 implementations is not explicitly linked in the provided text (though likely available via the authors' repositories), and the exact hardware configuration for the 122B model training is only partially detailed. The use of proprietary or specific internal tools (like the "slime" framework) may limit immediate reproducibility for external labs without access to those specific infrastructure components.
The primary limitation is the reliance on a large-scale, proprietary infrastructure to train a 122B MoE model, making the results difficult to replicate for smaller labs. The evaluation is limited to terminal tasks, and while the paper argues for generalization, the specific domain of Linux shell operations is narrow. Additionally, the paper acknowledges that the model still struggles with the hardest tasks (Terminal-Bench Hard) compared to some larger dense models, and the "inefficient search" behavior (high turn counts) suggests that the model has not fully mastered optimal planning, merely improving its persistence and partial success rates.
This work is significant for the development of autonomous agents capable of performing complex, long-horizon software engineering tasks. By solving the stability issues of RL in MoE models, it paves the way for more efficient and capable agentic systems. The dense reward design is a valuable contribution to the RL community, offering a practical solution to the sparse reward problem in verifiable environments. The findings on training-inference consistency in sparse models will be relevant to any group working on large-scale MoE RL. The paper presents a comprehensive and technically rigorous approach to training large MoE agents via RL, introducing novel stabilization techniques (TITO and R3) that are critical for scaling RL to sparse models. Its strong empirical results on terminal benchmarks demonstrate a significant leap in autonomous software engineering capabilities, establishing a new standard for long-horizon agentic tasks.
Commercial text-to-image systems silently revise user prompts before generating images, a step users typically cannot disable or even see. Yet, existing audits of cultural bias examine only the final images and treat generation as a single pipeline, so they cannot tell where the bias originates. We introduce WORLDVIEW, a multilingual benchmark of 8,960 prompts across 15 languages and 31 language-context pairings. Using it, we audit the revision layer in three systems (DALL-E-3, Imagen-4, GPT-Image-1.5) through a three-step analysis of how heavily it marks each cultural context, whether it flattens that context into a narrow vocabulary, and whether that vocabulary is stereotypical. Relative to a no-context English baseline, the US is the least-marked context, while non-Western and non-Anglophone contexts are marked far more heavily, flattened into narrow vocabularies applied across topically diverse prompts, and reduced to recognizable cultural stereotypes. Comparing images from original versus revised prompts on models without a revision layer, we identify the layer itself as a previously undocumented, causal source of this stereotyping. To locate cultural bias, and fix it, we must audit the system as deployed, not the model alone.
Primary: University of Zurich
All Institutions: University of Zurich, Stanford University
The paper identifies the prompt revision layer in commercial text-to-image systems as a previously undocumented, causal source of cultural bias and stereotyping. By introducing the WORLDVIEW benchmark and a three-step audit framework, it demonstrates that non-Western cultures are disproportionately flattened into narrow, stereotypical vocabularies before image generation, necessitating a shift in bias mitigation strategies to include the entire deployed pipeline.
The paper introduces a rigorous three-step analytical framework (Contextual Markedness Score, Cultural Flattening Score, and Stereotypical Content Analysis) to audit the "prompt revision" layer in commercial text-to-image systems. By isolating this intermediate text-to-text transformation, the authors address a critical blind spot in prior bias audits that treated the generation pipeline as monolithic. The methodology is sound, utilizing sentence embeddings for markedness and TF-IDF for flattening, with a well-designed causal ablation study using open-source models to verify that the revision layer, not just the image model, drives stereotypical outputs.
The experimental setup is robust, featuring a new multilingual benchmark (WORLDVIEW) with 8,960 prompts across 15 languages and 31 contexts. The evaluation covers three major commercial systems (DALL-E-3, Imagen-4, GPT-Image-1.5). The results clearly demonstrate that non-Western contexts are disproportionately marked and flattened into stereotypical vocabularies (e.g., Egypt reduced to pyramids, Finland to snow). The causal link established via ablation on SDXL and Flux models is a strong technical contribution, proving the revision layer is a distinct source of bias.
High. The authors release the benchmark, revised prompts, metrics, and evaluation toolkit on GitHub. The use of standard APIs and open-source models for the ablation study ensures that the findings can be replicated by other researchers.
The causal ablation is restricted to English-speaking contexts due to language confounds, though a case study on Switzerland partially mitigates this. The study relies on VQA models for image description, which may introduce their own biases, although the authors argue the comparative design mitigates this. The benchmark, while broad, still underrepresents certain regions like Sub-Saharan Africa.
This paper has significant implications for AI safety and fairness research. It shifts the focus of bias mitigation from just the image generation model to the entire deployed system, including preprocessing layers. This insight is crucial for developers of commercial T2I systems, as it highlights that debiasing the image model alone is insufficient if the prompt revision layer injects stereotypes. It provides a actionable framework for auditing these hidden layers. The paper identifies the prompt revision layer in commercial text-to-image systems as a previously undocumented, causal source of cultural bias and stereotyping. By introducing the WORLDVIEW benchmark and a three-step audit framework, it demonstrates that non-Western cultures are disproportionately flattened into narrow, stereotypical vocabularies before image generation, necessitating a shift in bias mitigation strategies to include the entire deployed pipeline.
Most of mathematical knowledge has been communicated through so-called informal use of mathematics and natural language. With large language models (LLMs) being highly adept in using natural language, they achieve strong performance, yet not perfect, in informal mathematical reasoning. Restraining LLMs to informal reasoning misses out on the opportunity to use the discrete verification abilities that machines offer through machine-checkable proofs. In this paper, we bridge the gap between informal and formal reasoning by integrating Lean signals into the informal reasoning process. We introduce Magenta, a training-free agentic pipeline that, given only a natural-language problem, produces an answer, expresses it as a Lean 4 statement, and constructs a machine-checked proof. A statement judge verifies whether the formalisation preserves the original problem, while an error-attribution judge routes failed attempts either to mathematical re-derivation or local Lean repair. Magenta achieves 100% accuracy across all evaluated olympiad benchmarks, including AIME 2025, AIME 2026, and HMMT February 2026. When paired with the open-weight K2-Horizon-7B reasoner, it solves all six IMO 2026 problems. Our analysis shows that statement adjudication is essential for preventing false certificates and that feedback-guided correction outperforms independent resampling on difficult problems.
Primary: Imperial College London
All Institutions: Imperial College London, University College London
Magenta introduces a training-free agentic pipeline that integrates Lean 4 formal verification into LLM mathematical reasoning, achieving 100% accuracy on AIME/HMMT benchmarks and solving all IMO 2026 problems with a 7B model by using statement adjudication and error attribution to guide self-correction.
The paper introduces "Magenta," a training-free agentic pipeline that integrates informal LLM reasoning with formal Lean 4 verification. The core methodological contribution is the closed-loop feedback mechanism: a "Statement Judge" ensures the formalization is faithful to the natural language problem (addressing the autoformalization gap), and an "Error Attribution Judge" routes verification failures to either mathematical re-derivation or local proof repair. This distinction is crucial, as it prevents the system from wasting compute on syntax errors when the math is wrong, or vice versa. The use of a deterministic verifier (Lean) as a hard constraint on LLM outputs is a strong architectural choice that differentiates it from purely learned reward models.
The experiments are extensive, covering AIME 2025/2026, HMMT 2026, and IMO 2026. The claim of 100% accuracy on AIME/HMMT and solving all IMO 2026 problems with a 7B model is striking. Ablations effectively demonstrate the necessity of the Statement Judge (showing high false certification rates without it) and the Error Judge (showing superior performance over independent resampling). The robustness check via paraphrasing helps mitigate concerns about data contamination, though the perfect scores on recent benchmarks remain a point of scrutiny.
The paper provides high reproducibility standards, including verbatim prompt templates for all components (Reasoner, Formaliser, Judges, Prover), detailed hyperparameter settings, and specific model versions (e.g., Lean v4.29.1, Mathlib). The use of open-weight models for the core pipeline (K2-Horizon, Goedel, Leanstral) further enhances reproducibility compared to closed-source baselines.
The primary limitation is the "soft certificate" nature of the output: Lean verifies the proof relative to the generated statement, but the Statement Judge is a learned proxy that can still fail, meaning the final answer is not unconditionally guaranteed correct with respect to the original natural language problem. Additionally, the computational cost is significant, requiring multiple LLM calls and Lean compilation cycles, which may limit real-time applicability. The reliance on specific, potentially proprietary or rapidly evolving model versions (like K2-Horizon) could affect long-term reproducibility.
This work bridges a critical gap in AI for Science, enabling LLMs to produce mathematically rigorous, machine-checked proofs. It sets a new standard for mathematical reasoning benchmarks and offers a template for integrating formal verification into other domains where correctness is paramount (e.g., code generation, logic synthesis). The finding that small models can solve IMO problems with verification-guided correction challenges the assumption that scale is the only driver of capability in complex reasoning tasks. Magenta introduces a training-free agentic pipeline that integrates Lean 4 formal verification into LLM mathematical reasoning, achieving 100% accuracy on AIME/HMMT benchmarks and solving all IMO 2026 problems with a 7B model by using statement adjudication and error attribution to guide self-correction.
Driving vision-language-action (VLA) models increasingly reason before acting, but their intermediate reasoning is often weakly grounded in physical scene evidence and loosely connected to executable behavior. We present GRAVA, a framework built around Grounded Reasoning-to-Action (GRA), which unifies grounding, reasoning, and action generation in a single autoregressive stream. GRA links action-relevant language references to 2D visual regions and ego-centric physical states, organizes object interactions and decisions in a trajectory-anchored typed graph, and serializes this structure into grounded reasoning. A single VLM generates this reasoning followed by a compact Executable Planner action that is deterministically decoded into a continuous trajectory. We further introduce an agentic GRA data construction pipeline that combines forward scene grounding with backward trajectory anchoring, and use it to build GR-NavSim with 2.2M grounded question-answer pairs and 70K GRA reasoning traces. A progressive training strategy develops grounded cognition through pre-training, establishes the reasoning-to-action interface through imitation, and improves driving behavior through reinforcement learning and exploration. Using about 60% of the available human driving demonstrations for action supervision, GRAVA-8B achieves state-of-the-art performance among purely autoregressive driving models on the full NAVSIM benchmark. On an internal long-tail benchmark, full GRA improves key-object compliance and Closed-loop Driving Score by 19.3% and 20.5% over action-only prediction, respectively. These results show the benefit of preserving action-relevant physical evidence from grounded reasoning through executable action generation.
Primary: Beijing Institute of Technology
All Institutions: Beijing Institute of Technology, Shenzhen Automotive Research Institute, Shenzhen Jiguangzhijie Technology Co., Ltd., Nanyang Technological University
GRAVA introduces a unified framework for grounded reasoning-to-action in autonomous driving, achieving state-of-the-art performance on NAVSIM by integrating visual grounding, reasoning, and action generation in a single autoregressive stream with a novel trajectory-anchored graph representation and agentic data construction pipeline.
The paper proposes GRAVA, a framework that unifies visual grounding, reasoning, and action generation in a single autoregressive stream for autonomous driving. The core novelty lies in the "Grounded Reasoning-to-Action" (GRA) representation, which uses a trajectory-anchored typed graph to link linguistic references to 2D visual regions and ego-centric physical states. This structure is serialized into a reasoning sequence that directly precedes a compact "Executable Planner" action. The methodology is sound, addressing the "grounding gap" and "reasoning-to-action fragmentation" by ensuring that the physical evidence used in reasoning is explicitly connected to the final trajectory. The introduction of an agentic data construction pipeline that combines forward scene grounding with backward trajectory anchoring is a strong technical contribution, ensuring consistency between cognition and planning supervision. The progressive training strategy (pre-training, imitation, self-distillation, and Active RL) is well-structured and logically justified.
The experimental evaluation is rigorous and comprehensive. The authors benchmark GRAVA on the NAVSIM dataset, achieving state-of-the-art performance (90.48 PDMS) among purely autoregressive driving models. The ablation studies are extensive, isolating the contributions of the GRA representation, the Executable Planner, and the Active RL loop. The introduction of an internal long-tail benchmark (50K clips) to evaluate complex interactions like route obstructions and lane borrowing is a valuable addition, as public benchmarks often lack such coverage. The metrics used (PDMS, Key-Object Compliance, Closed-loop Driving Score) are appropriate for assessing both safety and progress. The results clearly demonstrate the benefit of preserving action-relevant physical evidence from grounded reasoning.
The paper provides a code repository link, which is a positive factor. However, the reliance on an "internal long-tail benchmark" limits the full reproducibility of the long-tail performance claims, as this dataset is not publicly released. The details of the agentic data construction pipeline and the specific implementation of the Active RL loop are described with sufficient detail for replication, assuming access to the nuPlan dataset and the Qwen3-VL backbone. The use of a fixed geometric decoder for the Executable Planner simplifies the action decoding process, aiding reproducibility.
The primary limitation is the dependence on the Qwen3-VL-8B backbone, which may limit the generalizability of the results to other VLM architectures. The internal long-tail benchmark, while valuable, is not publicly available, making it difficult for other researchers to verify the long-tail performance improvements. Additionally, the computational cost of the agentic data construction pipeline and the Active RL loop could be significant, potentially limiting adoption in resource-constrained settings. The paper does not extensively discuss the latency of the autoregressive reasoning process, which is a critical factor for real-time autonomous driving applications.
The paper has significant potential impact on the field of autonomous driving and vision-language-action models. By demonstrating that grounded reasoning can be effectively integrated with action generation in a single autoregressive stream, it provides a new paradigm for developing driving VLAs. The GRA representation and the agentic data construction pipeline could be adopted by other researchers to improve the grounding and reasoning capabilities of their models. The focus on long-tail scenarios and the use of reinforcement learning to refine reasoning-to-action sequences align with current trends in the field, suggesting that the work will be influential in shaping future research directions. GRAVA introduces a unified framework for grounded reasoning-to-action in autonomous driving, achieving state-of-the-art performance on NAVSIM by integrating visual grounding, reasoning, and action generation in a single autoregressive stream with a novel trajectory-anchored graph representation and agentic data construction pipeline.
Recovering editable 3D parametric curves from 2D images is a fundamental challenge in computer graphics, bridging pixel-based perception and vector-based CAD modeling. Existing NeRF- and 3DGS-based methods often rely on dense calibrated views, precomputed 2D edge maps, and costly per-scene optimization, limiting their applicability to casually captured real-world inputs. We propose CGGT, a Curve-Grounded Geometry Transformer that directly grounds 3D-consistent 2D curve instances in the image space from sparse, unposed multi-view images. CGGT combines a geometry-aware transformer encoder for multi-view feature learning with a curve-aware masked-attention decoder for cross-view instance association. In a single forward pass, it predicts camera parameters, dense depth maps, and instance-level 2D curve masks, which are then lifted into 3D and refined through a fast parametric optimization stage to recover compact, editable 3D curve primitives. To support structured curve learning, we introduce Wireframe-100K, a large-scale dataset comprising 100,000 CAD models with diverse topologies, realistic multi-view renderings, and accurate parametric curve annotations. Extensive experiments show that our framework achieves substantial improvements in both reconstruction accuracy and efficiency, particularly under challenging sparse-view settings and in separating persistent 3D structural edges from view-dependent image edges caused by silhouettes, textures, and appearance variations. Despite being trained solely on synthetic data, CGGT generalizes well to real-world images, demonstrating its potential for practical CAD-style wireframe reconstruction from unconstrained visual inputs.
Primary: National University of Defense Technology
All Institutions: National University of Defense Technology, Hunan University, Shenzhen University, Jiangsu Key Laboratory of AI for Industries, Institute of AI for Industries, Chinese Academy of Sciences
The paper presents a robust and efficient framework for 3D parametric curve reconstruction from sparse, unposed images, supported by a large-scale synthetic dataset. By combining a geometry-aware transformer for multi-view feature learning with a fast parametric optimization stage, CGGT achieves high-accuracy, editable CAD wireframe reconstruction that generalizes well to real-world inputs, representing a significant step forward in bridging computer vision and computer graphics.
The paper proposes CGGT, a transformer-based architecture designed to reconstruct editable 3D parametric curves from sparse, unposed multi-view images. The methodology is structured in two main phases: a learning-based front-end and an optimization-based back-end. The front-end utilizes a geometry-aware transformer encoder to process multi-view features and a curve-aware masked-attention decoder to associate 2D curve instances across views. This allows the model to predict camera parameters, dense depth maps, and instance-level 2D curve masks in a single forward pass. The back-end lifts these 2D predictions into 3D and refines them using a fast parametric optimization stage to recover compact curve primitives. The approach addresses the limitations of existing NeRF/3DGS methods, which typically require dense calibrated views and per-scene optimization, by enabling single-pass inference on casual, unposed inputs. The introduction of a "curve-grounded" attention mechanism for cross-view instance association is a logical and effective architectural choice for this specific problem.
The authors introduce Wireframe-100K, a significant contribution consisting of 100,000 CAD models with 5 million realistic multi-view renderings and accurate parametric curve annotations. This dataset addresses a critical gap in large-scale, structured curve learning data. Experiments demonstrate substantial improvements in reconstruction accuracy and efficiency compared to baselines, particularly in sparse-view settings. A key strength highlighted is the model's ability to distinguish persistent 3D structural edges from view-dependent artifacts (silhouettes, textures). The claim of generalization from synthetic training data to real-world images is a strong empirical result, suggesting robust feature learning. The acceptance at SIGGRAPH Asia 2026, a top-tier venue for graphics and vision, further validates the quality of the experimental rigor and results.
The paper provides a project page URL, which likely contains code and dataset links. The introduction of a large-scale dataset (Wireframe-100K) significantly aids reproducibility for future work in this niche. However, the specific details of the "fast parametric optimization stage" and the exact transformer architecture hyperparameters would need to be verified in the full code release. The reliance on synthetic data for training is a standard practice in this field, but the gap between synthetic and real-world data is a potential reproducibility challenge for users without access to the specific rendering pipeline used to generate Wireframe-100K.
The method relies on a two-stage process (learning + optimization), which may introduce latency compared to purely end-to-end differentiable approaches, although the paper claims efficiency. The generalization to real-world images is promising but may still suffer from domain shift in highly complex or non-CAD-like scenes. The dataset, while large, is synthetic; performance on truly unconstrained, noisy real-world photos with severe occlusions or lighting variations may be limited. The "parametric" nature of the output restricts the method to objects that can be represented by standard curve primitives, potentially limiting applicability to free-form organic shapes.
This work bridges the gap between pixel-based perception and vector-based CAD modeling, which has significant implications for automated design, reverse engineering, and augmented reality. The ability to recover editable 3D curves from casual photos could streamline workflows in industrial design and manufacturing. The release of Wireframe-100K will likely accelerate research in 3D shape understanding and vectorization. The method's efficiency and single-pass nature make it more practical for real-time or near-real-time applications compared to optimization-heavy baselines. The paper presents a robust and efficient framework for 3D parametric curve reconstruction from sparse, unposed images, supported by a large-scale synthetic dataset. By combining a geometry-aware transformer for multi-view feature learning with a fast parametric optimization stage, CGGT achieves high-accuracy, editable CAD wireframe reconstruction that generalizes well to real-world inputs, representing a significant step forward in bridging computer vision and computer graphics.
While Vision-Language Models (VLMs) excel at visual reasoning, generating structured, editable Scalable Vector Graphics (SVG) remains a fundamental challenge. Existing pipelines predominantly yield flat, semantically agnostic collections of paths, where editing a single object requires manually identifying its constituent paths. To address this, we propose a VLM-driven agentic framework for semantic compositional SVG generation. Our pipeline recursively parses visual scenes into semantic and geometric hierarchies via top-down decomposition, visual grounding, and prompt-driven amodal occlusion recovery, ensuring each component is geometrically complete. Furthermore, we introduce the Semantic SVG Benchmark with human-annotated semantic groups and novel sub-component metrics (Semantic Recall/Precision, PERE) to explicitly evaluate structural compositionality and functional editability. Experiments show that our natively predicted structures surpass the upper bounds of existing flat-generation methods in both grouping quality and editability, while maintaining state-of-the-art visual fidelity.
Primary: Unknown
All Institutions: Unknown
The paper introduces a VLM-driven agentic framework for semantic compositional SVG generation, addressing the lack of structural editability in current vectorization methods. By proposing a recursive decomposition pipeline with amodal occlusion recovery and introducing a dedicated benchmark with novel semantic metrics, the work provides a rigorous step towards structured, editable AI-generated graphics, offering a significant improvement over flat-path generation baselines.
The paper proposes a VLM-driven agentic framework for generating structured, editable SVGs. The core method involves recursive top-down decomposition of visual scenes into semantic and geometric hierarchies. Key technical components include visual grounding to localize objects and a prompt-driven mechanism for amodal occlusion recovery, which aims to ensure geometric completeness of occluded parts. The approach moves beyond flat path generation by explicitly modeling semantic groups, allowing for functional editability. The methodology is logically sound and addresses a genuine gap in current vectorization pipelines, which typically output unstructured path collections.
The authors introduce a new benchmark, "Semantic SVG Benchmark," with human-annotated semantic groups. They propose novel metrics: Semantic Recall/Precision and PERE (likely a typo for a specific editability metric, possibly "Path Editability Rate" or similar, though not explicitly defined in the abstract). Experiments claim that the proposed method surpasses the upper bounds of existing flat-generation methods in grouping quality and editability while maintaining state-of-the-art visual fidelity. The introduction of a dedicated benchmark for semantic compositionality is a significant contribution, as previous evaluations focused primarily on pixel-level or path-level fidelity.
The paper is 26 pages long and accepted to a major venue (EMNLP 2026), suggesting a level of detail expected for reproducibility. However, without access to the full code or specific hyperparameters for the VLM prompts and decomposition thresholds, exact reproduction may be challenging. The reliance on "prompt-driven" mechanisms can introduce variability. The benchmark's release is crucial for community adoption.
The primary limitation is the dependence on the underlying VLM's reasoning capabilities; if the VLM fails at visual grounding or occlusion reasoning, the structural output will be flawed. Additionally, the computational cost of recursive decomposition and agentic loops may be high compared to single-pass vectorization. The definition of "PERE" needs clarification in the full text to ensure metric validity.
This work has significant potential impact on the design and creative industries, where editable vector graphics are essential. By enabling semantic understanding in SVG generation, it bridges the gap between AI-generated art and human-editable assets. It could facilitate new workflows where users can edit AI-generated images by selecting semantic objects rather than individual paths. The paper introduces a VLM-driven agentic framework for semantic compositional SVG generation, addressing the lack of structural editability in current vectorization methods. By proposing a recursive decomposition pipeline with amodal occlusion recovery and introducing a dedicated benchmark with novel semantic metrics, the work provides a rigorous step towards structured, editable AI-generated graphics, offering a significant improvement over flat-path generation baselines.
Natural interaction in digital and physical environments requires continuous perception and timely responses. Spoken dialogue relies on acoustic and linguistic cues, while video interaction also requires grounding the conversation in evolving visual context. We present Realtime-Venus, a proactive full-duplex interaction system with two separately trained 9B models: Realtime-Venus-Omni for audio-visual interaction and Realtime-Venus-Audio for spoken interaction. Each model serves as a complete conversational frontend, integrating continuous perception, conversational control, and native speech generation through a shared causal timeline for user inputs, model outputs, and delegation events. A dual-loop runtime coordinates live interaction with background reasoning and tool execution. Foreground interaction continues while Realtime-Venus-Harness executes tasks asynchronously and returns results for integration into the ongoing dialogue. Both models follow a common post-training recipe combining offline understanding, proactive full-duplex trajectories, and delegation workflows. Among the evaluated online models, Realtime-Venus-Omni achieves the highest scores on six of eight video benchmarks, including StreamingBench (70.2%), OVO-Bench (64.7%), and Daily-Omni (81.3%). Across eight audio understanding and spoken question answering benchmarks, Realtime-Venus-Audio leads the compared models on MMAU (78.0%), MMAU-Pro (63.2%), Llama Questions (83.8%), and Speech CMMLU (67.8%), while matching the best VoiceBench AlpacaEval score of 4.81. On Full-Duplex-Bench v1.5, Realtime-Venus-Audio responds to 75% of user interruptions and achieves continuation rates of 97%, 88%, and 86% under backchannels, other-directed speech, and background speech, respectively, exceeding Gemini 3.1 Live and GPT-4o on all three continuation metrics.
Primary: Tsinghua University
All Institutions: Tsinghua University, Ant Group
Realtime-Venus introduces a dual-loop architecture that effectively separates real-time conversational control from asynchronous background reasoning, achieving state-of-the-art performance in full-duplex interaction metrics while maintaining strong multimodal understanding.
The paper proposes Realtime-Venus, a system architecture for full-duplex, proactive multimodal interaction. The core methodological contribution is the "dual-loop" runtime design that decouples the latency-sensitive conversational frontend (9B parameter models for audio and audio-visual) from a background "Harness" responsible for asynchronous tool execution and complex reasoning. The models are trained on a unified streaming formulation where user inputs, model outputs, and delegation events share a causal timeline. The training pipeline is notable for its synthesis of "proactive full-duplex trajectories," which explicitly supervise the model on when to listen, speak, interrupt, or delegate, rather than just standard turn-taking. The use of specific control tokens (<|listen|>, <|speak|>,
The evaluation is extensive, covering 8 video benchmarks, 8 audio benchmarks, and specific full-duplex interaction metrics (Full-Duplex-Bench v1.5 and v3). The results show that Realtime-Venus-Omni outperforms strong baselines like MiniCPM-o 4.5 and Gemini 3.1 Live on several key metrics, particularly in continuation rates during backchannels and background speech (97% and 86% respectively). The tool-use evaluation (FDB-v3) shows competent but not dominant performance compared to specialized agents like GPT-Realtime, which is an honest and useful finding. The memory augmentation experiments demonstrate clear gains in long-video understanding, validating the utility of the harness for state management.
The paper provides high-level architectural details and training data composition (2.8M samples), but specific hyperparameters, exact data generation scripts for the synthetic duplex trajectories, and the code for the "Harness" are not fully detailed in the text provided. The reliance on internal benchmarks (the "delegate benchmark") limits external reproducibility of those specific results. However, the use of public benchmarks (MMAU, StreamingBench, etc.) allows for partial verification.
The primary limitation is the lack of open-source code or weights mentioned in the text, which hinders immediate adoption. The tool-use performance, while good, lags behind dedicated function-calling models, suggesting the 9B frontend may struggle with complex multi-step tool orchestration without the harness. The paper also admits that the lower scores on ProactiveVideoQA and WorldSense compared to MiniCPM-o 4.5 indicate that the focus on interaction control may have come at a slight cost to pure offline video understanding.
This paper is significant for the development of real-time AI assistants. The separation of "fast" conversational responses from "slow" background reasoning is a critical pattern for deploying LLMs in real-time applications. The detailed approach to training models on full-duplex, overlapping speech scenarios (backchannels, interruptions) provides a valuable template for future speech-agent research. It moves the field beyond simple turn-based chatbots toward more natural, continuous interaction. Realtime-Venus introduces a dual-loop architecture that effectively separates real-time conversational control from asynchronous background reasoning, achieving state-of-the-art performance in full-duplex interaction metrics while maintaining strong multimodal understanding.
Visual Autoregressive Models (VAR) generate images through next-scale prediction, producing all tokens within each scale in parallel. We show that this parallel decoding constitutes a mean-field-style approximation that discards spatial dependencies among same-scale tokens, causing locally incoherent samples regardless of backbone capacity -- a limitation of the decoding rule. Addressing this limitation, we introduce the Logit Refiner, a lightweight autoregressive module that restores intra-scale dependencies by sequentially sampling tokens conditioned on frozen backbone features. Adding only ~10% parameters and less than 5% of the base model's training compute, it plugs into any pretrained VAR checkpoint without retraining. Controlled ablations isolate joint intra-scale sampling -- rather than additional capacity or training -- as the critical ingredient. Across backbones from 310M to 2B parameters on class-conditional ImageNet 256x256, the refiner consistently improves generation quality, enabling a 1.1B-parameter model to surpass one twice its size. The approach further generalizes to text-to-image generation, confirming that the mean-field bottleneck persists across VAR variants and is effectively alleviated by our method. Project page: https://compvis.github.io/logit-refiner/
Primary: LMU Munich
All Institutions: LMU Munich, Munich Center for Machine Learning (MCML)
The paper introduces the Logit Refiner, a lightweight module that restores intra-scale spatial dependencies in Visual Autoregressive models by sequentially refining logits, significantly improving generation quality without retraining the base backbone. This work provides a clear diagnosis of the mean-field approximation limitation in parallel VAR decoding and offers an efficient, plug-and-play solution that demonstrates strong empirical gains across model scales and tasks, representing a solid contribution to the field of autoregressive image generation.
The paper identifies a specific structural weakness in Visual Autoregressive (VAR) models: the parallel decoding of tokens within a scale acts as a mean-field approximation, ignoring spatial dependencies between same-scale tokens. The proposed solution, the "Logit Refiner," is a lightweight autoregressive module that sequentially refines logits conditioned on frozen backbone features. This approach is elegant in its simplicity, requiring only ~10% additional parameters and minimal training compute, and it plugs into existing checkpoints without retraining the base model. The theoretical framing of the problem as a mean-field approximation is insightful and provides a clear motivation for the sequential refinement step.
The experiments are rigorous and well-controlled. The authors test across multiple backbone sizes (310M to 2B) on ImageNet 256x256, demonstrating consistent improvements in FID and IS metrics. A key strength is the ablation study that isolates the effect of intra-scale dependency modeling from mere increases in capacity or training data, confirming that the sequential sampling mechanism is the critical factor. The generalization to text-to-image generation further validates the robustness of the method. The claim that a 1.1B model with the refiner surpasses a 2B model without it is a strong empirical result.
The paper provides sufficient details on the architecture of the Logit Refiner and the training procedure. The project page likely contains code, which is standard for this group. The method's plug-and-play nature enhances reproducibility, as it does not require complex retraining pipelines for the base model.
The primary limitation is the increased inference latency due to the sequential refinement step, which partially negates the speed advantage of VAR's parallel decoding. While the paper notes the compute cost is low during training, the inference cost could be significant for real-time applications. Additionally, the method is specific to VAR architectures and may not directly apply to other autoregressive or diffusion-based models without modification.
This work has significant implications for the design of autoregressive generative models. By highlighting the trade-off between parallel efficiency and spatial coherence, it guides future research in hybrid decoding strategies. The plug-and-play nature of the refiner makes it an attractive tool for practitioners using existing VAR checkpoints, potentially extending the utility of current models without the need for expensive retraining. The paper introduces the Logit Refiner, a lightweight module that restores intra-scale spatial dependencies in Visual Autoregressive models by sequentially refining logits, significantly improving generation quality without retraining the base backbone. This work provides a clear diagnosis of the mean-field approximation limitation in parallel VAR decoding and offers an efficient, plug-and-play solution that demonstrates strong empirical gains across model scales and tasks, representing a solid contribution to the field of autoregressive image generation.
Aligning multi-turn dialogue agents is usually framed as matching turn-level human preferences, yet direct optimization of long-term outcomes is often ineffective and prone to reward hacking. We formulate long-horizon dialogue optimization as a multi-objective reinforcement learning problem and train a multi-head value model that predicts a vector of observed user behaviors across multiple look-ahead horizons. Our findings demonstrate that a scalarized composite of dense auxiliary behavioral signals enables effective credit assignment and optimization of sparse outcomes. However, optimizing unconstrained single-objective proxies might induce policy degradations that are harmful when the agent is exposed to real users. To identify these failure modes prior to deployment, we establish a safety framework combining counterfactual user simulation with a validated dialogue-level outcome model to evaluate preference weightings and policy optimization methods. Finally, we demonstrate that distilling multi-objective value preferences into the policy via reference-anchored preference optimization matches on-policy online RL at a small fraction of its compute budget. Live A/B testing confirms that our distilled policy significantly improves long-term user retention, while simultaneously enhancing the positive behaviors and therapeutic-process markers.
Primary: Slingshot AI
All Institutions: Slingshot AI, Biomedical Research Alliance of New York (BRANY)
The paper presents a robust and empirically validated framework for aligning multi-turn dialogue agents using multi-objective value models and counterfactual simulation to optimize long-term user outcomes while mitigating reward hacking. By demonstrating that dense auxiliary behavioral signals enable effective credit assignment for sparse retention metrics, and that offline preference distillation can match on-policy RL at a fraction of the cost, the work offers a significant methodological advance for the field of RLHF, particularly in safety-critical applications.
The paper proposes a rigorous framework for aligning multi-turn dialogue agents by formulating the problem as a multi-objective reinforcement learning task. Instead of relying on a single scalar reward model which is prone to reward hacking, the authors train a multi-head value model that predicts a vector of 39 distinct user behaviors across multiple look-ahead horizons (e.g., next 1, 2, 5 messages; return within 1, 3, 7 days). The core methodological contribution is the use of a scalarized composite of these dense auxiliary signals to enable effective credit assignment for sparse long-term outcomes (retention). The paper introduces a safety framework combining counterfactual user simulation (using a DIAL-trained simulator) with a validated dialogue-level outcome model to screen for policy degradations (such as sycophancy or suppression of disclosure) before deployment. Finally, it demonstrates that distilling these multi-objective preferences into the policy via reference-anchored preference optimization (specifically DPO/LD-DPO) matches the performance of on-policy RL (GRPO) at a fraction of the compute cost. The methodology is sound, leveraging standard RL concepts (value functions, policy improvement) but applying them in a novel, safety-conscious manner to the specific challenges of long-horizon dialogue.
The experimental evaluation is extensive and well-controlled. The authors conduct offline evaluations on 1,500 real conversation prefixes, comparing ten different reward weightings and seven different distillation objectives. They rigorously validate their outcome model against 16 live experiments and 43 strategy pairs, showing a directional agreement of 86%. The paper includes a live A/B test with 6,700 users per arm over three weeks, demonstrating significant improvements in day-1 and day-7 retention (+2.15pp and +2.60pp respectively) while maintaining or improving positive therapeutic markers. The statistical analysis is robust, using Benjamini-Hochberg correction for multiple comparisons and paired tests for simulated data. The identification of specific failure modes (e.g., IPO collapsing to filler tokens, GRPO becoming verbose) through qualitative analysis of simulated dialogues adds significant depth to the quantitative results.
The paper provides high reproducibility standards. It details the architecture of the value model, the specific hyperparameters for LoRA training (rank, alpha, dropout, learning rate), and the exact setup for the GRPO baseline (group size, clipping ranges, KL penalty). The authors disclose the use of specific base models (Llama-3.3-70B-Instruct) and the tools used (TRL, Unsloth, vLLM). While the specific deployed model's base is not disclosed, the offline experiments are fully reproducible given the open-source base models and detailed hyperparameters. The code for the preference optimization and value model training is implied to be available or standard, though no specific GitHub link is provided in the text, the technical details are sufficient for replication.
The primary limitation is the reliance on a simulated user environment for the majority of the reward-design conclusions. While the simulator is validated, the fidelity of the simulation for out-of-distribution agent behaviors remains a concern, as acknowledged by the authors. The outcome model's AUROC of 0.671 is modest, meaning it can rank strategies but not accurately predict the magnitude of retention changes. The study is conducted in a single domain (mental health support), so generalization to other dialogue tasks is untested. Additionally, the composite weights are hand-chosen, and the authors acknowledge that an automated optimization procedure for these weights would be a valuable next step. The LLM judges used for behavior labeling have varying reliability, with some behaviors showing low inter-rater agreement.
This paper has significant implications for the development of safe and effective conversational AI, particularly in sensitive domains like healthcare. It provides a concrete methodology for moving beyond myopic, turn-level alignment to long-horizon, outcome-oriented alignment. The framework for detecting reward hacking via multi-objective value models and counterfactual simulation is a valuable tool for the broader RLHF community. The finding that offline distillation can match on-policy RL for this task is practically important for reducing the computational cost of alignment. The emphasis on safety and the explicit screening for harmful behaviors (sycophancy, distress) sets a standard for responsible deployment of dialogue agents. The paper presents a robust and empirically validated framework for aligning multi-turn dialogue agents using multi-objective value models and counterfactual simulation to optimize long-term user outcomes while mitigating reward hacking. By demonstrating that dense auxiliary behavioral signals enable effective credit assignment for sparse retention metrics, and that offline preference distillation can match on-policy RL at a fraction of the cost, the work offers a significant methodological advance for the field of RLHF, particularly in safety-critical applications.
Realtime spoken interaction demands deep reasoning, prompt responses, and fluid turn-taking. We present StepAudio 3 Realtime, an audio-language foundation model organized around a continuous listen-converse-think-act loop. Deep Perception captures rich acoustic cues to interpret user intent, while Seamless Duplex models synchronized audio streams to handle pauses, backchannels, and interruptions naturally. Crucially, we resolve the tension between deep deliberation and latency via Think-While-Speaking, executing private reasoning in parallel with spoken delivery. In reasoning mode, StepAudio 3 reaches a 73.0 macro average on StepAudioChat. With Think-While-Speaking, it achieves dialogue and reasoning performance comparable to dedicated reasoning models while speaking in real time. Furthermore, an integrated Voice Agent handles asynchronous tool execution without disrupting the dialogue flow. StepAudio 3 Realtime achieves top-tier performance across key dimensions: an exceptional 90.6 on the MMSU benchmark, 98.9 Overall on the Artificial Analysis Full-Duplex Bench, and a 56.0% macro task-success rate on $τ$-Voice.
Primary: StepFun (Step Star)
All Institutions: StepFun (Step Star)
StepAudio 3 Realtime introduces a "Think-While-Speaking" architecture that enables deep reasoning in parallel with real-time audio generation, achieving top-tier performance on full-duplex and reasoning benchmarks. The paper presents a significant engineering and architectural advance in speech-language modeling, effectively resolving the trade-off between latency and cognitive depth, which is a critical barrier for deploying advanced LLMs in real-time voice applications.
The paper proposes StepAudio 3 Realtime, an audio-language foundation model designed for real-time spoken interaction. The core architectural contribution is the "Think-While-Speaking" mechanism, which decouples the generation of spoken tokens from the internal reasoning process. This allows the model to perform deep deliberation (chain-of-thought or similar) in parallel with the streaming of audio output, thereby mitigating the latency-reasoning trade-off typically found in Large Language Models (LLMs). The system is organized into a continuous listen-converse-think-act loop. Key components include "Deep Perception" for acoustic intent interpretation and "Seamless Duplex" for handling full-duplex audio streams (interruptions, backchannels). The methodology addresses a critical gap in current speech models: the inability to maintain high-level reasoning capabilities while adhering to strict real-time latency constraints. The integration of a Voice Agent for asynchronous tool execution further extends the model's utility beyond simple dialogue.
The evaluation is comprehensive, targeting both reasoning quality and real-time interaction metrics. The model achieves a 73.0 macro average on StepAudioChat (likely an internal or specific benchmark) in reasoning mode. More significantly, it reports an exceptional 90.6 on the MMSU benchmark and 98.9 Overall on the Artificial Analysis Full-Duplex Bench. The 56.0% macro task-success rate on $\tau$-Voice suggests strong agentic capabilities. The claim that it achieves "dialogue and reasoning performance comparable to dedicated reasoning models while speaking in real time" is a strong empirical result, as most real-time models sacrifice reasoning depth for speed. The benchmarks chosen (MMSU, Full-Duplex Bench) are relevant to the specific niche of real-time audio interaction.
As a technical report from a major industry lab (StepFun), the paper likely provides high-level architectural details and training data composition but may lack the granular hyperparameter settings and code releases typical of academic open-source papers. The presence of a project page suggests some transparency, but without explicit code release mentioned in the abstract, full reproducibility by external researchers is likely limited. The benchmarks (StepAudioChat, $\tau$-Voice) may be proprietary or newly introduced, limiting independent verification.
The primary limitation is the potential for "hallucinated" reasoning in real-time contexts; if the model speaks before its reasoning is complete, it may commit to incorrect paths that are hard to retract in a fluid conversation. The 56.0% task-success rate on $\tau$-Voice, while high for voice agents, indicates significant room for improvement in complex multi-step tool use. Additionally, the reliance on specific benchmarks (MMSU, StepAudioChat) requires careful scrutiny to ensure they are not overfit to the model's training distribution. The "Seamless Duplex" mechanism's robustness to noisy environments or overlapping speech from multiple speakers is not detailed in the abstract.
This work has significant implications for the deployment of LLMs in voice-first interfaces (smart speakers, automotive assistants, customer service bots). By solving the latency-reasoning tension, it enables more intelligent and responsive voice agents that can handle complex queries without the user waiting for a "thinking" pause. This could accelerate the adoption of AI in real-time human-computer interaction, moving beyond simple command-and-response systems to conversational partners capable of deep analysis. StepAudio 3 Realtime introduces a "Think-While-Speaking" architecture that enables deep reasoning in parallel with real-time audio generation, achieving top-tier performance on full-duplex and reasoning benchmarks. The paper presents a significant engineering and architectural advance in speech-language modeling, effectively resolving the trade-off between latency and cognitive depth, which is a critical barrier for deploying advanced LLMs in real-time voice applications.
Deep learning now underpins structure-based drug design, from complex and affinity prediction to ligand ranking and pose generation. Recent co-folding models reportedly approach free-energy-perturbation accuracy at far lower cost. Yet standard evaluation, a single held-out correlation or pooled pose-success rate, cannot separate transferable binding principles from repeated exposure to related protein families in public databases, and practical success depends on genuinely novel targets. We introduce MIRAGE (Measuring Interpolation and Redundancy in Affinity GEneralization), a plug-in benchmark treating historical public family support (through 2019) as an explicit variable, applying a family-support axis to affinity and pose prediction via matched strata, family-disjoint controls, ligand-only baselines, and temporal evaluation. Co-folder affinity accuracy rises sharply with family support, while shallow controls that cannot exploit the test family stay flat, large for co-folders and near zero for every family-disjoint or trivial control. For Nesso-1 it survives covariate, conditioning, balancing, and clustering checks; Boltz-2's endpoint is limited by coverage. It localizes to family support rather than ligand chemistry, approaching a level from family identity alone. Rankings reverse on novel families, where a family-disjoint random forest leads both co-folders, significantly vs Nesso-1. On one external low-support target, neither co-folder beats molecular weight, corroborative rather than population-level evidence. gnina shows significant support dependence in rescoring whereas smina does not; MSA-free pose engines show larger gaps than smina redocking. This redundancy-driven inflation differs from conventional leakage. We propose reporting performance across family support plus excess over a support-insensitive baseline, and release MIRAGE as an installable benchmark and dataset.
Primary: University of Central Florida
All Institutions: University of Central Florida, DeepBio Scientific
The paper introduces MIRAGE, a rigorous benchmark that reveals significant redundancy-driven inflation in deep learning models for drug design, demonstrating that co-folding model accuracy is heavily dependent on protein family support rather than transferable binding principles, and proposes a new reporting standard to address this issue.
The paper proposes MIRAGE, a benchmark framework that treats protein family support (number of PDB structures in the same family) as an explicit experimental variable to measure "redundancy-driven inflation" in affinity and pose prediction models. The methodology is rigorous, employing matched strata to control for label spread, family-disjoint controls (RF-QSAR, ligand-kNN) to isolate family recognition from general learning, and temporal evaluation on a novel target. It distinguishes itself from standard leakage checks by focusing on the gradient of performance across family support rather than just train/test overlap. The use of covariate adjustment (controlling for ligand similarity, protein length, etc.) with cluster-robust standard errors is statistically sound.
The experiments are extensive, covering major co-folding models (Nesso-1, Boltz-2, Chai-1) and classical docking/scoring (smina, gnina). The key finding—that co-folder accuracy rises sharply with family support while controls remain flat—is well-supported by the data. The external temporal evaluation on a low-support target provides strong corroborative evidence. The analysis of the "family generalization gap" is compelling, showing that much of the reported accuracy in high-support families is due to memorization of family identity rather than transferable binding physics.
High. The authors release the benchmark, dataset, and code via GitHub. They provide detailed definitions of family support, the specific PDBbind subset used, and the statistical methods (two-level bootstrap, CR1 errors). The paper explicitly states that models are run from public weights at default settings, which enhances reproducibility.
The primary limitation is that family support is a proxy for training exposure, not a direct measure of it, as proprietary training sets are unknown. The external temporal evaluation is limited to a single target (n=1), which the authors acknowledge as corroborative rather than population-level evidence. Boltz-2's coverage was limited by compute resources, leading to wider confidence intervals. The benchmark relies on PDBbind, which may not fully represent the diversity of real-world drug discovery targets.
This paper has significant implications for the field of computational drug design. It challenges the interpretation of high accuracy scores reported for co-folding models, suggesting that they may overestimate performance on novel targets. The proposed reporting protocol (performance across family support + excess over baseline) is a practical and valuable contribution that could become a standard in the field. It encourages more rigorous evaluation practices and highlights the importance of testing on genuinely novel targets. The paper introduces MIRAGE, a rigorous benchmark that reveals significant redundancy-driven inflation in deep learning models for drug design, demonstrating that co-folding model accuracy is heavily dependent on protein family support rather than transferable binding principles, and proposes a new reporting standard to address this issue.
Human videos provide demonstrations of dexterous manipulation but lack robot-executable actions and tactile measurements. We present UniDex-ViTac, a framework that uses human-video-guided simulation to generate robot demonstrations paired with fingertip contact observations for training a deployable visuo-tactile policy. Object-specific residual reinforcement learning specialists adapt annotated human-object interaction references to a robotic arm-hand system. Their successful rollouts pair final robot action targets with robot-side fingertip contact observations. From 50 human demonstrations across ten objects, we collect 10,000 simulated trajectories to train a single Action Chunking with Transformers (ACT) based generalist. The policy combines point clouds, proprioception, and four binary contact signals encoded through fingertip labels and a separate token, without requiring human references or privileged object identity and pose at deployment. The contact-augmented configuration achieves 68.3% macro-average success in simulation, compared with 55.5% for the point-cloud-only baseline. Without real-robot demonstrations or policy fine-tuning, it succeeds in 73/110 physical trials (66.4%) across six seen and five unseen objects, compared with 60/110 (54.5%) for the baseline, an increase of 11.8 percentage points. These results support the feasibility of learning a unified visuo-tactile dexterous manipulation policy from video-guided simulated interactions. Project page: https://unidex-vitac.github.io/
Primary: Korea Advanced Institute of Science and Technology (KAIST)
All Institutions: Korea Advanced Institute of Science and Technology, Korea Institute of Science and Technology (KIST), Kim Jaechul Graduate School of AI
UniDex-ViTac presents a framework for learning visuo-tactile dexterous manipulation policies from human video data by using simulated residual RL to generate robot-specific demonstrations with tactile feedback. The method effectively bridges the embodiment gap and provides a deployable policy that outperforms vision-only baselines in both simulation and real-world trials, though the reliance on binary tactile signals and moderate success rates limit its immediate practical impact.
The paper proposes a coherent pipeline to bridge the gap between human video demonstrations and robot-executable dexterous manipulation. The core method involves using human-object interaction (HOI) references from the DexYCB dataset to guide object-specific residual reinforcement learning (RL) specialists in simulation. These specialists generate robot-specific action trajectories paired with simulated tactile contact signals. These trajectories are then used to train a single generalist policy based on Action Chunking with Transformers (ACT). The novelty lies in the specific integration of a four-bit binary tactile interface (fingertip contact labels) into the point-cloud-based ACT architecture, allowing the policy to learn contact-aware behaviors without requiring privileged state or human references at deployment. The use of residual RL to adapt human motion to robot kinematics is a solid engineering choice, though not entirely new in the field.
The experimental setup is rigorous for a sim-to-real study. The authors train 10 object-specific specialists and pool 10,000 trajectories to train the generalist. Evaluation is conducted in simulation (Isaac Lab) and on a physical Franka Emika Panda arm with a 16-DoF hand. The results show a clear improvement of the contact-augmented policy (68.3% sim, 66.4% real) over the point-cloud-only baseline (55.5% sim, 54.5% real). The inclusion of unseen objects in the real-world evaluation (5 unseen) is a strong point, demonstrating some generalization capability. However, the absolute success rates (around 66-68%) are moderate, and the gap between seen and unseen objects in simulation is not explicitly detailed in the provided text, though real-world unseen performance is reported.
The paper provides significant detail on the simulation environment (Isaac Lab), the RL algorithm (PPO), the network architectures (MLP dimensions, ACT modifications), and the tactile sensing setup (barometric pressure sensors, calibration method). The use of standard datasets (DexYCB) and open-source simulation tools enhances reproducibility. However, the specific code for the residual RL specialists and the tactile sensor calibration scripts are not explicitly linked in the text (only the project page is mentioned), which may pose a barrier for full reproduction without access to the supplementary materials or code repository.
The primary limitation is the sparsity of the tactile interface; using only four binary signals discards rich information such as force magnitude and precise contact location. The paper acknowledges the sim-to-real discrepancy in contact sensing regions. Additionally, the evaluation is limited to a single skill (grasp-and-lift) and a relatively small number of objects (10 training, 11 testing). The success rate, while improved, is not yet at a level that suggests robust deployment in unstructured environments.
This work contributes to the growing field of learning dexterous manipulation from human data. By demonstrating that simulated tactile feedback can be generated from human video references and used to improve real-world policy performance, it offers a scalable alternative to collecting expensive robot teleoperation data with tactile sensors. The approach could be extended to other manipulation tasks and richer tactile representations. UniDex-ViTac presents a framework for learning visuo-tactile dexterous manipulation policies from human video data by using simulated residual RL to generate robot-specific demonstrations with tactile feedback. The method effectively bridges the embodiment gap and provides a deployable policy that outperforms vision-only baselines in both simulation and real-world trials, though the reliance on binary tactile signals and moderate success rates limit its immediate practical impact.
Hybrid dynamical systems provide a powerful modeling framework for robotic systems, particularly in contact-rich environments. However, ensuring safety and performance in such systems remains challenging due to the intricate coupling between continuous dynamics and discrete mode transitions. In this work, we extend classical Hamilton-Jacobi (HJ) reachability analysis, a formal verification method for continuous-time nonlinear systems, to hybrid dynamical systems. Our framework characterizes safe sets for hybrid systems through a generalized value function defined over both discrete and continuous states while accounting for control constraints and model uncertainty. We additionally provide a numerical algorithm to compute this value function. Building on these safe sets, we propose two different mechanisms to integrate performance objectives. First, we introduce a hybrid least-restrictive safety filter that intervenes on both the discrete and continuous components of a nominal controller only when necessary to avoid unsafe states, thereby preserving nominal behavior whenever possible. Second, we formulate and compute hybrid backward reach-avoid tubes, enabling the simultaneous enforcement of safety and goal-reaching behavior, an extension not previously addressed within hybrid HJ reachability. This enables the synthesis of continuous and discrete control policies that guarantee both safety and task completion. We validate our framework through simulation studies and real-world experiments on a quadrupedal robot, demonstrating its effectiveness in hybrid mode planning and safety-critical applications.
Primary: Stanford University
All Institutions: Universidad de Santiago de Chile, University of Southern California, Stanford University
The paper extends Hamilton-Jacobi reachability analysis to hybrid dynamical systems, providing formal safety guarantees and goal-driven control for robots with discrete mode transitions. This is a significant theoretical and practical contribution to robotics, offering rigorous methods for ensuring safety in contact-rich environments while maintaining performance, validated on a quadrupedal robot.
The paper extends Hamilton-Jacobi (HJ) reachability analysis, a rigorous formal verification method for continuous-time nonlinear systems, to hybrid dynamical systems. This is a significant theoretical contribution because HJ analysis is notoriously difficult to scale and apply to systems with discrete mode switches (hybrid systems). The authors define a generalized value function over both discrete and continuous states, accounting for control constraints and model uncertainty. They provide a numerical algorithm to compute this value function. Building on these safe sets, they propose two mechanisms: a hybrid least-restrictive safety filter that intervenes only when necessary, and hybrid backward reach-avoid tubes (BRATs) that enforce both safety and goal-reaching. The methodology is sound, leveraging established control theory principles (HJ reachability, CBFs, MPC) and extending them logically to the hybrid domain. The theoretical grounding is strong, providing formal guarantees rather than heuristic approximations.
The authors validate the framework through simulation studies and real-world experiments on a quadrupedal robot. The use of a quadruped is appropriate for hybrid systems due to the frequent contact-rich mode transitions (e.g., walking, trotting, falling, recovering). The experiments demonstrate effectiveness in hybrid mode planning and safety-critical applications. While the abstract mentions "real-world experiments," the provided text snippet does not detail the specific metrics, baselines, or quantitative results compared to other safety filters (like CBF-QP or standard HJ filters for continuous systems). However, the combination of formal guarantees and physical validation is a strong indicator of rigorous evaluation.
The paper provides a numerical algorithm for computing the value function. The inclusion of a video link to hardware experiments suggests some level of transparency. However, without access to the full code or detailed hyperparameters for the numerical solver (which can be computationally expensive), full reproducibility is difficult to assess from the abstract alone. The theoretical framework is clearly defined, which aids in understanding the approach.
HJ reachability analysis is computationally intensive, often limited to low-dimensional state spaces. Extending this to hybrid systems likely exacerbates the "curse of dimensionality." The paper does not explicitly discuss the computational cost or scalability to high-dimensional robots (e.g., humanoids with many degrees of freedom) in the provided text. Additionally, the reliance on accurate models for hybrid systems can be a limitation in practice, though the mention of "model uncertainty" suggests some robustness is considered.
This work has significant implications for safe robotics, particularly in unstructured environments where contact and mode changes are frequent. By providing formal safety guarantees for hybrid systems, it bridges the gap between theoretical verification and practical robotic control. This could enable more reliable deployment of robots in human-centric environments, autonomous vehicles with complex state transitions, and industrial automation. The integration of performance objectives (least-restrictive filtering, reach-avoid tubes) makes the approach more practical than pure safety verification. The paper extends Hamilton-Jacobi reachability analysis to hybrid dynamical systems, providing formal safety guarantees and goal-driven control for robots with discrete mode transitions. This is a significant theoretical and practical contribution to robotics, offering rigorous methods for ensuring safety in contact-rich environments while maintaining performance, validated on a quadrupedal robot.
A general-purpose robot needs to draw on diverse experience, choose actions, and anticipate how those actions will change the world. We introduce XPACE, a unified embodied world model that serves as both a world action model, jointly predicting executable robot actions and future video, and a world simulator, predicting the visual consequences of prescribed actions. Our key insight is that video prediction can both connect heterogeneous experience to action learning and generate new experience for policy improvement. With a shared video backbone between the policy and simulator, we use action-unlabeled video to learn visual dynamics and action-labeled human and robot demonstrations to jointly learn video and action prediction. Building on this architecture, a coarse-to-fine training curriculum progressively emphasizes robot control while retaining human experience, allowing the policy to learn behaviors beyond those covered by robot demonstrations. Beyond learning from recorded experience, XPACE uses its simulator to create additional recovery supervision for the policy. Specifically, we adapt the simulator to its own generated context, synthesize deviation-recovery trajectories around expert demonstrations, and fine-tune the policy on filtered recovery examples. Experiments on XPENG's IRON humanoid robot show that heterogeneous training improves robustness and enables transfer of human-observed skills to tasks absent from robot demonstrations, while recovery data generated by the model's own simulator further improves real-world task completion. Together, these results demonstrate how joint world and action modeling connects learning from heterogeneous experience with simulation-driven policy self-improvement.
Primary: XPENG
All Institutions: XPENG
XPACE introduces a unified embodied world model that jointly predicts actions and future video, leveraging heterogeneous human and robot experience to improve policy robustness and enable skill transfer. The paper presents a coherent and technically sound approach to addressing data scarcity in robot learning by integrating world modeling with policy learning and self-improvement through synthetic data generation.
The paper proposes XPACE, a unified framework that integrates a world action model (predicting actions and future video) with a world simulator (predicting future video from prescribed actions). The core methodological contribution is the use of a shared video backbone to learn from heterogeneous data: action-unlabeled human video for visual dynamics and action-labeled robot/human demonstrations for joint prediction. A key technical innovation is the "coarse-to-fine" training curriculum that balances robot control with human experience retention. Furthermore, the paper introduces a self-improvement loop where the learned simulator generates synthetic deviation-recovery trajectories, which are then used to fine-tune the policy via DAgger. This approach addresses the data scarcity problem in robot learning by leveraging human video and self-generated simulation data.
Experiments are conducted on XPENG's IRON humanoid robot. The results demonstrate that heterogeneous training improves robustness and enables the transfer of skills observed in human video to tasks not present in the robot's demonstration set. The use of simulator-generated recovery data shows further improvements in real-world task completion. While the results are promising for a specific hardware platform, the evaluation is limited to a single robot model and a specific set of tasks, lacking broader generalization tests across different embodiments or environments.
The paper provides a high-level description of the architecture and training procedure. However, specific details regarding hyperparameters, dataset sizes, and the exact implementation of the "coarse-to-fine" curriculum are likely sparse in the provided text. The reliance on proprietary hardware (XPENG IRON) and potentially proprietary datasets (human bridge data) significantly limits reproducibility for the broader research community.
The primary limitation is the closed nature of the system, relying on specific proprietary hardware and data. The generalizability of the results to other robot platforms or tasks is not extensively tested. Additionally, the computational cost of training a unified world model and generating synthetic data for self-improvement may be high, though this is not explicitly quantified.
This work contributes to the field of embodied AI by demonstrating how heterogeneous experience (human video + robot data) can be effectively leveraged through joint world and action modeling. The concept of using a learned world simulator to generate self-improvement data is a significant step towards autonomous robot learning. It highlights a pathway for reducing the reliance on expensive robot demonstrations by utilizing abundant human video data. XPACE introduces a unified embodied world model that jointly predicts actions and future video, leveraging heterogeneous human and robot experience to improve policy robustness and enable skill transfer. The paper presents a coherent and technically sound approach to addressing data scarcity in robot learning by integrating world modeling with policy learning and self-improvement through synthetic data generation.
Integrating contact information into visuomotor policies remains an open problem. Touch is essential to robust manipulation, yet most modern policies, including pretrained vision-language-action (VLA) models, operate from vision and proprioception alone. Existing approaches to closing this gap require specialized tactile hardware, add separate tactile encoders, or commit to non-image policy backbones, all incompatible with the modern paradigm of image-conditioned policies built on pretrained 2D visual representations. Our key insight is that the bottleneck is not the contact information itself, but how it is delivered: when contact signals are exposed in the same spatial frame as the scene the policy already attends to, they become directly usable by any image-conditioned policy without architectural changes. We operationalize this insight in Visible Touch, paired with a custom low-cost magnetic contact sensor that is open-sourced and fabricated from off-the-shelf parts via a parametric CAD-to-mold pipeline. Across the LIBERO benchmark, Visible Touch improves BC-Transformer success by 15.7 percentage points on average in the 2-view setting, with similar gains in the 1-view setting; controlled comparisons show that the contact-integration strategy strongly affects how effectively tactile information is used. The pattern holds when fine-tuning pretrained VLAs: miniVLA on LIBERO gains 25 percentage points on average, and $π_{0.5}$ on four real-world contact-rich tasks gains 30 percentage points with our custom sensor.
Primary: University of California, Los Angeles
All Institutions: University of California, Los Angeles
The paper introduces a visual overlay method for integrating tactile contact information into image-conditioned visuomotor policies, demonstrating significant performance gains on both simulation and real-world manipulation benchmarks. This approach effectively decouples the tactile sensing hardware from the policy architecture, allowing standard vision-based models to leverage contact data without modification, which is a practical and impactful contribution to the field of robotic manipulation.
The paper proposes "Visible Touch," a method that renders contact information as visual overlays in the same spatial frame as the scene. This approach allows standard image-conditioned policies (like BC-Transformer and VLA models) to utilize tactile data without architectural modifications. The method is paired with a custom, low-cost magnetic contact sensor that is open-sourced and fabricated via a parametric CAD-to-mold pipeline. The core insight is that the bottleneck for integrating touch is not the information content but the delivery mechanism; aligning the signal with the visual attention space makes it directly usable by existing vision-based backbones.
The authors evaluate the method on the LIBERO benchmark, reporting a 15.7 percentage point improvement for BC-Transformer in the 2-view setting. They also demonstrate gains when fine-tuning pretrained VLAs, specifically miniVLA (25 pp gain on LIBERO) and $\pi_{0.5}$ (30 pp gain on four real-world contact-rich tasks). Controlled comparisons highlight that the contact-integration strategy significantly impacts the effectiveness of tactile information usage. The results are strong, showing consistent improvements across both simulation and real-world settings.
The paper claims high reproducibility by open-sourcing the custom magnetic contact sensor and providing a parametric CAD-to-mold pipeline for fabrication from off-the-shelf parts. The project website is provided. However, the full paper text provided in the prompt is largely a stub with section headers, so specific implementation details of the rendering algorithm and policy training are not visible in the provided text, though the abstract implies a clear methodology.
The provided text is incomplete, containing only the abstract and section headers, which limits a deep critique of the specific rendering algorithms or failure cases. The reliance on a custom sensor, even if low-cost, may limit immediate adoption by groups without fabrication capabilities. The generalization to other types of tactile sensors or non-magnetic contact scenarios is not discussed in the available text.
This work bridges the gap between tactile sensing and the dominant paradigm of vision-language-action models. By providing a drop-in solution for integrating touch into existing image-based policies, it lowers the barrier to entry for robust manipulation research. The open-sourcing of the hardware is a significant contribution to the community, enabling broader experimentation with contact-rich manipulation tasks. The paper introduces a visual overlay method for integrating tactile contact information into image-conditioned visuomotor policies, demonstrating significant performance gains on both simulation and real-world manipulation benchmarks. This approach effectively decouples the tactile sensing hardware from the policy architecture, allowing standard vision-based models to leverage contact data without modification, which is a practical and impactful contribution to the field of robotic manipulation.
Training a Mixture-of-Experts (MoE) model at long context or large batch size fails as soon as any one component's peak allocation exceeds device memory, so the target is every peak at once, not the average footprint. Four are left unbounded by the parallelism plans in common use, and each grows differently: expert dispatch with the routing matrix, the vocabulary projection with tokens times vocabulary, gradient checkpoint boundaries with depth times sequence length, and optimizer state with parameter count. Which one runs out first changes with the model, the context length, and the device count, so lowering the largest only exposes the next. We bound all four with schedules whose GPU working set is fixed at launch: PipelinedLLEP extends least-loaded expert parallelism with a cap on the tokens each source contributes to a dispatch chunk, Ring-DTP circulates activations or weight shards around a ring at the vocabulary projection and folds each block of logits into an online log-sum-exp, Selective checkpoint offload (SCO) keeps the one long-lived tensor of each checkpoint boundary in CPU memory, and OffloadStreamAdamW turns the serial CPU Adam update of optimizer offload into a bucket pipeline. All four change only the order and granularity of computation and data movement, so the loss and gradients stay exact. In matched component tests, they cut the MoE dispatch peak by up to $59.3\%$ without losing throughput, the vocabulary projection peak by $86.6\%$, and the offloaded optimizer step by $2.05\times$ faster. Composed on MoE models from 120B to 667B parameters, they train at 1M context length, $8$--$32\times$ the reach of a tuned FSDP2 baseline, and up to $10.4\times$ its throughput.
Primary: Unknown
All Institutions: Unknown
The paper presents a comprehensive systems-level solution to the memory peak problem in long-context MoE training by introducing four orthogonal scheduling and offloading techniques that collectively enable training of 667B parameter models at 1M context length with significant throughput improvements over standard FSDP2 baselines.
The paper addresses a critical bottleneck in training large-scale Mixture-of-Experts (MoE) models: memory fragmentation and peak allocation spikes that cause out-of-memory (OOM) errors even when average memory usage is within limits. The authors propose a unified framework of four orthogonal techniques: PipelinedLLEP (for expert dispatch), Ring-DTP (for vocabulary projection), Selective Checkpoint Offload (SCO), and OffloadStreamAdamW (for optimizer state). The methodology is sound, focusing on scheduling and data movement rather than altering the mathematical computation graph, which ensures exact loss and gradient preservation. The insight that "lowering the largest peak exposes the next" is a strong systems-level observation that justifies a multi-pronged approach. The techniques are well-motivated by the specific growth patterns of different tensor types (routing matrix, logits, activations, optimizer states).
The experimental section claims significant improvements, including training MoE models up to 667B parameters at 1M context length, which is a substantial scale. The reported metrics (59.3% reduction in dispatch peak, 86.6% reduction in projection peak, 2.05x faster optimizer step) are specific and compelling. The comparison against a "tuned FSDP2 baseline" is appropriate for this domain. However, the provided text is truncated and lacks detailed ablation studies, hardware specifications (GPU model, interconnect bandwidth), and throughput breakdowns (MFU/HFU) that would allow for a rigorous verification of the "10.4x throughput" claim. The scale of the experiments (120B-667B) suggests high-quality infrastructure, but the lack of detailed tables in the provided text limits full verification.
The paper claims that the methods change only the order and granularity of computation, implying high reproducibility in terms of correctness. However, without access to the code (no URL provided) and with the text truncated, it is difficult to assess the ease of implementation. The reliance on specific hardware characteristics (CPU-GPU bandwidth, ring topology) may limit portability to non-standard clusters. The use of LLMs for drafting is disclosed, which is transparent, but does not impact technical reproducibility.
The primary limitation is the lack of visible code or detailed implementation artifacts in the provided text. The techniques are highly specialized for MoE architectures and may not generalize directly to dense models or other parallelism strategies. The performance gains are likely dependent on high-bandwidth CPU-GPU interconnects (e.g., NVLink-C2C or similar), which are not universally available. The "10.4x throughput" claim is extreme and requires careful scrutiny of the baseline configuration to ensure it is not an artifact of a poorly tuned baseline.
This work has high potential impact on the field of large-scale model training. As MoE models become the standard for efficiency at scale, solving the memory peak problem is essential for training longer contexts and larger batches. The techniques proposed could become standard components in distributed training frameworks like PyTorch FSDP or DeepSpeed. The ability to train at 1M context length opens up new applications in long-document understanding and reasoning. The paper presents a comprehensive systems-level solution to the memory peak problem in long-context MoE training by introducing four orthogonal scheduling and offloading techniques that collectively enable training of 667B parameter models at 1M context length with significant throughput improvements over standard FSDP2 baselines.
Communication has become a bottleneck in distributed training and inference of large models. Overlapping communication with computation at the granularity of kernels, on separate streams, reduces only part of this communication cost. Fused kernels often have better performance by transmitting each output tile as soon as it is produced, but existing fused kernels are largely confined to a single NVLink domain. We present mKernel, a library of multi-GPU, multi-node fused kernels that overlap computation, intra-node NVLink communication, and inter-node RDMA at tile granularity. mKernel partitions the streaming multiprocessors (SMs) of a persistent kernel into compute and communication roles, and an on-GPU controller tunes the SM partition adaptively at run time, since the best SM partition varies with the kernel and the input shape. It structures data movement hierarchically so that data traversing the inter-node network is minimized. Finally, it drives the network from the GPU through a lightweight command queue and host proxy implemented directly on RDMA verbs, which allows the same kernels to run on any network backend (e.g. InfiniBand and on AWS EFA); we observe, surprisingly, that GPUDirect Async (IBGDA) yields little additional benefit over host-assisted GPU-initiated communication. We implement five kernels spanning tensor, sequence, and expert parallelism. On two 16-GPU H200 clusters, mKernel achieves speedups of up to 1.72x on GEMM+AllReduce and $1.88\times$ on Ring Attention.
Primary: University of California, Berkeley
All Institutions: University of California, Berkeley, University of Washington, Meta
mKernel introduces a novel approach to multi-GPU, multi-node fused kernels by adaptively partitioning SMs for compute and communication, achieving significant speedups in distributed training and inference. The paper provides a rigorous system-level solution to the communication bottleneck, with strong empirical results on high-end hardware and valuable insights into the efficacy of different GPU-initiated communication strategies.
The paper proposes mKernel, a library of fused kernels that operate across multiple GPUs and nodes. The core innovation lies in the partitioning of Streaming Multiprocessors (SMs) within a persistent kernel into distinct compute and communication roles. Unlike previous approaches that rely on separate CUDA streams for overlapping, mKernel uses an on-GPU controller to adaptively tune the SM partition at runtime based on input shapes and kernel characteristics. The system structures data movement hierarchically to minimize inter-node traffic and utilizes a lightweight command queue with a host proxy on RDMA verbs to drive the network directly from the GPU. This design allows the same kernels to run on diverse network backends (InfiniBand, AWS EFA) without relying heavily on GPUDirect Async (IBGDA), which the authors note yields little benefit over their host-assisted approach.
The evaluation is conducted on two 16-GPU H200 clusters, which is a high-end and relevant hardware setup for current large-scale training. The paper implements five kernels spanning tensor, sequence, and expert parallelism. The results show significant speedups, up to 1.72x for GEMM+AllReduce and 1.88x for Ring Attention. The comparison against state-of-the-art baselines (likely including standard NCCL-based overlaps and existing fused kernels) demonstrates clear performance gains. The finding that IBGDA provides marginal benefit over their host-assisted method is a notable empirical contribution that challenges common assumptions in high-performance computing for ML.
The paper describes the system architecture and implementation details sufficiently for experts to understand the mechanism. However, as an arXiv preprint, the code availability is not explicitly confirmed in the provided text (no GitHub link found in the extracted data). The reliance on specific hardware (H200) and network configurations (RDMA verbs) may limit immediate reproducibility for users without access to such clusters, but the design principles are generalizable.
The system is highly specialized for high-end GPU clusters with RDMA capabilities, limiting its applicability to consumer or mid-range hardware. The adaptive SM partitioning adds complexity to the kernel launch and management overhead, which might not be beneficial for smaller models or shorter sequences where communication overhead is negligible. The evaluation is limited to specific kernel types (GEMM, Attention, MoE), and the generalization to other collective operations or irregular communication patterns is not fully explored.
This work addresses a critical bottleneck in scaling large language models, potentially reducing training times and energy consumption for data centers. By enabling efficient multi-node fused kernels, it can lower the barrier to training larger models on existing hardware. The insights into GPU-initiated communication and SM partitioning may influence future hardware design and system software development in the AI infrastructure space. mKernel introduces a novel approach to multi-GPU, multi-node fused kernels by adaptively partitioning SMs for compute and communication, achieving significant speedups in distributed training and inference. The paper provides a rigorous system-level solution to the communication bottleneck, with strong empirical results on high-end hardware and valuable insights into the efficacy of different GPU-initiated communication strategies.
Auto-regressive model decode is bandwidth-bound, since every weight and key/value-cache byte crosses high-bandwidth memory once per token. A megakernel is an ideal solution, but existing automatic megakernel generation approaches cannot achieve both generalization across models and correctness guarantees. We present ForgeMegakernel, which generates a per-model high-performance decode megakernel using coding agents. ForgeMegakernel pairs a universal knowledge base of ten progressive milestones with an independent mid-state test oracle. The milestones provide the megakernel's structural properties: a fine-grained instruction stream for each SM, dependency counters replacing the global synchronization, and a shared-memory buffer pool for workload balance across SMs and greater parallelism. The test oracle derives the mid-states of the megakernel and checks the performance, error and precision during the generation process, guaranteeing a correct and trustworthy forged megakernel. We evaluated ForgeMegakernel on 14 representative decoding operations across eight model families spanning 0.6B-13B parameters. The generated megakernels achieved 50.5-85.9% MBU and geometric mean speedups of 1.21x over SGLang 0.5.18 and 1.54x over a megakernel compiler under identical configurations. Inside SGLang, evaluated on GSM8K with ragged prompts, all 14 megakernels decoded faster than the SGLang engine at comparable answer accuracy.
Primary: Tsinghua University
All Institutions: Tsinghua University, ModelBest Inc, University of Chinese Academy of Sciences
ForgeMegakernel introduces a robust framework using LLM agents and a test oracle to generate high-performance decode megakernels, achieving significant speedups over existing engines. The paper demonstrates a novel intersection of LLMs and systems optimization, offering a promising path toward automated kernel generation, though reproducibility is hindered by the lack of open-source tools and detailed agent specifications.
The paper proposes ForgeMegakernel, a framework that leverages LLM coding agents to generate highly optimized GPU megakernels for auto-regressive model decoding. The core innovation lies in the "universal knowledge base" of ten progressive milestones that guide the agent through structural properties like fine-grained instruction streams, dependency counters, and shared-memory buffer pools. Crucially, it introduces an independent mid-state test oracle to verify correctness and performance during generation, addressing the reliability issues of pure LLM code generation. This is a sophisticated application of LLMs to systems programming, moving beyond simple code completion to complex, constraint-satisfying kernel synthesis.
The evaluation is extensive, covering 14 decoding operations across 8 model families (0.6B-13B parameters). The reported results are strong: 50.5-85.9% Memory Bandwidth Utilization (MBU) and significant speedups (1.21x over SGLang, 1.54x over a megakernel compiler). The integration into SGLang and testing on GSM8K with ragged prompts provides practical relevance. However, the lack of open-source code or detailed hardware specifications (e.g., specific GPU architecture, memory hierarchy details) slightly limits the depth of verification possible for external readers.
Reproducibility is a concern. While the methodology is described, the "coding agents" and "knowledge base" are proprietary or not fully detailed in the text provided. Without access to the specific prompts, agent configurations, and the oracle implementation, independent reproduction is difficult. The paper relies on the authors' specific setup, which may not be easily replicated by other labs without the full toolkit.
The primary limitation is the dependency on the specific LLM agents and the closed nature of the generation pipeline. Additionally, the evaluation is limited to decoding; the impact on prefill or other phases is not discussed. The generalization to future GPU architectures or different memory hierarchies is not explored. The "mid-state test oracle" is a black box in the description, making it hard to assess its overhead or failure modes.
This work has significant potential to automate the optimization of critical inference bottlenecks. If the framework generalizes well, it could reduce the manual effort required to tune kernels for new models or hardware, potentially lowering inference costs. It represents a shift towards AI-assisted systems engineering, which is a growing trend. However, the impact is currently limited to the specific domain of auto-regressive decoding and requires trust in the LLM-generated code. ForgeMegakernel introduces a robust framework using LLM agents and a test oracle to generate high-performance decode megakernels, achieving significant speedups over existing engines. The paper demonstrates a novel intersection of LLMs and systems optimization, offering a promising path toward automated kernel generation, though reproducibility is hindered by the lack of open-source tools and detailed agent specifications.
Determinism and numerical reproducibility are increasingly required of GPU kernels in machine learning systems, yet deterministic implementations of the same kernel can still differ bit for bit. Floating-point reduction order is the primary cause, alongside partial-sum precision, fused multiply-add operations, and rounding placement. These choices may be hand-coded, selected by a block-level language such as Triton, or hidden inside a closed-source library such as cuBLAS or rocBLAS. A tile shape chosen for performance therefore also determines the arithmetic, potentially breaking batch invariance. Preserving a fixed order can cost up to 20 percent, while an autotuner cannot identify which configurations are bitwise equivalent. We characterize the factors determining the bitwise behavior of reductions and general matrix multiplication (GEMM). First, we introduce a descriptor of GEMM reduction order, including the partitioning of K in split-K GEMM. Using it, we perform the first black-box reconstruction of a closed-source library's arithmetic for bit-level correctness. Our family of Triton GEMMs matches NVIDIA cuBLAS in all tested cases on Blackwell and Hopper. For realistic LLM shapes with fused epilogues, it matches or exceeds torch.compile performance. Second, we enforce balanced-tree reduction during Triton lowering and introduce a data-layout optimization that brings 19 of 27 kernels on GB300 and H100 within 10 percent of free-order performance. Third, we develop sound static checkers for bitwise equivalence between compiled GPU kernels, including the first checker spanning NVIDIA PTX and AMD GCN. Integrated into Triton's autotuner, the checker restricts search to a single bit-equivalence class.
Primary: Georgia Institute of Technology
All Institutions: Georgia Institute of Technology, Meta
The paper presents a comprehensive framework for achieving bitwise reproducibility in GPU kernels through black-box reconstruction, compiler enforcement, and static verification. It makes significant contributions to the field of ML systems by providing practical tools and theoretical insights to ensure numerical determinism, which is increasingly critical for reliable machine learning deployments.
The paper introduces a rigorous theoretical framework for characterizing bitwise behavior in GPU kernels, specifically focusing on GEMM and reductions. The core contribution is the "GEMMDesc" descriptor, which formally captures the parameters determining floating-point reduction order (e.g., split-K cuts, instruction-level accumulation semantics). The methodology for black-box reconstruction of closed-source libraries (cuBLAS) is particularly innovative, using numerical inference with specific extreme values to reverse-engineer the internal arithmetic structure without access to source code. The implementation of a sound static equivalence checker for PTX and AMDGCN assembly is a significant technical achievement, providing a formal guarantee that two compiled kernels are bitwise equivalent, which is rare in compiler research.
The evaluation is extensive and rigorous. The authors demonstrate 100% bitwise match with cuBLAS across 110,813 random shapes on multiple GPU architectures (GB300, GB200, H100). The performance analysis is nuanced, showing that while enforcing bitwise determinism typically costs performance, their layout optimizations recover most of this cost, and in some fused kernel scenarios, the bit-exact implementation actually outperforms the baseline due to reduced launch overhead. The soundness of the static checker is validated on over 51,000 configurations, showing high precision in partitioning equivalent kernels.
The paper provides detailed descriptions of the compiler modifications and the static checker algorithm. However, as it is an arXiv preprint, the code availability is not explicitly confirmed in the text provided. The reliance on specific hardware (GB300, H100) and closed-source libraries (cuBLAS) may limit immediate reproducibility for all readers, but the methodology is clearly described.
The work is heavily focused on GEMM and standard reductions; complex kernels like Flash Attention are only theoretically analyzed. The black-box reconstruction is specific to cuBLAS versions tested and may not generalize to other libraries or future hardware without re-derivation. The static checker, while sound, has a performance overhead and may not scale to arbitrarily complex control flows without further optimization.
This work has high potential impact on the ML systems community, particularly for teams requiring strict reproducibility in training and inference. It provides tools to enforce determinism without significant performance loss, addressing a critical pain point in distributed training and RLHF pipelines. The static equivalence checker could become a standard tool in compiler verification suites. The paper presents a comprehensive framework for achieving bitwise reproducibility in GPU kernels through black-box reconstruction, compiler enforcement, and static verification. It makes significant contributions to the field of ML systems by providing practical tools and theoretical insights to ensure numerical determinism, which is increasingly critical for reliable machine learning deployments.