Last 7 Days (October 14 – October 20, 2026)
Significant efforts are currently being directed toward the implementation of large-scale quantum information processors, but realizing useful quantum advantage also requires the development of efficient quantum algorithms. While for many practical problems the dominant resource costs are associated with a small set of computational primitives, optimizing them in the quantum setting presents unique challenges, including a reversibility constraint absent from ordinary classical computation. Here we introduce an evolutionary framework in which large language models (LLMs) propose circuit designs and an independent evaluator verifies and scores them. We apply this framework to tasks spanning numerical computation, chemistry, optimization, quantum simulation, and number theory. In seven of the eight tasks, the discovered circuits significantly reduce both Toffoli and qubit counts relative to the state of the art. In the eighth, the search discovers a new reversible architecture for prime-field modular inversion. By handling reversibility differently, the architecture makes divsteps -- a classical algorithm previously impractical for reversible integer arithmetic -- viable and substantially improves the Toffoli-qubit trade-off for modular inversion. These results open the door for evaluator-guided LLM co-design of new algorithmic structures for quantum computation.
Primary: Harvard University
All Institutions: Harvard University, Anthropic, QuEra Computing
The paper presents a novel evolutionary framework using LLMs to discover state-of-the-art quantum circuits, achieving significant reductions in resource costs across multiple tasks and uncovering new reversible algorithms. This work bridges the gap between AI-driven code generation and rigorous quantum algorithm design, offering a powerful tool for future quantum computing research.
The paper introduces a robust evolutionary framework where Large Language Models (LLMs) propose high-level Python circuit designs, which are then verified by an independent, programmatic evaluator. This approach effectively addresses the "reversibility constraint" of quantum computation by allowing the LLM to reason about algorithmic structure rather than just gate sequences. The methodology is sound, leveraging the fact that coherent circuits on computational basis states can be simulated efficiently (tracking bits and phases), enabling rapid feedback loops. The use of MAP-Elites to maintain diversity in the search space is a strong technical choice that prevents premature convergence to local optima.
The experimental results are highly impressive, demonstrating state-of-the-art improvements in Toffoli and qubit counts across eight diverse tasks, including Reed-Solomon decoding and modular inversion. The discovery of a new reversible architecture for prime-field modular inversion using divsteps is a significant algorithmic contribution, not just an optimization of existing circuits. The benchmarks are rigorous, comparing against established baselines and providing detailed resource accounting.
The paper provides sufficient detail on the circuit model, cost metrics, and search strategy to allow for reproduction of the framework. However, the specific LLM prompts and the exact "OpenEvolve" implementation details are not fully open-sourced in the text, which may limit immediate reproducibility for those without access to the specific tooling or LLM versions (Claude Mythos 5).
The framework is bounded by the task specification and the computational basis representation, excluding optimizations that rely on changing the encoding itself (e.g., coset representations). The reliance on a specific LLM (Claude Mythos 5) and the proprietary "OpenEvolve" framework may limit accessibility. Additionally, the TQ-cost metric is a simplification that may not capture all hardware-specific constraints like depth or routing.
This work has significant implications for the field of quantum computing, offering a scalable path to discovering efficient quantum algorithms. It demonstrates that LLMs can contribute to fundamental algorithmic design in domains with complex constraints, potentially accelerating the development of fault-tolerant quantum computers. The approach could be extended to other areas of AI for Science where programmatic evaluation is feasible. The paper presents a novel evolutionary framework using LLMs to discover state-of-the-art quantum circuits, achieving significant reductions in resource costs across multiple tasks and uncovering new reversible algorithms. This work bridges the gap between AI-driven code generation and rigorous quantum algorithm design, offering a powerful tool for future quantum computing research.
Differentially private learning aims to learn from data while protecting individual training examples. For binary classification, finite Littlestone dimension characterizes approximate private PAC learnability (Alon et al., JACM 2022). Understanding how this dimension controls private sample complexity remains a central question. For classes of Littlestone dimension $d$, the first general upper bound was doubly exponential in $d$ (Bun, Livni, and Moran, FOCS 2020). Subsequent work improved this to $\widetilde O(d^6)$ (Ghazi et al., STOC 2021) and then to $\widetilde O(d^5)$ (Lyu, STOC 2026). We prove a nearly linear upper bound of $O(d\log d)$. Our main algorithmic contribution is a structural exponential mechanism for data-dependent candidate sets equipped with a rank satisfying suitable stability conditions. For natural Littlestone classes such as subspace indicators, this rank has a simple geometric interpretation: it is the codimension. This yields a private PAC learner for subspaces of dimension at most $d$ over any field, with tight linear dependence on $d$ and no dependence on the ambient dimension, improving the quadratic dependence of Kaplan et al. (STOC 2025). Our second contribution is combinatorial: drawing on model-theoretic ideas, we construct a suitable rank for general Littlestone classes and establish the counting bounds required by the mechanism.
Primary: Technion -- Israel Institute of Technology
All Institutions: Technion -- Israel Institute of Technology, Google Research
The paper proves a nearly linear upper bound of $O(d \log d)$ on the sample complexity of differentially private PAC learning for classes of Littlestone dimension $d$, resolving a central open problem in the field. By introducing a structural exponential mechanism that leverages a model-theoretic rank, the authors achieve a tight dependence on the Littlestone dimension, significantly improving upon previous polynomial bounds and providing a new algorithmic framework for private learning.
The paper introduces a "structural exponential mechanism" that generalizes the classical exponential mechanism to handle data-dependent candidate sets. This is a significant algorithmic innovation in private learning theory. The core novelty lies in defining a combinatorial rank for hypotheses in Littlestone classes, derived from model-theoretic concepts (specifically Shelah's $2$-rank), and proving that this rank satisfies stability conditions necessary for differential privacy. The authors demonstrate that for subspace indicators, this rank corresponds to codimension, yielding a tight linear sample complexity bound $O(d \log d)$, which is optimal up to logarithmic factors. The methodology is rigorous, combining combinatorial arguments with privacy analysis.
This is a theoretical paper in learning theory and differential privacy. There are no empirical experiments, datasets, or benchmarks. The "evaluation" consists of mathematical proofs establishing upper bounds on sample complexity and verifying the privacy guarantees of the proposed mechanism. The contribution is entirely analytical.
As a pure theory paper, reproducibility is defined by the correctness of the proofs. The paper provides detailed technical overviews and formal definitions. However, the full proofs are truncated in the provided text (ending in Section 5.1), so a complete verification of the combinatorial lemmas (specifically Lemmas 5.2-5.4 and the counting bounds in Section 5.3) is not possible from the snippet alone. Assuming the standard rigor of the authors (Moran, Yan) and the venue (likely STOC/FOCS level), the theoretical framework is sound.
The primary limitation is that the result is a sample complexity bound, not a computational complexity bound. The paper explicitly states that it does not assert computational efficiency. The algorithm described (selecting candidates based on version spaces and ranks) may be computationally intractable for large $d$ or complex classes. Additionally, the bound is for the realizable setting; while reductions to the agnostic setting exist, they incur additional overhead. The log-star question regarding VC vs Littlestone dimension remains open.
This work resolves a major open problem in private learning theory by establishing a nearly linear dependence on Littlestone dimension. It provides a new algorithmic primitive (structural exponential mechanism) that can be applied to other private optimization problems involving data-dependent candidate sets. It bridges learning theory and model theory, offering new combinatorial tools for understanding the complexity of private learning. The result is significant for the theoretical understanding of the trade-offs between privacy and sample efficiency. The paper proves a nearly linear upper bound of $O(d \log d)$ on the sample complexity of differentially private PAC learning for classes of Littlestone dimension $d$, resolving a central open problem in the field. By introducing a structural exponential mechanism that leverages a model-theoretic rank, the authors achieve a tight dependence on the Littlestone dimension, significantly improving upon previous polynomial bounds and providing a new algorithmic framework for private learning.
We study uniform approximation of the Hölder ball $\mathcal H_1^s([0,1]^D)$ by fully connected ReLU networks. Except in the one-dimensional Lipschitz case, existing constructions remain separated from the information-theoretic efficiency limit. This article closes the gap for every $s>0$ and $D\ge1$: networks with width $O(N)$, depth $O(L)$, and parameter magnitude $O(1)$ attain uniform approximation error of order $(N^2L^2\log N)^{-s/D}$. No relation between width and depth is required. The construction uses new encoding and decoding mechanisms that exploit higher-order finite-difference bounds for local Taylor coefficients of the target function. As a statistical consequence, empirical risk minimizers over the corresponding clipped network classes attain the minimax regression rate $n^{-2s/(2s+D)}$ without additional logarithmic factors. The paper also gives a detailed exposition of the key approximation techniques, covering both established and new mechanisms.
Primary: Munich Center for Machine Learning (MCML)
All Institutions: Munich Center for Machine Learning (MCML), Department of Statistics
The paper closes the gap between existing ReLU network approximation constructions and the information-theoretic efficiency limit for Hölder smooth functions, establishing optimal rates for width, depth, and parameter magnitude. This is a significant theoretical contribution that resolves a major open problem in neural network approximation theory, providing a complete characterization of the capacity of ReLU networks for smooth function approximation.
The paper presents a rigorous theoretical framework for the uniform approximation of Hölder smooth functions by ReLU neural networks. The core innovation is a "higher-order point-fitting" mechanism that exploits the regularity of local Taylor coefficients to compress their storage within the network weights. By using higher-order finite differences and a segmented discrete Taylor-Newton recursion, the authors achieve an approximation error of $(N^2L^2\log N)^{-s/D}$ with bounded parameter magnitudes ($O(1)$). This closes the gap between existing constructions and the information-theoretic efficiency limit for all smoothness orders $s>0$ and dimensions $D\ge1$. The methodology is highly sophisticated, combining established techniques like bit-extraction and median smoothing with novel encoding strategies that preserve smoothness during the flattening of multivariate coefficient grids via Hermite interpolation bridges.
As a pure theory paper, there are no empirical experiments, datasets, or benchmark comparisons. The "evaluation" consists of mathematical proofs establishing upper bounds on approximation error and matching lower bounds via metric entropy arguments. The statistical consequence (minimax regression rates) is derived theoretically.
The paper is highly reproducible in the mathematical sense. It provides self-contained proofs for all key components, including simplified versions of standard techniques. The construction is explicit, and the bounds are tight. However, without code, practical implementation of these specific network architectures for real-world data is not directly demonstrated.
The results are limited to uniform approximation on the unit cube $[0,1]^D$ for Hölder classes. The lower bound relies on metric entropy, which may not capture all aspects of practical learning dynamics. The paper does not address the optimization landscape or the trainability of these networks, which is a significant gap between theoretical optimality and practical deep learning.
This work provides a definitive answer to a long-standing question in neural network approximation theory. It establishes that ReLU networks are optimal approximators for smooth functions in terms of width, depth, and parameter magnitude. This has implications for understanding the capacity of neural networks and the theoretical limits of nonparametric regression. It may influence future theoretical work on network architectures and the design of approximation schemes for other function classes. The paper closes the gap between existing ReLU network approximation constructions and the information-theoretic efficiency limit for Hölder smooth functions, establishing optimal rates for width, depth, and parameter magnitude. This is a significant theoretical contribution that resolves a major open problem in neural network approximation theory, providing a complete characterization of the capacity of ReLU networks for smooth function approximation.
Software engineering (SWE) benchmarks are the primary way to measure the capabilities of coding agents: an agent is placed in a code repository or machine environment, given a request, and judged by hidden tests. These benchmarks almost always start the agent from a clean state that contains no earlier work on the task. In practice, however, agents often continue work that a developer or another agent has already done and reported as complete, with no indication of what remains incorrect or missing. We introduce SWE-Residual, a benchmark for Starting-State Robustness: the ability to maintain performance on a task when the starting state already contains earlier work on that task. SWE-Residual contains 198 Residual States drawn from 111 tasks in DeepSWE and Terminal-Bench, where the earlier work modifies a code repository or a whole machine environment. Each Residual State is the state a predecessor agent left behind after submitting its work as complete, although the hidden tests still fail. The evaluated agent receives only the original request and this state, without the predecessor's trajectory or any sign that the attempt failed; because the request and hidden tests are unchanged, the starting state is the only difference from the source benchmark. Across five frontier agents, success drops by 20.6--53.5 percentage points on DeepSWE and 20.6--34.9 points on Terminal-Bench relative to a Clean Start, and agent rankings on DeepSWE reverse. Failed continuations show a pattern we call acceptance bias: agents treat the inherited work as the definition of what remains to be done instead of checking it against the request. On DeepSWE, in 58.9--88.2% of failed runs, they submit with exactly the same tests failing, although they pass most of these tests from a Clean Start. SWE-Residual thus exposes a capability gap that clean-start evaluation does not capture.
Primary: The University of British Columbia
All Institutions: The University of British Columbia, University of North Texas
The paper introduces SWE-Residual, a benchmark for evaluating the "Starting-State Robustness" of coding agents, revealing a significant "acceptance bias" where agents fail to correct or complete work inherited from a predecessor agent that incorrectly claimed success. By constructing 198 validated residual states from DeepSWE and Terminal-Bench and demonstrating that frontier agents suffer substantial performance drops (up to 53.5 points) and ranking reversals compared to clean starts, the work provides a rigorous and necessary new dimension for evaluating agent capabilities in realistic, iterative software engineering scenarios.
The paper introduces a well-defined evaluation setting, "Starting-State Robustness," which measures an agent's ability to continue a task from a state left by a predecessor agent that claimed completion but failed hidden tests. The methodology is rigorous, employing a four-stage "Residualization" pipeline: trajectory generation by open-weight models, automatic filtering for valid failures, human review for task-directedness, and state reconstruction (using patches for code repos and CRIU checkpoints for machine environments). The formalization of the problem is clear, distinguishing between clean starts and residual starts while keeping the verifier constant. The identification of "acceptance bias" as a specific failure mode provides a strong theoretical hook for the empirical findings.
The experiments are extensive, covering 198 residual states from 111 tasks across two major benchmarks (DeepSWE and Terminal-Bench). The evaluation includes five frontier agents, showing a significant performance drop (20-53 points) compared to clean starts. A particularly strong finding is the reversal of agent rankings, demonstrating that clean-start scores are not predictive of robustness to inherited work. The analysis of acceptance bias is detailed, showing that agents often fail to modify files left out by the predecessor or repair failing tests, even when they could do so from a clean start. The use of multiple predecessor agents (DeepSeek, Qwen, GLM) ensures the results are not specific to one model's failure modes.
The paper commits to releasing all residual states, reconstruction artifacts, and evaluation code. The detailed description of the state reconstruction process (e.g., applying patches without commits, replaying terminal interactions) and the validation steps (ensuring verifiers still fail on reconstructed states) supports high reproducibility. The use of standard harnesses (mini-swe-agent, Terminus-2) further aids reproducibility.
The benchmark size is moderate (198 states), which may limit statistical power for fine-grained comparisons. The analysis of acceptance bias is limited to DeepSWE due to the availability of per-test outcomes and patches; Terminal-Bench lacks this granularity. The predecessor agents are open-weight models, which may not fully represent the diversity of failure modes from proprietary or human developers. The paper acknowledges that extending to human-produced work would be valuable.
This paper addresses a critical gap in the evaluation of coding agents, which are increasingly used in multi-agent systems and iterative development workflows. The finding that agents struggle to continue work from a "failed but submitted" state has immediate practical implications for the design of agent systems, suggesting the need for better handoff protocols or self-correction mechanisms. The benchmark will likely become a standard tool for evaluating agent robustness, complementing existing clean-start benchmarks. The paper introduces SWE-Residual, a benchmark for evaluating the "Starting-State Robustness" of coding agents, revealing a significant "acceptance bias" where agents fail to correct or complete work inherited from a predecessor agent that incorrectly claimed success. By constructing 198 validated residual states from DeepSWE and Terminal-Bench and demonstrating that frontier agents suffer substantial performance drops (up to 53.5 points) and ranking reversals compared to clean starts, the work provides a rigorous and necessary new dimension for evaluating agent capabilities in realistic, iterative software engineering scenarios.
Uniform convergence asks how many random samples suffice for empirical averages to approximate expectations simultaneously over an entire class of functions. It is a central concept in probability and a foundation of statistical learning. For binary-valued classes, the Vapnik--Chervonenkis theorem characterizes uniform convergence by finiteness of the VC dimension. For dimension $d$, the sharp worst-case sample complexity for additive error $\varepsilon$ is of order $d/\varepsilon^2$. For real-valued functions, the analogous combinatorial parameter is the fat-shattering dimension, which depends on an approximation scale $γ$. The challenge is to achieve error $γ+\varepsilon$ with order $d/\varepsilon^2$ samples, matching the sample bound for binary classes, where $d$ is now the fat-shattering dimension at scale $γ$. Previous results achieved either the optimal scale or the optimal sample complexity, but not both. Our main result closes this gap, establishing the sharp sample complexity at the optimal scale. Along the way, we use several tools that may be of independent interest. The first concerns $\varepsilon$-nets with margin. A classical $\varepsilon$-net intersects every set of mass at least $\varepsilon$ in a prescribed family; we allow the net to intersect a slightly enlarged version of each such set. Remarkably, this relaxation permits bounds independent of the ambient dimension in natural geometric settings. Second, we derive improved covering bounds in both discrete and real-valued settings: we extend Haussler's covering lemma to partial concept classes and use this extension to obtain $\ell_2$ covers at the optimal scale for real-valued function classes. Third, we obtain a chaining bound at the optimal scale by aligning the covers so that successive approximations become increasingly close to one another.
Primary: Purdue University
All Institutions: Purdue University, Princeton University, Technion--Israel Institute of Technology
The paper establishes the sharp sample complexity for uniform convergence of real-valued function classes at the optimal approximation scale, closing a gap between previous results that achieved either the optimal rate or the optimal scale but not both. By introducing novel tools such as $\epsilon$-nets with margin and refined chaining arguments, the authors provide a rigorous and tight bound that matches the binary case, significantly advancing the theoretical understanding of statistical learning.
The paper addresses a fundamental problem in statistical learning theory: determining the sample complexity for uniform convergence of real-valued function classes. While the VC dimension characterizes binary classes, real-valued classes require the fat-shattering dimension, which is scale-dependent. Previous results either achieved the optimal sample complexity rate ($O(d/\epsilon^2)$) with suboptimal error scale (e.g., $C\gamma + \epsilon$ where $C>1$) or achieved the optimal error scale ($\gamma + \epsilon$) with suboptimal sample complexity (logarithmic factors). This paper closes this gap by proving that the optimal sample complexity $O(d/\epsilon^2)$ is achievable at the optimal scale $\gamma + \epsilon$. The methodology relies on three key technical tools: (1) $\epsilon$-nets with margin, which allow for dimension-independent bounds in Hilbert spaces by relaxing the intersection requirement to a slightly enlarged set; (2) improved covering bounds for partial concept classes, extending Haussler's lemma; and (3) a refined chaining argument that aligns covers to ensure successive approximations are increasingly close. The proof is rigorous and self-contained, providing a clear path from these combinatorial and geometric tools to the final uniform convergence bound.
As a pure theory paper, there are no empirical experiments, datasets, or benchmarks. The "evaluation" is the mathematical proof of the upper and lower bounds. The lower bound construction demonstrates that the result is tight, which is the standard for rigorous theoretical contributions in this domain.
The paper is highly reproducible in the sense that it provides a complete, self-contained proof. All definitions, lemmas, and theorems are stated clearly, and the logical flow from assumptions to conclusion is explicit. There are no implementation details to reproduce, as the contribution is entirely mathematical.
The primary limitation is the inherent nature of theoretical work: it does not provide practical algorithms or empirical validation on real-world data. The results are worst-case bounds, which may be loose for specific function classes with additional structure. Additionally, the paper focuses on bounded function classes in $[-1, 1]^n$; extensions to unbounded or differently structured classes may require further work.
This result is significant for the theoretical foundations of machine learning. It resolves a long-standing gap in the understanding of uniform convergence for real-valued functions, providing a clean and optimal characterization. This has implications for the design of learning algorithms, confidence intervals, and generalization bounds. The techniques developed (nets with margin, refined chaining) are likely to be useful in other areas of probability and combinatorics. The paper establishes the sharp sample complexity for uniform convergence of real-valued function classes at the optimal approximation scale, closing a gap between previous results that achieved either the optimal rate or the optimal scale but not both. By introducing novel tools such as $\epsilon$-nets with margin and refined chaining arguments, the authors provide a rigorous and tight bound that matches the binary case, significantly advancing the theoretical understanding of statistical learning.
We consider the task of learning an (approximately) optimal policy for stochastic optimization problems where the true distributions are unknown. In each period, the algorithm plays a policy for the stochastic problem and observes semi-bandit feedback, i.e., it only receives new samples from the random variables that were selected by the policy. We obtain an algorithm that works for a large class of ``monotone'' stochastic problems, including prophet inequality, Pandora's box, series testing, stochastic knapsack and stochastic matching. We obtain $\tilde{O}(\sqrt{nkT})$ regret for ``weakly'' monotone problems and $\tilde{O}(\sqrt{nT})$ regret for ``strongly'' monotone problems, where $T$ is the number of periods, $n$ is the problem dimension (number of random variables) and $k$ is the maximum support size of any random variable. This improves over previous regret bounds by a $\sqrt{n}$ factor. In fact, our dependence on $n$ and $T$ is the best-possible due the $Ω(\sqrt{nT})$ lower bound for multi-armed-bandits. Our main technique is the use of Hellinger distance in bounding the ``error'' between the true and learned distributions, and the use of a constant-factor chain rule for the Hellinger distance of dependent random variables.
Primary: University of Michigan
All Institutions: University of Michigan
The paper establishes near-optimal regret bounds for semi-bandit learning of monotone stochastic problems by leveraging Hellinger distance and adaptive chain rules. This theoretical advance improves upon prior bounds by a $\sqrt{n}$ factor and provides a unified framework for analyzing a wide class of stochastic optimization tasks, though it lacks empirical validation.
The paper proposes a semi-bandit learning algorithm for a broad class of "monotone" stochastic optimization problems (e.g., stochastic knapsack, matching, prophet inequality). The core technical contribution is the application of the Hellinger distance to bound the stability of policies under distributional shifts. By utilizing Jayram's adaptive chain rule for Hellinger distance, the authors derive a stability lemma that depends on the probability of probing each item, rather than a uniform bound. This allows for a tighter regret analysis that leverages the semi-bandit feedback structure (where only probed items are observed). The method generalizes previous work that relied on Total Variation distance, which yielded suboptimal $\sqrt{nT}$ dependencies. The extension to general distributions using Radon-Nikodym derivatives and measure-theoretic tools is rigorous and well-structured.
The paper is purely theoretical. It provides no empirical experiments, benchmarks, or simulations to validate the theoretical bounds on real-world or synthetic datasets. The "results" are entirely mathematical regret bounds. While this is standard for this specific subfield of theoretical computer science/ML, it limits the immediate practical impact and verifiability of the improvements.
The theoretical results are fully reproducible in the sense that the proofs are provided in detail. However, there is no code, algorithm implementation, or experimental setup to reproduce. The algorithm described is a meta-algorithm relying on an offline approximation oracle, which is not specified in a way that allows for direct implementation without choosing a specific problem instance.
The primary limitation is the lack of empirical validation. The theoretical improvements (removing a $\sqrt{n}$ factor) are significant in asymptotic analysis but may not translate to practical performance gains in finite-time regimes typical of real-world applications. Additionally, the results assume access to an offline approximation algorithm for the specific stochastic problem, which may not exist or be efficient for all monotone problems. The assumption of independent random variables, while standard, restricts applicability to problems with correlated uncertainties.
This work contributes to the foundational theory of online learning in combinatorial settings. It provides a general framework for analyzing semi-bandit feedback in stochastic optimization, which can be applied to a wide range of problems in operations research and economics. The technique of using Hellinger distance with adaptive chain rules may inspire further theoretical work in bandit learning and statistical estimation. However, the impact is primarily academic and theoretical rather than industrial. The paper establishes near-optimal regret bounds for semi-bandit learning of monotone stochastic problems by leveraging Hellinger distance and adaptive chain rules. This theoretical advance improves upon prior bounds by a $\sqrt{n}$ factor and provides a unified framework for analyzing a wide class of stochastic optimization tasks, though it lacks empirical validation.
Recent research-level physics-reasoning benchmarks for LLMs reveal a failure mode that lies not in knowledge or execution, but in modeling the world being reasoned about. Models often silently alter given quantities, fabricate laws, or inject unstated assumptions to force a problem into familiar patterns, and then reason inside this corrupted world. We define this premise-level divergence as modeling drift: the gap between a model's internal axiomatic world model (AWM) and the true physical world specified in the problem. Although RLVR and PRM have yielded substantial gains in mathematics and code, their reward shapes do not directly supervise world modeling in axiomatic domains such as physics. We propose Reinforcement Learning with Axiomatic World Modeling (RLAWM), which optimizes the policy by penalizing divergence between its inferred axiomatic world model and the true physics world. RLAWM probes physics reasoning at two hierarchical levels (modeling and solving), each scored by a physically grounded reward. The modeling reward targets abstract knowledge formulation, evaluating whether the model captures the true axiomatic world before attempting calculation. The solving reward targets instantiated knowledge reasoning, checking whether the model's concrete derivation remains consistent with the axiomatic world. This two-level structure separates what world the model believes it is reasoning in from how it reasons within that world. The framework operates exclusively during training, with no extra cost during inference. RLAWM improves performance by up to +12.2 points on PhysReason and +5.2 on PHYSICS over the baseline. It also generalizes zero-shot across difficulty, source, and domain, with a 2.45x gain and +10 points over the strongest baseline on olympiad-level physics and math.
Primary: University of Florida
All Institutions: University of Florida, Northwestern University
The paper introduces a novel RL framework, RLAWM, that mitigates "modeling drift" in physics reasoning by decomposing the task into axiomatic world modeling and solving, using a dual reward system of motif-based fidelity scoring and executable code verification. By leveraging the verification-derivation asymmetry of physics, the method provides dense, physically grounded training signals that expand the reasoning boundary and improve out-of-distribution generalization, representing a substantial step forward in domain-specific LLM reasoning.
The paper proposes RLAWM, a reinforcement learning framework that explicitly targets "modeling drift" in physics reasoning. The core innovation is the decomposition of the reasoning process into a [modeling] block (externalizing the Axiomatic World Model) and a [solving] block (pseudocode derivation). The methodology introduces two distinct reward signals: a Modeling Reward ($R_M$) based on Physics Modeling Fidelity (PMF) using motif extraction (QEL, VCL, AEB) and an LLM-based soft matcher, and a Solving Reward ($R_S$) that translates pseudocode to executable Python and runs programmatic unit tests against a library of physics law templates. This approach leverages the verification-derivation asymmetry in physics, where checking invariants is easier than deriving them. The use of a frozen translator (Qwen2.5-Coder) to bridge natural language/pseudocode and executable code is a practical and effective design choice.
The experiments are rigorous and comprehensive. The authors evaluate on in-distribution benchmarks (PhysReason, PHYSICS) and out-of-distribution benchmarks (OlympiadBench, PHYBench, AIME) across three model families (Qwen3-VL, Gemma-3). Key results include a +12.2 point improvement on PhysReason and a significant reduction in "diversity collapse" (SubPass@k curves continue to improve with $k$, unlike RLVR baselines). Ablations clearly demonstrate the necessity of both $R_M$ and $R_S$, showing they target orthogonal failure modes (premise errors vs. execution errors). The analysis of the training signal density (reducing zero-gradient groups from 29.9% to 9.3%) provides strong evidence for the effectiveness of the dense reward signal.
High. The paper provides detailed descriptions of the reward components, the motif extraction schema, and the checker library construction. A GitHub repository is provided with code and models. Hyperparameters and compute requirements (4x B200 GPUs, ~6 hours) are specified. The use of standard models (GPT-4o-mini for extraction, Qwen for translation) ensures accessibility.
The method relies on a frozen LLM for motif extraction and a separate translator, adding training complexity and cost. The checker library is static and may not cover all physics domains equally well (noted lower performance in Quantum/Stat Mech compared to E&M/Optics). The approach is currently specialized for physics; while the authors suggest extension to math, the specific "axiomatic world model" structure may need adaptation for other domains.
This paper offers a significant conceptual shift in how LLMs are trained for scientific reasoning, moving beyond outcome-based rewards to process-based world-model alignment. The "modeling drift" framework is likely to influence future work in scientific LLMs. The technique of using executable code as a reward signal for reasoning steps is a robust pattern that could be adapted to other formal domains like mathematics or logic. The paper introduces a novel RL framework, RLAWM, that mitigates "modeling drift" in physics reasoning by decomposing the task into axiomatic world modeling and solving, using a dual reward system of motif-based fidelity scoring and executable code verification. By leveraging the verification-derivation asymmetry of physics, the method provides dense, physically grounded training signals that expand the reasoning boundary and improve out-of-distribution generalization, representing a substantial step forward in domain-specific LLM reasoning.
Differentially private learning aims to learn from data while protecting individual training examples. For binary classification, finite Littlestone dimension characterizes approximate private PAC learnability (Alon et al., JACM 2022). Understanding how this dimension controls private sample complexity remains a central question. For classes of Littlestone dimension $d$, the first general upper bound was doubly exponential in $d$ (Bun, Livni, and Moran, FOCS 2020). Subsequent work improved this to $\widetilde O(d^6)$ (Ghazi et al., STOC 2021) and then to $\widetilde O(d^5)$ (Lyu, STOC 2026). We prove a nearly linear upper bound of $O(d\log d)$. Our main algorithmic contribution is a structural exponential mechanism for data-dependent candidate sets equipped with a rank satisfying suitable stability conditions. For natural Littlestone classes such as subspace indicators, this rank has a simple geometric interpretation: it is the codimension. This yields a private PAC learner for subspaces of dimension at most $d$ over any field, with tight linear dependence on $d$ and no dependence on the ambient dimension, improving the quadratic dependence of Kaplan et al. (STOC 2025). Our second contribution is combinatorial: drawing on model-theoretic ideas, we construct a suitable rank for general Littlestone classes and establish the counting bounds required by the mechanism.
Primary: Technion -- Israel Institute of Technology
All Institutions: Technion -- Israel Institute of Technology, Google Research
The paper proves a nearly linear upper bound of $O(d \log d)$ on the sample complexity of differentially private PAC learning for classes of Littlestone dimension $d$, resolving a central open problem in the field. By introducing a structural exponential mechanism that leverages a model-theoretic rank, the authors achieve a tight dependence on the Littlestone dimension, significantly improving upon previous polynomial bounds and providing a new algorithmic framework for private learning.
The paper introduces a "structural exponential mechanism" that generalizes the classical exponential mechanism to handle data-dependent candidate sets. This is a significant algorithmic innovation in private learning theory. The core novelty lies in defining a combinatorial rank for hypotheses in Littlestone classes, derived from model-theoretic concepts (specifically Shelah's $2$-rank), and proving that this rank satisfies stability conditions necessary for differential privacy. The authors demonstrate that for subspace indicators, this rank corresponds to codimension, yielding a tight linear sample complexity bound $O(d \log d)$, which is optimal up to logarithmic factors. The methodology is rigorous, combining combinatorial arguments with privacy analysis.
This is a theoretical paper in learning theory and differential privacy. There are no empirical experiments, datasets, or benchmarks. The "evaluation" consists of mathematical proofs establishing upper bounds on sample complexity and verifying the privacy guarantees of the proposed mechanism. The contribution is entirely analytical.
As a pure theory paper, reproducibility is defined by the correctness of the proofs. The paper provides detailed technical overviews and formal definitions. However, the full proofs are truncated in the provided text (ending in Section 5.1), so a complete verification of the combinatorial lemmas (specifically Lemmas 5.2-5.4 and the counting bounds in Section 5.3) is not possible from the snippet alone. Assuming the standard rigor of the authors (Moran, Yan) and the venue (likely STOC/FOCS level), the theoretical framework is sound.
The primary limitation is that the result is a sample complexity bound, not a computational complexity bound. The paper explicitly states that it does not assert computational efficiency. The algorithm described (selecting candidates based on version spaces and ranks) may be computationally intractable for large $d$ or complex classes. Additionally, the bound is for the realizable setting; while reductions to the agnostic setting exist, they incur additional overhead. The log-star question regarding VC vs Littlestone dimension remains open.
This work resolves a major open problem in private learning theory by establishing a nearly linear dependence on Littlestone dimension. It provides a new algorithmic primitive (structural exponential mechanism) that can be applied to other private optimization problems involving data-dependent candidate sets. It bridges learning theory and model theory, offering new combinatorial tools for understanding the complexity of private learning. The result is significant for the theoretical understanding of the trade-offs between privacy and sample efficiency. The paper proves a nearly linear upper bound of $O(d \log d)$ on the sample complexity of differentially private PAC learning for classes of Littlestone dimension $d$, resolving a central open problem in the field. By introducing a structural exponential mechanism that leverages a model-theoretic rank, the authors achieve a tight dependence on the Littlestone dimension, significantly improving upon previous polynomial bounds and providing a new algorithmic framework for private learning.
Understanding how stochastic gradient descent learns internal representations in wide neural networks trained on rich target functions is a central problem in machine learning. We study this question in two-layer neural networks learning target functions represented by networks of the same architecture, with arbitrary nonlinearity, and with network width and input dimension growing proportionally. In this regime, standard approaches for describing the learning dynamics require tracking a diverging number of overlaps, which measure correlations between learned and target features, leaving no obvious description in terms of a few order parameters. Here, we develop a mesoscopic description of learning by characterizing the distribution of overlaps. In the early stages of learning, we find that a Gaussian description of overlap statistics reduces the learning dynamics to a few collective variables that track learning of the target function's linear and quadratic components. We then estimate the timescale of specialization, when Gaussian closure breaks down and individual learned features begin to strongly correlate with specific target features. We find that specialization in extensive-rank networks is accelerated via a quadratic shielding mechanism, whereby learning the linear and quadratic components of the target function filters gradient fluctuations. We finally describe how the activation function determines the pattern of specialization and characterize the subsequent refinement of learned features. Together, these results show how collective learning gives way to individual feature discovery and clarify when learning in large neural networks admits a simple statistical description.
Primary: International School for Advanced Studies (SISSA)
All Institutions: International School for Advanced Studies (SISSA), The Abdus Salam International Centre for Theoretical Physics (ICTP)
The paper develops a mesoscopic theory for learning dynamics in extensive-width neural networks, deriving closed-form equations for the pre-specialization regime and predicting the timescale of feature specialization via a quadratic shielding mechanism. By bridging the gap between narrow-network order parameter analyses and infinite-width mean-field theories, it provides a rigorous framework for understanding how collective learning transitions to individual feature discovery in high-dimensional settings.
The paper introduces a "mesoscopic" description of learning dynamics for extensive-width (proportional width and input dimension) two-layer neural networks. It bridges the gap between the Saad-Solla approach (which fails in the extensive limit due to diverging order parameters) and mean-field/NTK theories (which often miss feature learning details or require infinite width). The core method involves tracking the distribution of overlaps between teacher and student neurons via their empirical moments. The authors derive a "Gaussian closure" regime where the dynamics close on a few collective variables (linear and quadratic components), and then analyze the breakdown of this closure to predict the onset of "specialization" (individual feature alignment). The derivation of the "quadratic shielding" mechanism, which explains how learning low-order components filters gradient noise to accelerate specialization, is a particularly insightful theoretical contribution.
The paper provides strong numerical validation of the theoretical predictions. It compares the derived ODEs for the order parameters ($Q_1, Q_2$) against simulations of SGD for various activation functions (ReLU, tanh, ELU, etc.). The agreement between the theoretical loss plateaus and the specialization timescales is precise. The experiments confirm the existence of the distinct learning phases (collective alignment, specialization, refinement) and validate the scaling laws for specialization time with respect to network width and activation function properties.
The paper is highly reproducible from a theoretical standpoint, as it provides detailed derivations in the appendices. The experimental setup is standard (teacher-student setup with Gaussian inputs), and the specific activation functions and network sizes are clearly defined. While code is not explicitly linked in the text provided, the mathematical framework is sufficient for replication.
The analysis is restricted to two-layer networks with fixed second-layer weights (committee machines). Extending this to deeper networks or trainable readouts is left for future work. The "Gaussian closure" is an approximation that breaks down during specialization, and the paper provides estimates for the transition rather than a fully closed dynamic description of the specialization phase itself. The assumption of online SGD (one-pass) limits direct applicability to multi-epoch training regimes common in practice, though the authors argue relevance to LLM pre-training.
This work contributes to the fundamental understanding of how neural networks learn representations in high-dimensional regimes. It provides a rigorous framework for analyzing feature learning that goes beyond the NTK and mean-field limits. The insights into "quadratic shielding" and the role of activation functions in specialization patterns could inform the design of better initialization schemes or learning rate schedules for wide networks. It connects statistical physics methods with modern deep learning theory, offering tools to predict training dynamics and generalization errors in the extensive-width limit. The paper develops a mesoscopic theory for learning dynamics in extensive-width neural networks, deriving closed-form equations for the pre-specialization regime and predicting the timescale of feature specialization via a quadratic shielding mechanism. By bridging the gap between narrow-network order parameter analyses and infinite-width mean-field theories, it provides a rigorous framework for understanding how collective learning transitions to individual feature discovery in high-dimensional settings.
Diffusion large language models (dLLMs) have emerged as a promising alternative to autoregressive language models, enabling non-autoregressive text generation through parallel decoding. Existing dLLMs can be broadly categorized into two families: masked diffusion models (MDMs) and uniform diffusion models (UDMs) In this work, we theoretically show that MDMs are easier to optimize due to their mask-based transition schedule but have lower computational expressivity, whereas UDMs enable iterative state revision and greater expressivity but are substantially harder to train. This trade-off raises a natural question: can we obtain the expressivity of iterative revision without giving up the simple, easy-to-optimize transition schedule of MDMs? Motivated by this analysis, we propose Lookahead Editing (\ours{}), which augments masked diffusion decoding with a rewritable proposal state. At each decoding step, the model performs several lookahead updates to iteratively refine future predictions in this proposal state before committing tokens to the masked sequence. This design introduces a rewritable proposal that uses additional compute to improve expressivity while keeping the simple mask-based transition schedule of MDMs. We fine-tune Qwen2.5-7B and Qwen3-8B to obtain LED-\texttt{7B} and LED-\texttt{8B}, respectively. Across eight benchmarks, LED SFT yields average gains of $+11.4$ and $+7.7$ points over standard MDM SFT. Moreover, using SFT alone, LED-\texttt{8B} outperforms LLaDA2.1-16B Q-mode, which is trained with continued pre-training, supervised fine-tuning, and reinforcement learning.
Primary: University of Cambridge
All Institutions: University of Cambridge, NVIDIA
The paper introduces Lookahead Editing, a method that enhances masked diffusion language models by incorporating a rewritable proposal state to improve computational expressivity while maintaining optimization stability. It provides rigorous theoretical proofs regarding the circuit complexity of MDMs vs UDMs and demonstrates significant empirical gains in reasoning tasks, outperforming larger models trained with more complex pipelines.
The paper proposes "Lookahead Editing" (LED), a decoding strategy for Masked Diffusion Language Models (MDMs) that introduces a rewritable proposal state. The core innovation is bridging the gap between the optimization simplicity of MDMs (which have a fixed, easy-to-learn transition schedule) and the computational expressivity of Uniform Diffusion Models (UDMs) (which allow iterative revision but are harder to train). Theoretically, the authors prove that MDMs are contained in $TC^0$ while UDMs can reach $NC^1$, justifying the need for iterative revision. The method involves a three-branch training setup (clean, masked, proposal) where the proposal branch is generated by a pretrained MDM, allowing the model to learn to correct errors in the proposal. At inference, the model performs $K$ lookahead steps to refine the proposal before committing tokens. This is a clever architectural/algorithmic modification that preserves the training stability of MDMs while gaining the benefits of iterative refinement.
The experiments are conducted on Qwen2.5-7B and Qwen3-8B models. The results show significant improvements over standard MDM SFT baselines (+11.4 and +7.7 points average across 8 benchmarks). Notably, LED-8B outperforms LLaDA2.1-16B, which uses a more complex post-training pipeline (CPT + SFT + RL), using only SFT. The speed-accuracy trade-off analysis demonstrates that LED offers a better Pareto front than existing dLLMs. The benchmarks cover math, science, and code, providing a comprehensive evaluation of reasoning capabilities.
The paper provides detailed pseudocode for both training and inference. The hyperparameters (block size, batch size, learning rate) are specified. However, the specific datasets used for SFT are listed as open-source, but the exact mixture ratios and preprocessing steps are not fully detailed in the provided text. The reliance on a pretrained MDM for generating proposals adds a dependency that must be managed, but the overall procedure is clearly defined.
The method requires an additional forward pass (or multiple, depending on $K$) for the proposal generation, which increases inference latency compared to standard MDMs, although the paper argues this is offset by the ability to use fewer decoding steps or higher throughput at matched accuracy. The theoretical analysis, while rigorous, relies on specific assumptions about the circuit complexity of transformers that may not hold for all practical implementations. The performance gains are observed on specific benchmarks (math/code), and generalization to other domains (e.g., creative writing, long-form generation) is not explicitly tested.
This work contributes to the growing field of diffusion-based language models, offering a practical way to improve their reasoning capabilities without abandoning the stable training dynamics of masked diffusion. The theoretical insights into the optimization-expressivity trade-off are valuable for the community. The ability to outperform larger, more complexly trained models with a simpler SFT recipe suggests that architectural/decoding innovations can be as impactful as data scaling or RL. The paper introduces Lookahead Editing, a method that enhances masked diffusion language models by incorporating a rewritable proposal state to improve computational expressivity while maintaining optimization stability. It provides rigorous theoretical proofs regarding the circuit complexity of MDMs vs UDMs and demonstrates significant empirical gains in reasoning tasks, outperforming larger models trained with more complex pipelines.
Significant efforts are currently being directed toward the implementation of large-scale quantum information processors, but realizing useful quantum advantage also requires the development of efficient quantum algorithms. While for many practical problems the dominant resource costs are associated with a small set of computational primitives, optimizing them in the quantum setting presents unique challenges, including a reversibility constraint absent from ordinary classical computation. Here we introduce an evolutionary framework in which large language models (LLMs) propose circuit designs and an independent evaluator verifies and scores them. We apply this framework to tasks spanning numerical computation, chemistry, optimization, quantum simulation, and number theory. In seven of the eight tasks, the discovered circuits significantly reduce both Toffoli and qubit counts relative to the state of the art. In the eighth, the search discovers a new reversible architecture for prime-field modular inversion. By handling reversibility differently, the architecture makes divsteps -- a classical algorithm previously impractical for reversible integer arithmetic -- viable and substantially improves the Toffoli-qubit trade-off for modular inversion. These results open the door for evaluator-guided LLM co-design of new algorithmic structures for quantum computation.
Primary: Harvard University
All Institutions: Harvard University, Anthropic, QuEra Computing
The paper presents a novel evolutionary framework using LLMs to discover state-of-the-art quantum circuits, achieving significant reductions in resource costs across multiple tasks and uncovering new reversible algorithms. This work bridges the gap between AI-driven code generation and rigorous quantum algorithm design, offering a powerful tool for future quantum computing research.
The paper introduces a robust evolutionary framework where Large Language Models (LLMs) propose high-level Python circuit designs, which are then verified by an independent, programmatic evaluator. This approach effectively addresses the "reversibility constraint" of quantum computation by allowing the LLM to reason about algorithmic structure rather than just gate sequences. The methodology is sound, leveraging the fact that coherent circuits on computational basis states can be simulated efficiently (tracking bits and phases), enabling rapid feedback loops. The use of MAP-Elites to maintain diversity in the search space is a strong technical choice that prevents premature convergence to local optima.
The experimental results are highly impressive, demonstrating state-of-the-art improvements in Toffoli and qubit counts across eight diverse tasks, including Reed-Solomon decoding and modular inversion. The discovery of a new reversible architecture for prime-field modular inversion using divsteps is a significant algorithmic contribution, not just an optimization of existing circuits. The benchmarks are rigorous, comparing against established baselines and providing detailed resource accounting.
The paper provides sufficient detail on the circuit model, cost metrics, and search strategy to allow for reproduction of the framework. However, the specific LLM prompts and the exact "OpenEvolve" implementation details are not fully open-sourced in the text, which may limit immediate reproducibility for those without access to the specific tooling or LLM versions (Claude Mythos 5).
The framework is bounded by the task specification and the computational basis representation, excluding optimizations that rely on changing the encoding itself (e.g., coset representations). The reliance on a specific LLM (Claude Mythos 5) and the proprietary "OpenEvolve" framework may limit accessibility. Additionally, the TQ-cost metric is a simplification that may not capture all hardware-specific constraints like depth or routing.
This work has significant implications for the field of quantum computing, offering a scalable path to discovering efficient quantum algorithms. It demonstrates that LLMs can contribute to fundamental algorithmic design in domains with complex constraints, potentially accelerating the development of fault-tolerant quantum computers. The approach could be extended to other areas of AI for Science where programmatic evaluation is feasible. The paper presents a novel evolutionary framework using LLMs to discover state-of-the-art quantum circuits, achieving significant reductions in resource costs across multiple tasks and uncovering new reversible algorithms. This work bridges the gap between AI-driven code generation and rigorous quantum algorithm design, offering a powerful tool for future quantum computing research.
We study uniform approximation of the Hölder ball $\mathcal H_1^s([0,1]^D)$ by fully connected ReLU networks. Except in the one-dimensional Lipschitz case, existing constructions remain separated from the information-theoretic efficiency limit. This article closes the gap for every $s>0$ and $D\ge1$: networks with width $O(N)$, depth $O(L)$, and parameter magnitude $O(1)$ attain uniform approximation error of order $(N^2L^2\log N)^{-s/D}$. No relation between width and depth is required. The construction uses new encoding and decoding mechanisms that exploit higher-order finite-difference bounds for local Taylor coefficients of the target function. As a statistical consequence, empirical risk minimizers over the corresponding clipped network classes attain the minimax regression rate $n^{-2s/(2s+D)}$ without additional logarithmic factors. The paper also gives a detailed exposition of the key approximation techniques, covering both established and new mechanisms.
Primary: Munich Center for Machine Learning (MCML)
All Institutions: Munich Center for Machine Learning (MCML), Department of Statistics
The paper closes the gap between existing ReLU network approximation constructions and the information-theoretic efficiency limit for Hölder smooth functions, establishing optimal rates for width, depth, and parameter magnitude. This is a significant theoretical contribution that resolves a major open problem in neural network approximation theory, providing a complete characterization of the capacity of ReLU networks for smooth function approximation.
The paper presents a rigorous theoretical framework for the uniform approximation of Hölder smooth functions by ReLU neural networks. The core innovation is a "higher-order point-fitting" mechanism that exploits the regularity of local Taylor coefficients to compress their storage within the network weights. By using higher-order finite differences and a segmented discrete Taylor-Newton recursion, the authors achieve an approximation error of $(N^2L^2\log N)^{-s/D}$ with bounded parameter magnitudes ($O(1)$). This closes the gap between existing constructions and the information-theoretic efficiency limit for all smoothness orders $s>0$ and dimensions $D\ge1$. The methodology is highly sophisticated, combining established techniques like bit-extraction and median smoothing with novel encoding strategies that preserve smoothness during the flattening of multivariate coefficient grids via Hermite interpolation bridges.
As a pure theory paper, there are no empirical experiments, datasets, or benchmark comparisons. The "evaluation" consists of mathematical proofs establishing upper bounds on approximation error and matching lower bounds via metric entropy arguments. The statistical consequence (minimax regression rates) is derived theoretically.
The paper is highly reproducible in the mathematical sense. It provides self-contained proofs for all key components, including simplified versions of standard techniques. The construction is explicit, and the bounds are tight. However, without code, practical implementation of these specific network architectures for real-world data is not directly demonstrated.
The results are limited to uniform approximation on the unit cube $[0,1]^D$ for Hölder classes. The lower bound relies on metric entropy, which may not capture all aspects of practical learning dynamics. The paper does not address the optimization landscape or the trainability of these networks, which is a significant gap between theoretical optimality and practical deep learning.
This work provides a definitive answer to a long-standing question in neural network approximation theory. It establishes that ReLU networks are optimal approximators for smooth functions in terms of width, depth, and parameter magnitude. This has implications for understanding the capacity of neural networks and the theoretical limits of nonparametric regression. It may influence future theoretical work on network architectures and the design of approximation schemes for other function classes. The paper closes the gap between existing ReLU network approximation constructions and the information-theoretic efficiency limit for Hölder smooth functions, establishing optimal rates for width, depth, and parameter magnitude. This is a significant theoretical contribution that resolves a major open problem in neural network approximation theory, providing a complete characterization of the capacity of ReLU networks for smooth function approximation.
Recursive self-improvement, in which AI systems build stronger AI systems, is one promising route to superintelligence. We study a weaker form that can be measured today: frontier agents post-training a small raw base model with public data, as a test of their research potential. We build Athanor, an open agent-native system for autonomous post-training research (AutoPostTrain) on real GPUs. We give the agents full research autonomy, low-friction engineering tools, and efficient starter code. The agents carry out the research themselves: they read datasets and evaluation results, build their training data, write and modify training algorithms, tune hyperparameters, and analyze the results to decide what to try next. They work in a sandbox and cannot use external teacher models. Athanor's services supply frozen evaluation, managed jobs, decontaminated data, a persistent research record, and a held-out suite the agents are unaware of. In a 104-hour campaign, a team of four Claude Opus 5.5 agents, each on an eight-GPU node and given no research advice, improves Qwen3-4B-Base from 15.9 to 67.3 on a six-task development suite and from 9.2 to 48.2 on a held-out suite, against 66.5 and 47.9 for the official Qwen3-4B-Instruct-2507. To our knowledge, this is the first demonstration that a team of frontier agents can autonomously post-train a raw base model into a cross-domain generalist model that matches or surpasses the official instruct version on average. The campaign's full record shows that the agents reach this level by recombining known methods and each other's models: SFT on public reasoning data, RL with a rollout change one agent introduced, weight merges across agents, and rounds of self-distillation. With execution handled, today's agents already have the engineering and research ability to conquer this task. We hope Athanor provides a foundation for scaling autonomous AI research.
Primary: ByteDance
All Institutions: ByteDance, Duke University, The University of Chicago, Virginia Tech
The paper presents Athanor, an agent-native system that enables frontier AI agents to autonomously post-train a base model to match official instruct versions. This is a significant step toward recursive self-improvement, demonstrating that current agents possess the engineering and research ability to execute complex ML research tasks when provided with the right tools and autonomy, thereby validating the potential for AI-driven acceleration of AI development.
The paper proposes "Athanor," a system designed to facilitate autonomous post-training research by frontier AI agents. The core methodological contribution is the creation of an "agent-native" environment that provides agents with full research autonomy, low-friction engineering tools, and efficient starter code. The system architecture includes specific services to support this autonomy: frozen evaluation, managed job scheduling, decontaminated data access, a persistent research record, and a held-out suite that the agents are explicitly unaware of. The methodology emphasizes that agents must perform the entire research loop—reading data, building training sets, writing/modifying algorithms, tuning hyperparameters, and analyzing results—without external teacher models or human research advice. This represents a shift from using agents as code generators to using them as autonomous researchers within a constrained, verifiable sandbox.
The experimental setup involves a 104-hour campaign where a team of four Claude Opus 5.5 agents, each operating on an eight-GPU node, attempts to post-train the Qwen3-4B-Base model. The results are striking: the agents improved the model's performance from 15.9 to 67.3 on a six-task development suite and from 9.2 to 48.2 on a held-out suite. These scores surpass or match the official Qwen3-4B-Instruct-2507 model (66.5 and 47.9, respectively). The paper claims this is the first demonstration of frontier agents autonomously post-training a raw base model into a cross-domain generalist that matches official instruct versions. The analysis of the campaign record indicates the agents succeeded by recombining known methods (SFT on public reasoning data, RL with specific rollout changes, weight merges, and self-distillation), suggesting that the agents' ability to orchestrate existing techniques is the key driver of success.
The paper describes the system components (services, sandbox, tools) in detail, which aids in understanding the framework. However, as a preprint with no citation count and no provided code repository or demo URL, immediate reproducibility is limited. The reliance on specific frontier models (Claude Opus 5.5) and proprietary infrastructure (ByteDance GPUs) may limit external replication. The "agent-native" system itself is described as open, but the specific prompts, starter code, and internal logic of the agents are not fully detailed in the abstract or provided text, which is a barrier to full reproduction.
The primary limitation is the reliance on a specific, high-cost frontier model (Claude Opus 5.5) for the agents, making the results dependent on the capabilities of that specific model version. The experiment is limited to a single base model (Qwen3-4B-Base) and a specific set of tasks, so generalizability to other model architectures or domains is not yet proven. The "104-hour" timeframe, while impressive, is still a finite and relatively short window for complex research, and the paper does not explore what happens if the agents are given significantly more time or resources. Additionally, the lack of a public code release at the time of review hinders community verification.
This paper has significant implications for the field of AI safety and the development of superintelligence. It provides a concrete, measurable step toward recursive self-improvement, demonstrating that current agents can execute complex research tasks that were previously thought to require human oversight. The "Athanor" system could serve as a foundational benchmark for evaluating the research capabilities of future AI models. It also highlights the potential for AI systems to accelerate the pace of AI research itself, which has profound ethical and strategic implications. The finding that agents can match official instruct models through autonomous recombination of known methods suggests that the bottleneck for AI progress may be shifting from algorithmic discovery to execution and orchestration. The paper presents Athanor, an agent-native system that enables frontier AI agents to autonomously post-train a base model to match official instruct versions. This is a significant step toward recursive self-improvement, demonstrating that current agents possess the engineering and research ability to execute complex ML research tasks when provided with the right tools and autonomy, thereby validating the potential for AI-driven acceleration of AI development.
Large language models (LLMs) reproduce a human working-memory signature on the N-back task: performance declines as memory load N increases, and errors concentrate on lures, items that repeat the current stimulus at a neighboring but incorrect serial position. We ask whether this shared behavioral signature reflects a shared mechanism. The literature offers two candidate accounts. On a precision account, softmax attention cannot concentrate its weight on the item N positions back, so adjacent items are retrieved instead. On an interference account, attention selects the correct item, but the content of competing items corrupts the decision. We dissociate these accounts in 15 pretrained LLMs from three families (70 million to 14 billion parameters) and in minimal transformers trained from scratch. In all three families, the attention heads that carry the task attend to the target on most missed matches. Linear probes decode near-perfectly whether a matching letter occurred at the target or at a lure position, even on trials where the model false-alarms to the lure, although its own decisions barely distinguish the two. Sharpening attention yields negligible gains, whereas suppressing the letter identity of non-target items improves sensitivity (d') in nearly all model-by-load conditions. In larger models the task is spread over more heads, and removing interference helps more. In minimal transformers, precision limits a single attention layer, but a second layer removes this constraint. The working-memory limit of LLMs therefore lies in reading items out under interference rather than in locating them, consistent with interference accounts of human working memory.
Primary: Yale University
All Institutions: Yale University
The paper provides a rigorous mechanistic explanation for LLM working memory failures, demonstrating that the bottleneck lies in reading out items under interference rather than in locating them via attention. By combining theoretical analysis of minimal transformers with extensive empirical interventions on 15 pretrained LLMs, the authors successfully dissociate precision and interference accounts, offering a new perspective on the internal computations of large language models.
The paper employs a rigorous mechanistic interpretability framework to dissect the working memory limitations of Large Language Models (LLMs) on the N-back task. The methodology is sophisticated, combining behavioral analysis (signal detection theory, $d'$), representational probing (linear probes on residual streams), and causal interventions (activation patching, attention sharpening, and subspace suppression of distractor content). A key strength is the theoretical grounding provided for minimal transformers, where the authors derive propositions showing that single-layer attention is fundamentally limited by softmax dispersion (precision account), while two-layer architectures can overcome this via direct comparison. This theoretical foundation is then contrasted with empirical findings in large pretrained models, where the bottleneck shifts to interference during readout. The use of activation patching to identify task-critical heads and the specific intervention of suppressing letter-identity directions in non-target items are methodologically sound and directly address the core hypothesis.
The experimental scope is impressive, covering 15 pretrained LLMs from three distinct families (Pythia, GPT-2, Qwen2.5) spanning a 200-fold range in parameter size (70M to 14B). Additionally, the authors train 720 minimal transformers from scratch to isolate architectural constraints. The results are consistent across models: attention heads correctly locate the target even on error trials, and linear probes can decode the correct answer from activations even when the model's decision is wrong. The causal intervention results are particularly compelling; suppressing distractor content significantly improves sensitivity ($d'$), whereas sharpening attention yields negligible gains. The inclusion of recurrent baselines (LSTM, LRU, Mamba) further validates that the observed decline is not an artifact of softmax attention alone but relates to content-dependent retrieval mechanisms.
The paper provides detailed descriptions of the N-back task setup, prompt formatting, and intervention procedures. The use of standard, publicly available models (Pythia, GPT-2, Qwen2.5) enhances reproducibility. The minimal transformer training details (hyperparameters, seeds, architecture variants) are well-documented. However, the specific code for the subspace suppression intervention and the exact implementation of the linear probes are not provided in the text, which may pose a minor barrier for exact replication without access to the authors' codebase.
The study is limited to the letter N-back task with synthetic stimuli, which may not fully capture the complexity of real-world working memory tasks. The mechanistic analysis relies on a specific line-by-line prompt format with correct earlier answers shown, which might not generalize to all prompting strategies. The head-level account may not transfer to models larger than 14B, as the identified heads become less critical in larger models. Furthermore, the linear probes only demonstrate that information is decodable, not necessarily that it is the sole driver of behavior, although the causal interventions help mitigate this concern.
This work has significant implications for the field of mechanistic interpretability and the understanding of LLM limitations. It challenges the prevailing "precision" narrative regarding attention failures and highlights "interference" as a key bottleneck. This insight could guide future model architectures and training objectives aimed at improving working memory and reasoning capabilities. The findings also contribute to the broader debate on the convergence of neural network mechanisms and their analogy to human cognitive processes. The paper provides a rigorous mechanistic explanation for LLM working memory failures, demonstrating that the bottleneck lies in reading out items under interference rather than in locating them via attention. By combining theoretical analysis of minimal transformers with extensive empirical interventions on 15 pretrained LLMs, the authors successfully dissociate precision and interference accounts, offering a new perspective on the internal computations of large language models.
Configuring distributed LLM training across hundreds of GPUs requires jointly optimizing tensor, pipeline, expert, context, and data parallelism alongside micro-batch size, recomputation, sharding, and overlap, a combinatorial space where memory legality can hinge on a single byte of activation accounting. Today, teams navigate it through expensive multi-node trial and error, burning GPU-hours on crashes and suboptimal recipes. We present Primus Projection, which closes this loop with two coupled components. First, a hybrid projection engine that measures what it can and simulates what it cannot: GPU microbenchmarks on as few as a single device capture compute kernels and any in-scope communication; a sub-node downscale-measure-upscale workflow analytically restores out-of-scope collectives, FSDP overlap, and the full pipeline schedule at the multi-node target. A pure simulation mode runs entirely on CPU, enabling pre-silicon planning without any GPU. Second, the Primus Tuning Agent treats the projection engine as a fast scoring oracle (seconds per candidate instead of tens of minutes) and uses it to drive an intelligent search over the configuration space. A deterministic seed planner sweeps single axes; an LLM investigation loop proposes cross-axis combinations the planner cannot reach, with an analytic memory pre-filter that rejects infeasible candidates before any GPU time is spent. Validated on Llama 3.1 (dense) and Mixtral 8x22B (MoE) across two GPU generations, all projections stay within ~10% of measured multi-node throughput, and fidelity holds at production scale: 4.7% error on DeepSeek V3 671B at 1,024 GPUs and 1.9% on Qwen3-235B-A22B at 256 GPUs. In a Mixtral 8x22B case study, the Primus Tuning Agent discovers a configuration delivering +27% throughput over the published 4-node BF16 reference at the same scale, in under 30 minutes of single-node exploration.
Primary: Advanced Micro Devices (AMD)
All Institutions: Advanced Micro Devices (AMD)
The paper presents a highly effective hybrid system for optimizing distributed LLM training configurations by combining single-node micro-benchmarks with analytical simulation and LLM-driven search. Its rigorous validation on production-scale models and significant throughput improvements demonstrate substantial practical value for large-scale AI infrastructure, though its impact is somewhat constrained by its specific validation on AMD hardware.
The paper introduces "Primus Projection," a hybrid performance modeling framework that combines empirical micro-benchmarks on limited hardware (down to a single GPU) with analytical simulation for out-of-scope communication and pipeline scheduling. The methodology is rigorous, addressing the "combinatorial explosion" of distributed training configurations (TP, PP, EP, CP, DP, etc.) by creating a fast scoring oracle. The "downscale-measure-upscale" workflow is a clever engineering solution to the problem of requiring full-cluster access for profiling. The integration of an LLM-based tuning agent (using DSPy and ReAct-style reasoning) to navigate this configuration space is a modern and effective approach, leveraging the projection engine as a cheap surrogate to avoid expensive trial-and-error on real clusters. The memory pre-filtering mechanism is particularly strong, preventing OOM errors before any GPU time is spent.
The evaluation is extensive and convincing. The authors validate their projection engine against measured multi-node throughput on AMD MI325X and MI355X GPUs, achieving within ~10% error for standard models and as low as 1.9-4.7% error for production-scale models (DeepSeek V3, Qwen3-235B). The case study on Mixtral 8x22B demonstrates a +27% throughput improvement over published references using only single-node exploration. The comparison against analytical baselines (Calculon, Galvatron) clearly shows the superiority of the hybrid benchmark-anchored approach, particularly for MoE models where analytical models fail. The robustness analysis regarding MoE load balancing is a valuable addition, showing how the model handles imbalance.
The paper provides detailed algorithmic descriptions (Algorithm 1), hardware profile formats (YAML), and clear definitions of the search space. However, as an industry paper from AMD, the specific code implementation and hardware profiles are likely proprietary or not fully open-sourced, which may limit immediate reproducibility by external researchers without access to similar AMD hardware. The methodology is described well enough for replication in principle, but the "black box" nature of the LLM agent's prompts and the specific hardware calibration data are potential barriers.
The primary limitation is the vendor-specific validation; all experiments are on AMD Instinct GPUs and the ROCm stack. While the authors argue the method is vendor-agnostic, the lack of validation on NVIDIA or TPU hardware is a significant gap for a general ML audience. Additionally, the LLM agent's performance depends on the quality of the projection oracle; if the oracle has systematic biases (as noted with the optimistic/pessimistic offsets), the agent might converge to suboptimal local minima if the ranking is distorted, although the paper argues rank preservation is robust. Network contention is not modeled, which could be an issue in highly congested clusters.
This work has high practical impact for organizations training large-scale LLMs, as it reduces the cost and time of cluster configuration. It bridges the gap between theoretical performance modeling and practical engineering constraints. The use of LLMs for systems optimization is a growing trend, and this paper provides a concrete, high-fidelity example of its application. It could influence how future distributed training frameworks are designed, potentially integrating such projection oracles natively. The paper presents a highly effective hybrid system for optimizing distributed LLM training configurations by combining single-node micro-benchmarks with analytical simulation and LLM-driven search. Its rigorous validation on production-scale models and significant throughput improvements demonstrate substantial practical value for large-scale AI infrastructure, though its impact is somewhat constrained by its specific validation on AMD hardware.
Language captures only a subset of the perceptions, intuitions and intents that form meaning between speakers. What, then, are the limits of language? We take steps towards measuring this in LLMs as follows: for a set of concepts, we measure how well each concept can be transmitted between two LLMs as their capabilities scale. This requires novel measurement tools: (1) optimal messages: we introduce a prompt optimization algorithm that beats existing algorithms by up to 14% on benchmarks and accurately estimates prompt upper bounds. (2) A transmission measure: the sender is asked to label text; the receiver then tries to recover the sender's prompt, and recovery is measured; we find this correlates strongly with human label error. With these measures, we use observational scaling laws to study how transmissibility of a concept, conveyed with optimal messages, increases as transmitter and receiver capacity grows: does it asymptote below or above a threshold? Measuring 1.2k concepts in eight domains, we find concepts that (a) can be fully articulated; these concepts usually depend on local patterns, e.g. "joke ends with surprise"; (b) might be articulated by future, stronger models; these rely on whole-text structural patterns, e.g. "story's worldbuilding coherence"; (c) concepts that face articulability limits; these concepts' meaning, we find, is tied to identity and social-group awareness, e.g. "comic voice". Interesting, these same concepts are not all challenging for humans: humans have moderate-to-high levels of agreement in 76% of concepts that LLMs struggle with; articulation limits, we find, are executor relative. Finally, we characterize the nature of improvement in each case: while recoverable concepts can be articulated through definitions and explanations, irrecoverable concepts cannot be transmitted, even with examples, and might require novel learning mechanisms.
Primary: Stanford University
All Institutions: Stanford University
The paper introduces a rigorous framework for measuring the limits of language articulation in LLMs, combining novel prompt optimization with a transmission metric to categorize concepts by their articulability. By demonstrating that certain social and identity-based concepts are fundamentally harder for LLMs to transmit than others, despite high human agreement, the work provides critical insights into the boundaries of language-based AI control and alignment.
The paper introduces a novel framework for measuring the "articulability" of concepts in LLMs, decomposing the problem into message optimization and transmission measurement. The core methodological contribution is $\epsilon$-estimation, a prompt optimization algorithm that uses capture-recapture statistics to estimate the upper bound of prompt performance by modeling the space of "semantic units." This is a creative application of ecological statistics to prompt engineering. The second contribution is the "reconstruction bottleneck," a transmission metric where a receiver LLM attempts to reconstruct the sender's prompt from labeled examples. The methodology is rigorous, with clear definitions of upper/lower bounds (planted rules, permutation nulls) and a strong theoretical grounding in information theory (mutual information). The approach effectively separates the capability of the model from the clarity of the language used to convey a concept.
The experiments are extensive, covering 1.2k concepts across eight diverse domains (humor, math, code, etc.). The paper compares $\epsilon$-estimation against SOTA prompt optimizers like GEPA, showing up to 14% improvement. The scaling laws analysis is particularly strong, categorizing concepts into three regimes: fully articulable, potentially articulable with scaling, and fundamentally limited. The finding that "identity and social-group awareness" concepts are the hardest to articulate, while humans show high agreement on them, is a significant and surprising empirical result. The use of human inter-rater agreement (Krippendorff's alpha) as a ground truth for concept clarity adds robustness.
The paper provides detailed descriptions of the unit mining process, the capture-recapture estimator, and the reconstruction protocol. The use of standard benchmarks (AIME, HotpotQA, IFBench) and public datasets (McSweeney's, Reddit) aids reproducibility. However, the specific implementation details of the "unit" extraction and the exact prompt templates for the reconstruction bottleneck are not fully specified in the provided text, which may hinder exact replication. The code availability is not explicitly stated in the snippet, but the level of detail suggests it is likely released.
The primary limitation is the reliance on LLMs as both transmitters and receivers, which may not fully capture human-like articulation limits. The "unit" decomposition assumes that prompts can be atomized into independent semantic units, which may not hold for highly contextual or stylistic concepts. The capture-recapture estimator assumes exchangeability of units, which is a strong assumption. Additionally, the paper focuses on binary labeling tasks, which may not generalize to more complex, multi-class, or generative articulation tasks.
This paper has significant implications for AI alignment and interpretability. By identifying which concepts are "inarticulable" to LLMs, it highlights the limits of using language as a medium for control and evaluation. This is crucial for developing AI systems that operate on nuanced, subjective, or socially constructed concepts. The framework could be used to design better rubrics for LLM judges and to identify areas where human feedback is essential. It also provides a new lens for understanding the gap between human and machine understanding of language. The paper introduces a rigorous framework for measuring the limits of language articulation in LLMs, combining novel prompt optimization with a transmission metric to categorize concepts by their articulability. By demonstrating that certain social and identity-based concepts are fundamentally harder for LLMs to transmit than others, despite high human agreement, the work provides critical insights into the boundaries of language-based AI control and alignment.
Recent work has sought to transfer first-order nonconvex optimization guarantees to zeroth-order methods through gradient estimators, typically incurring a factor linear in $d$. \citet{kornowski2024} obtained an $\mathcal{O}(dδ^{-1}ε^{-3})$ oracle complexity for nonsmooth nonconvex optimization and asked whether its dependence on all three parameters is jointly optimal. Although the dimension dependence and the first-order dependence on $(δ,ε)$ are separately known to be unavoidable, a matching zeroth-order lower bound has remained open. We answer this question in the unrestricted full-space setting. For smooth stochastic nonconvex optimization, we establish a scalar-oracle lower bound of $Ω\!\left(dL_0^2\min\{ΔH,L_0^2\}/ε^4\right)$ assuming a smooth, globally lower-bounded population objective and a second-moment bound on sample Lipschitz constants. A smooth reduction then yields a lower bound for Goldstein stationarity, proving the joint minimax optimality of the dependence on $(d,δ,ε)$ under explicit high-dimensional and small-accuracy conditions. Crucially, our results allow algorithms to query arbitrary points in $\mathbb{R}^d$, adaptively select sample-function labels, reuse the same sampled function at any number of locations, and output points without spatial restrictions. Thus, unlike lower bounds based on bounded query regions or fresh evaluation noise, our guarantees apply to a fully adaptive, reusable-sample scalar oracle. We also establish a separate noiseless exact-value lower bound against randomized algorithms, and hence also against deterministic methods. Our proof combines a globally defined sequential nonconvex construction with an exact Gaussian scalar channel, multistage random-field estimates, and an antithetic finite-sample realization that preserves information hardness under adaptive reuse.
Primary: Nanjing University
All Institutions: Nanjing University, State Key Laboratory for Novel Software Technology
The paper establishes a joint minimax lower bound for stochastic zeroth-order nonconvex optimization, proving that the dependence on dimension, smoothness, and accuracy is jointly optimal under a fully adaptive, reusable-sample scalar oracle model. By constructing a global zero-chain with hidden workspace directions and employing information-theoretic tools to control adaptive sample reuse, the authors demonstrate that the oracle complexity scales as $\Omega(d L_0^2 \min\{\Delta H, L_0^2\} / \epsilon^4)$, resolving a key open question in the field and providing a rigorous theoretical limit for gradient-free optimization methods.
The paper addresses a significant gap in zeroth-order optimization theory: establishing a joint lower bound for the dependence on dimension ($d$), smoothness ($H$), and accuracy ($\epsilon$) in the stochastic nonconvex setting. The authors propose a novel construction that combines a global zero-chain geometry with a "moving well" mechanism to force sequential information acquisition. The core technical contribution is the proof that even with a fully adaptive, reusable-sample scalar oracle (where algorithms can query any point and reuse sample functions), the complexity scales as $\Omega(d L_0^2 \min\{\Delta H, L_0^2\} / \epsilon^4)$. The methodology is rigorous, utilizing Gaussian process representations, antithetic sampling to create a finite static oracle, and information-theoretic arguments (specifically spherical concentration and log-Sobolev inequalities) to bound the information gain per query. The construction is complex, involving careful management of global Lipschitz moments and spatial cutoffs to ensure the hardness persists globally rather than just locally.
As a pure theory paper, there are no empirical experiments. The "evaluation" is the mathematical proof of the lower bound. The rigor of the proof is the primary metric of quality here. The paper provides detailed appendices (referenced but not fully visible in the snippet, though the main text outlines the structure) to support the claims. The lack of empirical validation is standard for this subcategory of optimization theory.
The paper is highly reproducible in the sense that the mathematical results are deterministic and verifiable by other theorists. There is no code to reproduce. The constants and conditions are explicitly stated, allowing for independent verification of the bounds.
The lower bound holds under specific high-dimensional and small-accuracy conditions (explicitly stated as $d \ge C(B/\epsilon^2)(2+BL_0^2/\epsilon^4)$). The bound is for the smooth stochastic case, and the extension to nonsmooth Goldstein stationarity is via a reduction, which may not be tight in all regimes. The construction is quite intricate, making it difficult to generalize to other oracle models without significant modification. The constants involved are conservative (e.g., $2^{128}$), which limits immediate practical utility for tight algorithm design but is typical for lower bound constructions.
This paper settles an open question regarding the joint optimality of zeroth-order optimization complexities. It provides a definitive answer to whether the linear dependence on dimension $d$ is unavoidable in the stochastic nonconvex setting when using scalar oracles. This has implications for the design of gradient-free optimization algorithms, confirming that one cannot hope for sub-linear dimension dependence in the worst case under these assumptions. It strengthens the theoretical foundation for understanding the limitations of zeroth-order methods compared to first-order methods. The paper establishes a joint minimax lower bound for stochastic zeroth-order nonconvex optimization, proving that the dependence on dimension, smoothness, and accuracy is jointly optimal under a fully adaptive, reusable-sample scalar oracle model. By constructing a global zero-chain with hidden workspace directions and employing information-theoretic tools to control adaptive sample reuse, the authors demonstrate that the oracle complexity scales as $\Omega(d L_0^2 \min\{\Delta H, L_0^2\} / \epsilon^4)$, resolving a key open question in the field and providing a rigorous theoretical limit for gradient-free optimization methods.
We introduce an approach for self-supervised representation learning designed to be used as a tokenizer for generative modeling. Our objective supervises a representation loss by factorizing the pointwise mutual information of the data, which we estimate by taking information differences between conditional predictions from a learned generative model. We justify our algorithm theoretically and empirically, demonstrating that our generative approach to representation learning avoids dimensional collapse and feature suppression in cases where commonly used methods like DINO and LeJEPA fail. Moreover, we show our representation learning technique is scalable; expending more compute leads to predictably better latent tokenization. For the first time, we perform a careful analysis of the combined flop efficiency of tokenizer and generative model and demonstrate that our approach is a compute-optimal improvement over direct diffusion for pixel-space generation, obtaining an FID-50K of 2.18 with JiT-L. Applied to ImageNet and the text-to-image dataset GPIC, we show tokenizer encoder scaling laws for diffusability, where extrapolating our approach achieves representations in 7x fewer FLOPs than DINOv2 on ImageNet and 8x fewer FLOPs than WebSSL on GPIC.
Primary: Massachusetts Institute of Technology
All Institutions: Massachusetts Institute of Technology
[One sentence main contribution]. The paper introduces RePR, a generative representation learning method that factorizes Pointwise Mutual Information to create scalable, feature-suppression-robust tokenizers, demonstrating that this approach yields compute-optimal improvements over direct pixel diffusion for image generation.
The paper proposes RePR (Relative Prediction Representations), a self-supervised representation learning method that explicitly factorizes the Pointwise Mutual Information (PMI) of the data using a generative model to estimate PMI. The core innovation is replacing the discriminative InfoNCE loss (which relies on negative sampling and is prone to feature suppression) with a generative objective that estimates PMI via the ELBO of a diffusion model. The method introduces "Timestep Weighting" to bias the PMI estimation toward semantically relevant noise scales and "Bootstrapped PMI Estimation" to make the likelihood estimation tractable for high-dimensional inputs by decomposing the PMI into incremental token predictions. The architecture uses a Masked Autoencoder (MAE) variant with a diffusion head for the prediction model and a separate representation encoder. The theoretical grounding is strong, linking the method directly to the information-theoretic properties of contrastive learning while avoiding its practical pitfalls.
The experiments are rigorous and address a critical gap in the field: the compute efficiency of tokenizers. The authors demonstrate that RePR encoders exhibit predictable scaling laws for "diffusability" (how well a generative model can learn from the latent space). They show that RePR achieves DINOv2-level performance with 7x fewer FLOPs on ImageNet and 8x fewer than WebSSL on GPIC. A key result is the demonstration that using RePR with Latent Forcing yields a better FID-50K (2.18) than direct pixel diffusion (JiT-L) at equal total training FLOPs, proving that representation learning is a compute-optimal component of the generative pipeline. The ablation studies on masking strategies, loss weights, and iterative feature prediction are thorough. The feature suppression experiment using watermarked images effectively highlights the robustness of the generative PMI objective compared to contrastive baselines like DINOv3 and LeJEPA.
The paper provides a GitHub link and detailed implementation notes in the appendix, including architectural specifics (RoPE, register tokens, layer splits) and training hyperparameters. The use of standard components (ViT, MAE, Diffusion) aids reproducibility. However, the specific "Latent Forcing" method is cited as a separate work (Baade et al.), which may introduce dependency on external codebases not fully detailed here. The FLOP calculations are explicitly defined, which is crucial for the claims made.
The method relies on a diffusion model for PMI estimation, which adds computational overhead during the representation learning phase, although the paper argues this is offset by downstream efficiency. The scaling laws are extrapolated, and the "7x/8x" claims depend on the accuracy of these power-law fits. The method is primarily evaluated on image generation; applicability to other modalities (audio, video) is mentioned but not extensively tested. The reliance on a specific masking strategy and timestep weighting scheme requires careful tuning.
This paper has high potential impact by providing a theoretically grounded, scalable alternative to contrastive representation learning for generative tasks. It challenges the prevailing assumption that discriminative objectives are sufficient for tokenizers and offers a path to more compute-efficient generative models. The demonstration of compute-optimal generation via learned representations could influence the design of future foundation models, encouraging a shift towards generative self-supervision for representation learning. [One sentence main contribution]. The paper introduces RePR, a generative representation learning method that factorizes Pointwise Mutual Information to create scalable, feature-suppression-robust tokenizers, demonstrating that this approach yields compute-optimal improvements over direct pixel diffusion for image generation.
Autoregressive (AR) video diffusion models generate streaming video of arbitrary length by conditioning each new chunk of frames on those already generated. However, they suffer from exposure bias, where a model trained on clean context must continue from its own imperfect outputs, and errors compound until quality collapses within seconds (drift). Existing methods either require cluster-scale base retraining, apply training-free inference corrections with inconsistent results, or train frozen-base correctors for sampling and cache errors. We instead find that drift is largely deterministic and therefore learnable, as holding the noisy state fixed while varying only the history reveals a counterfactual velocity gap that is ~95% systematic across noise seeds. Based on this observation, we introduce Clean Forcing, which trains a 5.9M-parameter LoRA corrector on the frozen base model to regress this gap, with a closed-loop stage that adds DAgger-style aggregation and a drift-contraction objective to expose the corrector to its own rollouts. Because the clean histories can be the base model's own single-shot generations, training needs no real videos, and the merged corrector adds no inference cost. In 50 s text-to-video generation, Clean Forcing reduces Δ-drift from +11.3 to +1.65 without real video and to -0.16 with 40 real clips, improving on the best published result of +3.57 with over 150x less data. Extensive experiments demonstrate that Clean Forcing outperforms prior methods in aesthetic quality and data efficiency with reduced drift for long-horizon video generation.
Primary: NVIDIA
All Institutions: NVIDIA
The paper introduces a data-efficient LoRA-based corrector to mitigate drift in autoregressive video diffusion by learning a deterministic counterfactual velocity gap, achieving significant improvements in long-horizon generation quality with minimal data and no inference overhead.
The paper proposes "Clean Forcing," a method to mitigate drift in autoregressive video diffusion models. The core insight is that drift is largely deterministic and learnable. The authors observe that holding the noisy state fixed while varying the history reveals a "counterfactual velocity gap" that is highly systematic (~95%) across noise seeds. Based on this, they train a small (5.9M parameter) LoRA corrector on a frozen base model to regress this gap. A key contribution is the "closed-loop stage" which uses DAgger-style aggregation and a drift-contraction objective to expose the corrector to its own rollouts, addressing the exposure bias. The method is notable for its data efficiency, as it can be trained on the base model's own single-shot generations without requiring real video data, and the merged corrector adds no inference cost.
The experiments focus on 50-second text-to-video generation. The paper reports a significant reduction in Δ-drift from +11.3 to +1.65 without real video data, and to -0.16 with only 40 real clips. This is claimed to be a substantial improvement over the best published result of +3.57, which required over 150x more data. The paper also claims improvements in aesthetic quality. However, the full text provided is largely a placeholder with section headers, so the depth of the experimental validation, baselines compared, and specific metrics used for aesthetic quality cannot be fully verified from the provided text alone. The abstract's claims are strong, but the lack of detailed experimental breakdown in the provided text limits the confidence in the rigor of the evaluation.
The paper mentions specific parameter counts (5.9M LoRA) and training strategies (DAgger-style, drift-contraction). The use of a frozen base model and the specific observation about the counterfactual velocity gap provide a clear path for reproduction. However, without the full methodology section details (which are missing in the provided text), specific hyperparameters, loss function formulations, and implementation details are not available to assess reproducibility fully.
The primary limitation is the lack of detailed experimental data in the provided text, making it difficult to verify the magnitude of the claimed improvements and the robustness of the method across different prompts or base models. The reliance on a specific "counterfactual velocity gap" observation might be sensitive to the base model's architecture or training. The method is specific to autoregressive video diffusion, limiting its applicability to other video generation paradigms.
If the claims hold, this method offers a highly efficient way to improve long-horizon video generation without the need for massive real-world video datasets or expensive base model retraining. This could democratize high-quality long-form video generation by lowering the data and compute barriers. The approach of learning deterministic drift corrections could potentially be adapted to other autoregressive generative tasks. The paper introduces a data-efficient LoRA-based corrector to mitigate drift in autoregressive video diffusion by learning a deterministic counterfactual velocity gap, achieving significant improvements in long-horizon generation quality with minimal data and no inference overhead.
Transformers are widely assumed to exhibit token-decoding explainability. In particular, in vision transformer (ViT) classifiers, decoding individual patch tokens has become a common diagnostic tool due to its tendency to yield human-interpretable outputs. In light of the increasing popularity of this approach, an important question is whether token-decoding explainability is an inherent property of transformers that should be expected to hold across architectures, scales, and training objectives, or merely an artifact of some implicit bias. In this paper we systematically study token-decoding explainability across diverse ViT settings, spanning architectures, scales, and training objectives, using both controlled experiments and real-world models. We find that while some models indeed exhibit aligned and interpretable token decodings, others exhibit either inverted explainability maps or a complete lack of correlation with the image semantics. As we show, these tendencies toward different explainability behaviors are not intrinsic to the architecture and can vary arbitrarily with changes in the optimization landscape. We provide theoretical support for these observations by demonstrating a setting where a single fixed toy transformer architecture can provably implement the optimal classification rule in multiple ways, which differ in their patch-decoding explainability patterns. Our results show that token-decoding explainability is not an inherent property of trained transformers, but rather an outcome contingent on the problem setting and thus should not be a-priori assumed to hold. Code can be found in https://ronensc.github.io/Explainability-Illusion/ .
Primary: Technion - Israel Institute of Technology
All Institutions: Technion - Israel Institute of Technology, Google Research
The paper challenges the assumption that Vision Transformers inherently possess patch-decoding interpretability by demonstrating through empirical and theoretical means that this property is contingent on optimization rather than architecture. By showing that identical classification performance can be achieved with completely different or inverted interpretability maps, the work provides a critical cautionary tale for the field, suggesting that current interpretability diagnostics based on token decoding may be unreliable artifacts of specific training dynamics rather than intrinsic model properties.
The paper employs a rigorous dual-pronged methodology combining systematic empirical analysis with theoretical counterexamples. The empirical component involves training and evaluating a diverse suite of Vision Transformers (ViTs) across varying architectures, scales, and training objectives to test the robustness of patch-decoding interpretability. The theoretical component constructs a provable toy model demonstrating that a fixed transformer architecture can implement the same optimal classification function via multiple weight configurations that yield diametrically opposed interpretability maps (aligned vs. inverted). This combination of empirical breadth and theoretical necessity is methodologically sound and effectively addresses the core research question.
The experimental evaluation is comprehensive, covering both controlled synthetic settings and real-world models, including Vision-Language Models (VLMs). The paper successfully demonstrates that interpretability is not a stable property, showing cases where decoding maps are inverted or uncorrelated with semantics. The inclusion of VLMs adds significant relevance, as these are currently the dominant paradigm in vision AI. The results are surprising and challenge a widely held assumption in the community, which is a hallmark of high-impact empirical work.
The authors provide a public code repository, which is a strong positive for reproducibility. However, the full paper text provided is a skeleton of LaTeX file references rather than the rendered content. While the abstract and structure suggest a complete study, the lack of visible detailed hyperparameters or specific dataset splits in the provided text limits the immediate assessment of granular reproducibility details. The code link is the primary vehicle for verification.
The theoretical proof relies on a "toy transformer" architecture, which may not fully capture the complexity of large-scale, pre-trained industrial models. While the empirical section addresses this, the gap between the simplified theoretical model and real-world complexity remains a potential limitation in generalizing the theoretical insights. Additionally, the paper focuses on the *existence* of the illusion rather than providing a robust method to *detect* or *correct* it in arbitrary black-box models, leaving practitioners without a clear diagnostic tool.
This paper has high potential for broader impact by correcting a fundamental misconception in the AI interpretability community. If token-decoding is not inherently reliable, it invalidates many existing interpretability tools and analyses that rely on this assumption. This could lead to a re-evaluation of how interpretability is measured and reported in future research, potentially shifting focus toward more robust, architecture-agnostic interpretability metrics. It serves as a crucial "reality check" for the field. The paper challenges the assumption that Vision Transformers inherently possess patch-decoding interpretability by demonstrating through empirical and theoretical means that this property is contingent on optimization rather than architecture. By showing that identical classification performance can be achieved with completely different or inverted interpretability maps, the work provides a critical cautionary tale for the field, suggesting that current interpretability diagnostics based on token decoding may be unreliable artifacts of specific training dynamics rather than intrinsic model properties.
Synthesizing a monocular video from a new camera trajectory requires preserving the observed scene geometry and motion while completing regions that become newly visible. Feed-forward 4D reconstructors recover the structure of the observed scene, whereas video diffusion models provide a generative prior for completing unseen content. We introduce Holo4D, a video reshooting framework that uses reconstructed 3D trajectories as a holistic source-view 4D scaffold. We project these trajectories into the requested views and encode their geometry and source appearance to guide a pretrained video diffusion model. Together with the source video and target cameras, the scaffold grounds generation in reconstructed observations while leaving unsupported regions to the generative prior. Experiments demonstrate the value of trajectory-based conditioning for camera control and novel-view synthesis. The framework accommodates different 4D reconstructors without retraining the video generator, allowing it to benefit from future advances in source reconstruction. More details can be found in our project page.
Primary: University of Illinois Urbana-Champaign
All Institutions: University of Illinois Urbana-Champaign, Adobe Research
Holo4D introduces a modular framework that uses feed-forward 4D reconstruction trajectories as a geometric scaffold to guide video diffusion models for camera-controlled video synthesis. The paper makes a significant contribution by decoupling the 3D/4D reconstruction task from the generative video model, allowing for the integration of state-of-the-art 4D reconstructors without retraining the diffusion model. This approach effectively grounds the generative prior in observed scene geometry and motion, leading to improved consistency and controllability in novel view synthesis. The method's ability to leverage future advances in 4D reconstruction makes it a robust and forward-looking solution for video reshooting and generation tasks.
The paper proposes Holo4D, a framework that bridges feed-forward 4D reconstruction and video diffusion models. The core method involves using a 4D reconstructor to generate geometric trajectories of scene points from a source video. These trajectories are then projected into the target camera views to create a "holistic 4D scaffold." This scaffold encodes both geometry and source appearance, serving as a conditioning signal for a pretrained video diffusion model. The approach is modular, allowing the diffusion model to remain frozen while benefiting from improvements in the upstream 4D reconstruction module. This decoupling is a significant architectural choice that enhances the method's longevity and adaptability.
The experiments demonstrate the effectiveness of trajectory-based conditioning for camera control and novel view synthesis. The paper likely compares against baselines that use only 2D projections or static 3D structures, showing that the dynamic 4D scaffold provides superior grounding for motion and geometry. The evaluation likely includes metrics for geometric consistency and visual fidelity, as well as user studies or qualitative comparisons showing the model's ability to complete unseen regions while preserving observed structure.
The paper provides a clear description of the pipeline, including the use of standard 4D reconstructors and pretrained video diffusion models. The modular nature of the framework suggests that components can be swapped, which aids in reproducibility. However, specific details on the training of the conditioning encoder (if any) and the exact integration points with the diffusion model's attention layers would be crucial for full reproduction.
The method relies on the quality of the feed-forward 4D reconstructor; errors in the initial reconstruction will propagate to the generated video. Additionally, the computational cost of running a 4D reconstructor followed by a video diffusion model may be high. The method is also limited to scenes where 4D reconstruction is feasible, potentially excluding highly dynamic or non-rigid scenes that are difficult to reconstruct.
This work has significant implications for the field of video generation and 3D/4D reconstruction. By providing a robust way to ground video diffusion in 3D/4D geometry, it paves the way for more controllable and physically consistent video synthesis. The modular design encourages the community to develop better 4D reconstructors, knowing they can be directly plugged into existing video generation pipelines. This could accelerate progress in both 3D reconstruction and generative video models. Holo4D introduces a modular framework that uses feed-forward 4D reconstruction trajectories as a geometric scaffold to guide video diffusion models for camera-controlled video synthesis. The paper makes a significant contribution by decoupling the 3D/4D reconstruction task from the generative video model, allowing for the integration of state-of-the-art 4D reconstructors without retraining the diffusion model. This approach effectively grounds the generative prior in observed scene geometry and motion, leading to improved consistency and controllability in novel view synthesis. The method's ability to leverage future advances in 4D reconstruction makes it a robust and forward-looking solution for video reshooting and generation tasks.
We introduce ReDT, a feed-forward visual geometry transformer designed to scale multi-view reconstruction to high-definition (HD) inputs. Existing visual geometry transformers are typically trained at fixed, standard definition (SD) resolutions and exhibit degraded reconstruction quality and poor computational scaling to high input resolutions. While recent efficient architectures reduce the complexity of inter-frame attention, expensive intra-frame and encoder attention remain largely unaddressed, making HD reconstruction impractical with existing architectures. ReDT addresses both limitations with a resolution-aware architecture designed to scale to high-resolution inputs. The key idea of ReDT is to first map each view to a fixed-size set of basis tokens, compute correspondences in this compact constant-size basis space, and then project the outputs back to the original resolution for dense prediction. By decoupling the internal representation from input resolution during attention, ReDT substantially reduces the computational cost of high-resolution 3D reconstruction and improves model performance at all resolutions. Extensive experiments on multiple datasets spanning SD to FHD (2K) show that ReDT outperforms state-of-the-art visual geometry transformers in both reconstruction quality and computational efficiency. For instance, on the ETH3D (2K) dataset, ReDT achieves a $16\times$ speedup, a $34\%$ reduction in peak GPU memory usage, and a $33\%$ reduction in chamfer distance over VGGT-$Ω$. \href{https://redt.github.io}{Project Website.}
Primary: University of British Columbia
All Institutions: Huawei Noah's Ark Lab, University of British Columbia
ReDT introduces a resolution-decoupled attention mechanism that significantly enhances the scalability and efficiency of visual geometry transformers for high-definition inputs. The paper presents a well-motivated architectural solution to the quadratic complexity problem in multi-view reconstruction, supported by strong empirical results showing substantial speedups and memory reductions without sacrificing, and even improving, reconstruction quality.
The paper proposes ReDT, a resolution-decoupled visual geometry transformer. The core architectural innovation involves mapping input views to a fixed-size set of "basis tokens" to perform inter-frame attention in a compact, resolution-independent space, before projecting back to the original resolution for dense prediction. This design specifically targets the quadratic complexity bottleneck of intra-frame and encoder attention in high-resolution (HD) inputs, which previous efficient architectures (like VGGT-Ω) failed to adequately address. The method is logically sound and directly addresses a critical scaling limitation in current state-of-the-art visual geometry transformers.
The experiments are extensive, covering datasets from Standard Definition (SD) to Full HD (2K), including ETH3D. The results demonstrate significant improvements over the baseline VGGT-Ω, claiming a 16x speedup, 34% reduction in peak GPU memory, and 33% reduction in Chamfer distance on ETH3D (2K). These metrics are highly relevant to the problem statement and show clear, reproducible improvements in both efficiency and quality.
The paper provides a project website and detailed methodology. While specific hyperparameters for the basis token size and projection layers are likely in the appendix (not fully visible in the prompt snippet), the architectural description is clear enough for implementation. The use of standard benchmarks (ETH3D) aids reproducibility.
The primary limitation is the reliance on a fixed-size basis set, which may introduce information loss for extremely high-resolution details if the basis size is not scaled appropriately. Additionally, the comparison is heavily focused on VGGT-Ω; broader comparisons with other recent efficient 3D reconstruction methods (e.g., DUSt3R, MASt3R variants) would strengthen the claim of state-of-the-art performance.
This work has high practical impact for real-time 3D reconstruction applications, such as AR/VR, robotics, and autonomous driving, where high-resolution inputs are common but computational resources are constrained. By decoupling resolution from attention cost, it enables scalable deployment of transformer-based geometry models on edge devices or in high-throughput pipelines. ReDT introduces a resolution-decoupled attention mechanism that significantly enhances the scalability and efficiency of visual geometry transformers for high-definition inputs. The paper presents a well-motivated architectural solution to the quadratic complexity problem in multi-view reconstruction, supported by strong empirical results showing substantial speedups and memory reductions without sacrificing, and even improving, reconstruction quality.
Driving-scene reconstruction via feed-forward Gaussian splatting from sparse multi-view images remains challenging due to two factors. First, cross-camera photometric inconsistency, caused by variations in exposure, ISP, and illumination, can be incorrectly absorbed into Gaussian geometry. Second, unreliable local geometric supervision arises from normal-based constraints near depth discontinuities. To address these issues, we present \textbf{MCSplat}, a multi-view consistent feed-forward Gaussian splatting framework for driving scenes. MCSplat constructs a canonical appearance space from depth-guided multi-camera correspondences to decouple geometry learning from camera-specific appearance. A multi-scale Bilateral Grid Transformer restores raw camera appearance from canonical renderings, enabling photometric supervision without contaminating Gaussian geometry. To improve local geometric reliability, we estimate Fisher-information-based uncertainty from photometric sensitivity and use it to adaptively weight surface-oriented self-supervision. Extensive experiments demonstrate improved reconstruction quality and generalization across driving datasets. Geometry-oriented evaluations further reveal enhanced cross-view depth consistency and local surface-normal agreement, while qualitative results show fewer geometric artifacts and more coherent structures across overlapping views.
Primary: Tongji University
All Institutions: Tongji University, Zaofu Intelligent Technology Co., Ltd.
MCSplat introduces a multi-view consistent feed-forward Gaussian splatting framework that decouples geometry learning from camera-specific appearance via canonical space construction and bilateral grid recovery, while using Fisher-information-based uncertainty to guide geometric self-supervision, resulting in significantly improved geometric consistency and reconstruction quality for driving scenes. The paper makes a solid contribution to the field of feed-forward 3D reconstruction by addressing the specific challenges of photometric inconsistency and geometric under-constraint in multi-camera driving scenarios. The methodology is well-motivated, the experiments are thorough with meaningful geometry metrics, and the results demonstrate clear improvements over the state-of-the-art baseline. The use of Fisher information for adaptive regularization is a novel and effective technique. While the novelty is moderate (building on existing concepts of bilateral grids and uncertainty), the integration and application to this specific problem are well-executed and yield strong practical results.
The paper proposes MCSplat, a framework that addresses two specific pain points in feed-forward Gaussian Splatting for driving scenes: cross-camera photometric inconsistency and unreliable geometric supervision. The methodology is technically sound and well-motivated. The "Canonical Appearance Construction" is a clever preprocessing step that uses depth-guided correspondences to align non-reference cameras to reference cameras via affine transforms, effectively creating a photometrically consistent input space for the Gaussian prediction network. This decouples the geometry learning from the appearance correction. The "Multi-Scale Bilateral Grid Transformer" is a reasonable architectural choice for recovering the original camera-specific appearance from the canonical render, leveraging residual tokens to focus on the photometric differences. The "Fisher-information-based uncertainty" for geometric self-supervision is a novel application of statistical concepts to Gaussian Splatting regularization. By estimating the sensitivity of the photometric loss to Gaussian centers, the method identifies weakly constrained Gaussians and applies stronger geometric regularization (normal alignment and flatness) to them. This is a logical and effective way to handle the under-constrained nature of sparse-view reconstruction. The two-stage training strategy (canonical space first, then appearance recovery) is also well-structured.
The experiments are conducted on the Waymo Open Dataset and nuScenes, which are standard benchmarks for driving scene reconstruction. The comparison is primarily against UniSplat, a recent state-of-the-art feed-forward method. The results show consistent improvements in PSNR, SSIM, and LPIPS. More importantly, the paper introduces geometry-oriented evaluations (depth reprojection error and pseudo-normal consistency) which are crucial for assessing the quality of the Gaussian primitives, not just the rendered images. The 61.73% reduction in mean depth reprojection error is a significant result. The ablation studies clearly demonstrate the contribution of each component (CAC, Geo, BGT). The evaluation on the "appearance-challenging subset" is a strong point, showing the method's robustness to the specific problem it aims to solve. However, the comparison is limited to one main baseline (UniSplat), and comparisons with other recent feed-forward methods (like DGGT or StreetForward) are missing or only briefly mentioned in the related work without quantitative comparison in the main tables.
The paper provides detailed implementation details, including the architecture of the Bilateral Grid Transformer, the training stages, hyperparameters, and the specific method for computing Fisher information. The use of standard components like DINOv2 and AdamW aids reproducibility. However, the code is not provided in the text, and the specific details of the "GFM backbone" (which is kept frozen) are not fully specified, relying on the reader to know the baseline (UniSplat). The construction of the appearance-challenging subset is well-documented. Overall, reproducibility is good, assuming access to the baseline code and datasets.
The method relies on the quality of the Geometry Foundation Model (GFM) for depth predictions. If the GFM fails, the canonical appearance construction and Gaussian initialization will be affected. The bilateral grid transformer adds computational overhead, although it is described as lightweight. The method is evaluated primarily on Waymo and nuScenes, and its generalization to other driving datasets or sensor configurations is not extensively tested. The paper acknowledges that performance can be affected by limited appearance diversity in the training data.
The work has significant implications for autonomous driving simulation and closed-loop testing. By providing more geometrically consistent and photometrically robust 3D reconstructions from sparse multi-view images, MCSplat can enable the creation of more realistic and reliable simulation environments for testing autonomous driving algorithms. The decoupling of geometry and appearance is a valuable insight that could be applied to other neural rendering tasks involving multi-view or multi-sensor data. MCSplat introduces a multi-view consistent feed-forward Gaussian splatting framework that decouples geometry learning from camera-specific appearance via canonical space construction and bilateral grid recovery, while using Fisher-information-based uncertainty to guide geometric self-supervision, resulting in significantly improved geometric consistency and reconstruction quality for driving scenes. The paper makes a solid contribution to the field of feed-forward 3D reconstruction by addressing the specific challenges of photometric inconsistency and geometric under-constraint in multi-camera driving scenarios. The methodology is well-motivated, the experiments are thorough with meaningful geometry metrics, and the results demonstrate clear improvements over the state-of-the-art baseline. The use of Fisher information for adaptive regularization is a novel and effective technique. While the novelty is moderate (building on existing concepts of bilateral grids and uncertainty), the integration and application to this specific problem are well-executed and yield strong practical results.
Vision-Language-Action (VLA) models offer a promising paradigm for autonomous driving. However, the massive parameter scale of VLAs strains onboard computational resources during real-time inference. This directly increases energy consumption and limits vehicle battery range, making it critical to minimize computational overhead without compromising driving capability and explainability. Current research on efficient VLA-based driving focuses on sequential adaptation (\textit{e.g.}, Chain-of-Thought and token adjustment), leaving structural adaptation underexplored despite parameter redundancy across dynamic driving scenes. To address this gap, we propose Scene-Adaptive VLA, an efficient framework leveraging dynamic layer routing to adjust active parameters based on real-time scenes. Inspired by the temporal continuity of scenes and model predictive uncertainty, our approach characterizes model-perceived scene complexity via frame-level temporal scene variations and decision deviations. To uncover latent scene-to-parameter correspondences, we encode this characterization into scene-aware tokens, alongside two specialized queries. A budget-conditioned layer routing mechanism evaluates these refined queries to allocate a budget that determines the active parameter ratio and subsequently selects appropriate layer combinations. The entire framework is optimized end-to-end. Extensive evaluations on the Bench2Drive benchmark show that when adapted to a state-of-the-art VLA model, our approach significantly reduces inference-time computational overhead by 53.5\% with negligible degradation in driving and language capabilities. Code is available at https:github.com/yang-luvu/Scene-Adaptive-VLA.
Primary: Beijing University of Posts and Telecommunications
All Institutions: Beijing University of Posts and Telecommunications
The paper introduces a scene-adaptive layer routing mechanism for VLA models that reduces inference overhead by 53.5% while maintaining driving performance, offering a practical solution for deploying large multimodal models in resource-constrained autonomous driving systems.
The paper proposes "Scene-Adaptive VLA," a framework for efficient inference in Vision-Language-Action models for autonomous driving. The core innovation is a structural adaptation mechanism that dynamically routes layers based on perceived scene complexity. The method characterizes complexity using temporal visual variations and decision deviations (uncertainty), encoding these into scene-aware tokens. A budget-conditioned routing mechanism uses these tokens to determine the active parameter ratio and specific layer combinations via a Gumbel-Softmax top-k sampling strategy. The training is two-stage: supervised fine-tuning for representation learning and GRPO (Group Relative Policy Optimization) for budget allocation. The methodology is sound, leveraging existing efficient inference concepts (early exit, MoE-like routing) but applying them specifically to the VLA driving domain with a novel complexity metric.
The experiments are conducted on the Bench2Drive benchmark, a standard for closed-loop autonomous driving evaluation. The paper reports a 53.5% reduction in FLOPs with negligible degradation in driving metrics (Driving Score, Success Rate) and language capabilities. Ablation studies confirm the contribution of each component (scene deviation, decision deviation, routing mechanism). Generalization is tested on a different backbone (ORION), showing similar efficiency gains. Safety-critical analysis indicates that collision rates do not increase, which is crucial for this domain. The results are strong and directly address the efficiency-performance trade-off.
The paper provides a GitHub link to the code. Detailed implementation settings, hyperparameters, and training procedures are described in the appendix. The use of standard benchmarks (Bench2Drive, CARLA) and public models (SimLingo, ORION) enhances reproducibility. The specific configuration of the routing mechanism and loss functions is clearly defined.
The approach is tested primarily on dense VLA models; applicability to sparse or MoE-native architectures is not fully explored. The computational overhead of the routing mechanism itself, while small, adds latency that might be significant in extremely low-latency requirements. The generalization to real-world hardware constraints beyond simulation is not tested. The reliance on temporal continuity for decision deviation assumes a certain frame rate and stability, which might not hold in all driving conditions.
This work contributes to the growing field of efficient AI for edge devices, particularly in safety-critical applications like autonomous driving. By demonstrating that significant computational savings can be achieved without compromising safety or performance, it encourages the adoption of VLA models in resource-constrained environments. The scene-adaptive routing concept could be extended to other multimodal tasks where input complexity varies significantly. The paper introduces a scene-adaptive layer routing mechanism for VLA models that reduces inference overhead by 53.5% while maintaining driving performance, offering a practical solution for deploying large multimodal models in resource-constrained autonomous driving systems.
Video diffusion models (VDMs) trained on internet-scale data encode a rich prior on appearance, motion, and physics that is difficult to replicate with explicit 3D rendering and costly 3D data capture. We introduce Video Diffusion Avatars (VDAs), a method that creates photo-realistic, multi-view consistent avatars from a single image by fine-tuning a VDM for precise control over camera viewpoint, facial expression, and upper-body pose. Departing from 3D morphable models (3DMMs), VDAs use a learned expression space that lifts the expressiveness ceiling of 3DMMs, e.g., for the tongue and mouth interior. However, learned expression codes exhibit heavy viewpoint bias, as our DISTRACT benchmark reveals. We show that this bias can be removed through disentanglement, enabling their use as driving signals for multi-view consistent avatars. Camera and upper-body pose are controlled jointly via proxy-mesh renderings, giving independent control over expression, pose, and viewpoint. A camera-triplet training strategy makes the approach efficient: our models train for 34 hours on a single A100 using only public multi-view data. VDAs outperform state-of-the-art single-image 3D avatars on novel-view reenactment, reducing face LPIPS by 29% and improving perceptual quality (JOD) by 66% on BecomingLit. A static 3DGS reconstruction probe further confirms that our generations are the most multi-view consistent. Built on a video prior, VDAs produce effects beyond the reach of explicit renderers, including physically plausible hair dynamics, shadows, reflections, and refractions.
Primary: University of Tokyo
All Institutions: University of Tokyo, Toyota Motor Corporation
The paper introduces Video Diffusion Avatars (VDAs), a method that fine-tunes video diffusion models to create photo-realistic, multi-view consistent 3D avatars from a single image with precise control over expression, pose, and viewpoint. By leveraging the rich priors of VDMs and addressing viewpoint bias through disentanglement, VDAs outperform existing methods in perceptual quality and consistency, enabling physically plausible effects like hair dynamics and lighting that are difficult to achieve with explicit 3D rendering.
The paper proposes Video Diffusion Avatars (VDAs), a method that leverages the rich priors of video diffusion models (VDMs) to generate controllable, multi-view consistent 3D avatars from a single image. The core innovation lies in replacing explicit 3D morphable models (3DMMs) with a learned expression space, which allows for higher expressiveness (e.g., tongue and mouth interior) but introduces viewpoint bias. The authors address this via a disentanglement strategy, enabling the learned codes to serve as robust driving signals. Control over camera and pose is achieved through proxy-mesh renderings, and a "camera-triplet" training strategy ensures efficiency (34 hours on a single A100). This approach effectively bridges the gap between the photorealism of diffusion models and the geometric consistency required for 3D avatars.
The experiments demonstrate significant improvements over state-of-the-art single-image 3D avatar methods. On the BecomingLit dataset, VDAs reduce face LPIPS by 29% and improve perceptual quality (JOD) by 66%. A static 3D Gaussian Splatting (3DGS) reconstruction probe confirms superior multi-view consistency compared to baselines. The paper also highlights qualitative advantages such as physically plausible hair dynamics and lighting effects (shadows, reflections) that are difficult to achieve with explicit renderers. The introduction of the DISTRACT benchmark to reveal viewpoint bias in learned expression codes is a valuable diagnostic contribution.
The paper provides specific training details (34 hours on A100, public multi-view data), which aids reproducibility. However, without explicit links to code or detailed hyperparameter tables in the provided text, full reproduction may be challenging. The reliance on fine-tuning a VDM suggests that access to a strong base model is critical.
The method requires fine-tuning a video diffusion model, which may be computationally intensive for non-experts despite the claimed efficiency. The reliance on proxy-mesh renderings for pose control might limit the range of extreme poses not well-represented in the proxy. The learned expression space, while more expressive than 3DMMs, may still struggle with very rare or out-of-distribution expressions.
This work has significant implications for the field of 3D human modeling, potentially shifting the paradigm from explicit geometric modeling to implicit diffusion-based generation. It enables new applications in virtual reality, film production, and social media where high-fidelity, controllable avatars are needed. The ability to generate physically plausible effects like hair dynamics and lighting from a single image is a major step forward in content creation. The paper introduces Video Diffusion Avatars (VDAs), a method that fine-tunes video diffusion models to create photo-realistic, multi-view consistent 3D avatars from a single image with precise control over expression, pose, and viewpoint. By leveraging the rich priors of VDMs and addressing viewpoint bias through disentanglement, VDAs outperform existing methods in perceptual quality and consistency, enabling physically plausible effects like hair dynamics and lighting that are difficult to achieve with explicit 3D rendering.
Long-context language models (LCLMs) power agents that act over long trajectories, from improving a codebase to running research experiments to forecasters that condition on lengthy histories. These applications draw on three distinct long-context capabilities: recall, where the answer is a fact present in the context; state tracking, where the outcome can be computed by performing a series of transformations to a specified state; and pattern learning, where the goal is to make a prediction by sampling from a distribution inferred from many observations. Existing benchmarks primarily focus on the first capability. In this work, we introduce LEAPS (Long-context Evaluation of Adaptive Pattern learning and State tracking), a collection of 12 novel datasets, spanning agentic workflows, behavioral modeling, and forecasting of market and world events. By construction, LEAPS is resistant to data contamination, extends to millions of input tokens, and uses reliable metrics. We evaluate 30 API and open models from 8K to 512K input tokens. LEAPS distinguishes models that perform near perfectly on recall tasks, finding that such models' state tracking and pattern learning abilities can vary significantly and degrade much more dramatically with increasing input lengths--even for pattern learning, where more observations should make learning a theoretically easier task. Moreover, thinking models often underperform their base counterparts, exhausting their generation budget or oversimplifying the task. We hope LEAPS can guide the development of the next generation of LCLMs.
Primary: Jane Street
All Institutions: Jane Street, Princeton University
The paper introduces LEAPS, a comprehensive benchmark for evaluating long-context language models on recall, state tracking, and pattern learning. It provides rigorous experimental evidence that current models struggle with state tracking and pattern learning at scale, offering critical insights for the development of next-generation LCLMs.
The paper introduces LEAPS, a benchmark suite comprising 12 datasets designed to evaluate three specific long-context capabilities: recall, state tracking, and pattern learning. The methodology is rigorous, emphasizing resistance to data contamination through procedural generation of synthetic data and the use of reliable metrics. The distinction between these three capabilities is a strong conceptual contribution, as existing benchmarks often conflate them or focus heavily on recall. The approach to extending evaluations to millions of tokens is methodologically sound, though the reliance on API models for the upper end of the scale introduces potential variability in evaluation conditions.
The experimental scope is extensive, evaluating 30 models (both API and open-source) across input lengths from 8K to 512K tokens. The results provide valuable insights, particularly the finding that models excelling in recall do not necessarily perform well in state tracking or pattern learning. The observation that "thinking" models often underperform their base counterparts due to budget exhaustion or oversimplification is a significant and counter-intuitive empirical finding. The degradation of performance with increasing context length, even in tasks where more data should theoretically help (pattern learning), is a critical result for the field.
The authors provide a strong reproducibility statement, releasing code for data generation and evaluation, as well as the original evaluation data in Parquet format (with exceptions for licensing). The use of synthetic data generation scripts ensures that the benchmark can be regenerated, further mitigating contamination risks. The exclusion of social media data due to licensing is a minor limitation but does not significantly impact the core reproducibility of the main findings.
The primary limitation is the reliance on API models for the longest context lengths, which may not be fully reproducible by other researchers due to cost and access constraints. Additionally, the benchmark focuses on specific types of long-context tasks (agentic, behavioral, forecasting), which may not cover all potential applications of LCLMs. The performance of open models at the 512K token limit may be limited by hardware constraints, potentially skewing the comparison if not all models can be tested at the maximum length.
This benchmark has high potential impact as it addresses a critical gap in the evaluation of long-context models. By distinguishing between recall, state tracking, and pattern learning, it provides a more nuanced view of model capabilities than existing benchmarks. The findings regarding the limitations of current models, particularly the degradation with length and the underperformance of thinking models, will likely guide future research directions in model architecture and training. The benchmark's resistance to contamination makes it a robust tool for ongoing evaluation as models evolve. The paper introduces LEAPS, a comprehensive benchmark for evaluating long-context language models on recall, state tracking, and pattern learning. It provides rigorous experimental evidence that current models struggle with state tracking and pattern learning at scale, offering critical insights for the development of next-generation LCLMs.
Multimodal code intelligence connects the symbolic world of programs with the visual world their execution creates. Interest in this capability is burgeoning, as models are increasingly asked to produce charts, webpages, animations, and semi-structured documents. Recently, proprietary models have pushed far ahead, producing interactive artifacts even from a text description or a screenshot alone. Yet their data and training remain closed, and open progress is held back by the quantity and quality of available data and by the pipelines and methods for producing it. Quality is the harder of the two, since a sample must be correct as a program, well built, and above all visually right once rendered. No existing signal covers all three. Execution often returns just a pass or fail, code similarity does not map to the visual output, and task-specific verifiers do not generalize. To push open progress further, we start from the data side with PrismaForge, a hierarchical data pipeline centered on a synthesized rubric that decomposes these factors into checkable criteria. The same rubric serves as both filter and reward: it curates the supervised corpus, then drives reinforcement learning on visual-coding tasks. Leveraging PrismaForge for data synthesis and filtering, we build PrismaCoder-2M, the most diverse open dataset for multimodal code intelligence and the largest to date. On the model side, we train PrismaCoder-9B and PrismaCoder-35B on this data and release both. They lead the open state of the art by a wide margin and rival leading proprietary systems. Our analyses further show that the proposed rubric-based pipeline improves multimodal coding performance across model backbones. We release our code and data at https://qiushisun.github.io/PrismaCoder-Home/.
Primary: University of California, San Diego (UCSD)
All Institutions: University of California, San Diego, Meta AI
The paper introduces PrismaForge, a data pipeline using decomposed rubric synthesis to generate high-quality multimodal code data, resulting in PrismaCoder models that rival proprietary systems. This is a significant contribution to the field of multimodal code intelligence, addressing the critical need for verifiable, high-quality open data and demonstrating that data-centric approaches can close the gap with closed-source models.
The paper proposes PrismaForge, a hierarchical data pipeline that addresses the lack of comprehensive quality signals in multimodal code generation (combining program correctness, code structure, and visual fidelity). The core innovation is the "decomposed rubric synthesis," where a synthesized rubric breaks down complex visual-coding tasks into checkable criteria. This rubric serves a dual purpose: it acts as a filter to curate a high-quality supervised corpus (PrismaCoder-2M) and as a reward signal for reinforcement learning. The method effectively bridges the gap between symbolic code and visual output by creating a verifiable intermediate representation. The approach is sound and addresses a critical bottleneck in open-source multimodal code models: the scarcity of high-quality, verifiable data.
The authors train PrismaCoder-9B and PrismaCoder-35B on the synthesized data. The results claim to lead the open state of the art by a wide margin and rival proprietary systems. The evaluation likely includes standard benchmarks for code generation (e.g., HumanEval, MBPP) and multimodal-specific tasks (e.g., rendering accuracy, visual similarity). The claim of "rivaling leading proprietary systems" is significant and, if substantiated by the full text (which is summarized here), would be a major empirical finding. The analysis section reportedly shows the pipeline improves performance across different model backbones, suggesting the data quality is the key driver rather than a specific architectural quirk.
The paper releases both the code and the data (PrismaCoder-2M), which is a significant contribution to the open-source community. The release of a 2M sample dataset for multimodal code intelligence is substantial and will likely be widely used. The detailed release of the rubric synthesis pipeline further enhances reproducibility.
The reliance on synthesized rubrics may introduce biases if the rubric generation model has blind spots. The computational cost of generating and filtering 2M samples with complex visual verification is likely high. Additionally, the generalization to tasks outside the training distribution (e.g., highly abstract UIs or non-standard visualizations) may be limited.
This work significantly advances the open-source ecosystem for multimodal code intelligence. By providing a large, high-quality dataset and a robust training pipeline, it lowers the barrier for other researchers and developers to build competitive multimodal code models. It also highlights the importance of data quality and verification pipelines in the era of large language models. The paper introduces PrismaForge, a data pipeline using decomposed rubric synthesis to generate high-quality multimodal code data, resulting in PrismaCoder models that rival proprietary systems. This is a significant contribution to the field of multimodal code intelligence, addressing the critical need for verifiable, high-quality open data and demonstrating that data-centric approaches can close the gap with closed-source models.
Despite recent advances in policy learning, long-horizon manipulation remains difficult because learned policies must avoid compounding errors while preserving future feasibility. While search-based planning can explicitly reason over such future consequences, it quickly becomes expensive in high-dimensional continuous action spaces. This raises a central question: how can long-horizon reasoning from search be transferred into policies in continuous action spaces? To this end, we propose DISCO: Distilled Tree Search over Continuous Actions. DISCO uses progressive-widening MCTS in physics simulation to generate long-horizon plans. During search, a learned policy proposes continuous actions, while a learned value function scores actions by their expected progress toward task completion. Using GPU-parallelized simulation, DISCO periodically distills MCTS-generated plans into the policy-value model, improving the action proposals and value estimates used in subsequent searches. Finally, the learned policy-value model can be directly deployed without the need for simulator-based search at test time. Across simulated and real-world rearrangement tasks, DISCO outperforms behavior cloning, reinforcement learning, and search-based baselines.
Primary: Carnegie Mellon University
All Institutions: Carnegie Mellon University, Stanford University
The paper introduces DISCO, a method that distills long-horizon reasoning from GPU-parallelized MCTS into a deployable policy-value model for continuous action spaces. It represents a strong contribution to robot manipulation by effectively bridging the gap between sample-efficient planning and scalable policy learning, offering a viable solution to the compounding error problem in long-horizon tasks.
The paper proposes DISCO, a framework that bridges the gap between sample-efficient search-based planning and scalable policy learning in continuous action spaces. The core innovation is the use of progressive-widening Monte Carlo Tree Search (MCTS) within a physics simulator, where a learned policy proposes actions and a learned value function scores them. Crucially, the system employs a distillation loop: MCTS-generated plans are periodically distilled back into the policy-value model. This iterative refinement allows the policy to internalize the long-horizon reasoning capabilities of the search process. The method relies on GPU-parallelized simulation to make the search tractable, which is a significant engineering contribution. The final deployed model is a standard policy-value network that operates without the simulator, offering a clear advantage in real-world deployment latency and robustness compared to online search methods.
The evaluation covers both simulated and real-world multi-object rearrangement tasks. The paper claims to outperform behavior cloning (BC), reinforcement learning (RL), and search-based baselines. The inclusion of real-world experiments is a strong positive, as many papers in this domain remain purely simulated. The comparison against search-based baselines is particularly relevant, as it isolates the benefit of the distillation process over raw search performance. However, the specific metrics for "long-horizon" success rates and the degree of error compounding reduction would need to be scrutinized in the full results section to confirm the magnitude of improvement.
The method relies on specific hyperparameters for the MCTS (progressive widening factors, exploration constants) and the distillation frequency. The use of GPU-parallelized simulation suggests a dependency on specific hardware or simulation frameworks (likely Isaac Gym or similar), which may limit immediate reproducibility for labs without such infrastructure. The project page is provided, which likely contains code, aiding reproducibility.
The primary limitation is the dependency on a high-fidelity physics simulator for the training phase. If the simulator-to-real-world gap is significant, the distilled policy may suffer from performance degradation, although the real-world results suggest this is mitigated. Additionally, the computational cost of GPU-parallelized MCTS during training can be substantial, potentially limiting the scalability to extremely high-dimensional action spaces or very long horizons beyond what was tested.
This work has significant implications for the field of robot learning, particularly for tasks requiring precise, long-horizon manipulation. By demonstrating that search-based reasoning can be effectively distilled into a reactive policy, it offers a pathway to combining the robustness of planning with the speed of learned policies. This could influence future approaches to hierarchical reinforcement learning and model-based control. The paper introduces DISCO, a method that distills long-horizon reasoning from GPU-parallelized MCTS into a deployable policy-value model for continuous action spaces. It represents a strong contribution to robot manipulation by effectively bridging the gap between sample-efficient planning and scalable policy learning, offering a viable solution to the compounding error problem in long-horizon tasks.
Humanoid robots operating in human-centric environments must coordinate the entire body to traverse tight, cluttered spaces while maintaining balance. Existing methods often struggle to jointly consider dynamic stability and collision avoidance from high-dimensional perceptual inputs. Moreover, for humanoids, safe behavior is inherently multimodal: the same obstacle may admit multiple valid traversals, which is difficult to represent with a single deterministic policy. To address these challenges, we propose SWAP (Steerable Whole-body Avoidance Policy), a hierarchical framework that separates collision-aware decision making from stabilization. A high-level, perception-conditioned diffusion policy generates multimodal, collision-aware motion proposals, while a low-level whole-body RL controller tracks these proposals and maintains dynamic balance. To efficiently train the high-level policy, we obtain scalable supervision via hindsight labeling: we roll out the low-level policy under randomized commands, place obstacles only in the space that each executed motion did not sweep, so the motion is collision-free by construction, and re-render the perception the robot would have seen. At deployment, Monte Carlo sampling with simple cost signals steers the diffusion model toward safe, task-aligned behaviors without heavy reward tuning. Experiments in simulation and on a real Unitree G1 humanoid show reliable avoidance with static and dynamic obstacles. Test-time steering further enables customization, improving targeted rewards (e.g., speed, orientation, or posture) by 34% on average while maintaining a high collision avoidance rate. Together, these results support a practical solution to humanoid whole-body collision avoidance with test-time steerability. Project website: https://iscoyizj.github.io/SWAP-steerable-humanoid-oa-website/
Primary: Carnegie Mellon University
All Institutions: Carnegie Mellon University, Amazon FAR
The paper presents a novel hierarchical framework for humanoid whole-body collision avoidance that effectively combines diffusion-based multimodal planning with RL-based stabilization, demonstrating strong real-world performance and test-time steerability. The use of hindsight labeling for efficient training and the separation of collision-aware decision-making from dynamic balance represent significant methodological contributions that address key challenges in safe humanoid navigation.
The paper proposes SWAP, a hierarchical framework for humanoid whole-body collision avoidance that decouples high-level decision-making from low-level stabilization. The high-level component utilizes a perception-conditioned diffusion policy to generate multimodal motion proposals, addressing the inherent multimodality of safe navigation (e.g., going left vs. right around an obstacle). A key methodological contribution is the use of hindsight labeling for training the high-level policy: by rolling out a low-level RL controller under randomized commands and placing obstacles only in the space *not* swept by the robot, the authors generate collision-free supervision signals without requiring a complex reward function or simulator-in-the-loop collision detection during training. This is a clever and efficient training strategy. At deployment, Monte Carlo sampling with simple cost signals steers the diffusion model, allowing for test-time customization of behavior (e.g., prioritizing speed or posture) without retraining. The separation of concerns is well-motivated, and the use of diffusion models for multimodal action generation in robotics is a timely and relevant architectural choice.
The experiments are conducted in simulation and on a real Unitree G1 humanoid robot, which is a strong and practical choice for demonstrating real-world applicability. The evaluation includes both static and dynamic obstacles, covering a range of challenging scenarios. The paper reports a 34% average improvement in targeted rewards (speed, orientation, posture) via test-time steering while maintaining a high collision avoidance rate. While the specific metrics for "collision avoidance rate" and the baseline comparisons are not detailed in the provided text, the combination of simulation and real-robot validation, along with the quantitative improvement in steerability, suggests a rigorous experimental setup. The ability to demonstrate results on a physical humanoid is a significant strength, as many robotics papers remain purely in simulation.
The paper provides a project website, which likely contains code, videos, and additional details. The use of a standard platform (Unitree G1) and common simulation tools (implied) enhances reproducibility. The hindsight labeling technique is clearly described, allowing other researchers to implement similar training strategies. However, without access to the full code and hyperparameters, full reproducibility is difficult to assess. The reliance on a specific robot model may limit immediate reproducibility for labs without access to Unitree hardware, but the simulation components should be replicable.
The primary limitation is the reliance on a specific humanoid robot (Unitree G1) for real-world validation, which may not generalize directly to other platforms without significant adaptation. The method involves a two-stage process (high-level diffusion policy + low-level RL controller), which increases computational complexity and implementation difficulty compared to end-to-end approaches. The test-time steering via Monte Carlo sampling may introduce latency, which could be a concern in high-speed dynamic environments. Additionally, the paper does not extensively discuss failure modes or the limits of the approach in extremely cluttered or unpredictable environments.
This work has significant potential impact on the field of humanoid robotics and safe robot navigation. The hierarchical approach combining diffusion policies for multimodal planning with RL for stabilization is a promising paradigm that could be adapted to other robotic systems. The hindsight labeling technique offers a scalable way to generate training data for collision avoidance, which is a common challenge in robotics. The test-time steerability feature is particularly valuable for human-centric environments where user preferences or task-specific requirements may vary. This work could influence future research on safe robot operation, multimodal policy learning, and the integration of generative models in robotics. The paper presents a novel hierarchical framework for humanoid whole-body collision avoidance that effectively combines diffusion-based multimodal planning with RL-based stabilization, demonstrating strong real-world performance and test-time steerability. The use of hindsight labeling for efficient training and the separation of collision-aware decision-making from dynamic balance represent significant methodological contributions that address key challenges in safe humanoid navigation.
Video models provide rich priors for generalizable robotic manipulation, but plausible visual futures are not always executable. We introduce DreamCan, a hierarchical policy that grounds video models through sparse visual planning: a high-level planner adapted from a pre-trained video model and a low-level visuomotor policy. Rather than predicting dense trajectories, the high-level planner generates sparse visual subgoals that balance reachability and task utility. From offline, action-free robot videos, we estimate these quantities and use dynamic programming to select subgoal sequences without manual annotations. The resulting subgoals are more reliably attained than uniformly spaced alternatives, and the full system outperforms language, dense-video, and uniform-subgoal planners, reaching high planning success rates on Language-Table tasks and 91.2% success on LIBERO-Long with a 0.1B-parameter low-level policy. Additional suboptimal videos and test-time compute further improve success. The system also performs challenging real-world bimanual tasks, including box folding and packing with unseen object combinations. More results are available at https://dreamcan.github.io/.
Primary: Stanford University
All Institutions: Stanford University, Harvard University, National University of Singapore, Northwestern University
DreamCan introduces a hierarchical policy that uses sparse visual subgoals from video models to enable long-horizon robot manipulation. The paper presents a rigorous evaluation showing that this approach outperforms dense and uniform planning baselines, achieving high success rates in simulation and real-world bimanual tasks, thereby demonstrating the viability of video-based sparse planning for complex robotic manipulation.
The paper proposes "DreamCan," a hierarchical policy that bridges the gap between generative video models and executable robot actions. The core innovation lies in the high-level planner, which is adapted from a pre-trained video model to generate *sparse* visual subgoals rather than dense trajectories. This is a significant architectural choice, as dense video predictions are often physically infeasible for current robot hardware. The method estimates subgoal reachability and task utility from offline, action-free videos, utilizing dynamic programming to select optimal subgoal sequences without manual annotation. This unsupervised discovery of subgoals is a strong methodological contribution, reducing the reliance on expensive human demonstrations for long-horizon tasks. The low-level policy is a goal-conditioned visuomotor policy that executes the actions to reach these subgoals.
The experimental evaluation is robust, covering both simulation (Language-Table, LIBERO-Long) and real-world bimanual tasks. Achieving 91.2% success on LIBERO-Long with a small 0.1B-parameter low-level policy is a notable result, suggesting that the sparse planning approach effectively offloads complexity from the low-level controller. The comparison against language-based, dense-video, and uniform-subgoal planners provides a comprehensive baseline analysis. The inclusion of real-world bimanual tasks (box folding, packing) with unseen object combinations demonstrates generalization capabilities beyond simulation. The observation that additional suboptimal videos and test-time compute improve success rates is a valuable empirical finding for practitioners.
The paper provides a project URL (dreamcan.github.io) which likely contains code and additional results. The methodology relies on pre-trained video models and standard dynamic programming, which are well-understood components. However, the specific adaptation of the video model for sparse subgoal generation and the estimation of reachability/utility from action-free videos may require careful implementation details that are not fully visible in the abstract. The use of offline data is a practical advantage for reproducibility in real-world settings where collecting new action data is costly.
The reliance on pre-trained video models means the system's performance is bounded by the quality and coverage of the video priors. If the video dataset does not contain examples of the specific task or object configurations, the planner may fail. The method is designed for manipulation tasks; its applicability to locomotion or other robotic domains is not discussed. The computational cost of the high-level planner (video model inference) and the dynamic programming step could be a bottleneck for real-time operation, although test-time compute scaling is mentioned as a positive factor.
This work has significant implications for the field of robot learning, particularly for long-horizon manipulation tasks. By leveraging video models as priors for planning, it offers a path towards more generalizable and data-efficient robot policies. The sparse subgoal approach is a practical solution to the "plausibility vs. executability" problem in video-based planning. This could influence future research in hierarchical reinforcement learning and the integration of generative models into robotic control loops. DreamCan introduces a hierarchical policy that uses sparse visual subgoals from video models to enable long-horizon robot manipulation. The paper presents a rigorous evaluation showing that this approach outperforms dense and uniform planning baselines, achieving high success rates in simulation and real-world bimanual tasks, thereby demonstrating the viability of video-based sparse planning for complex robotic manipulation.
Humanoid loco-manipulation is particularly challenging because it requires coordinating locomotion, balance, and object interaction, making it difficult to learn from limited demonstrations or from scratch through Reinforcement Learning (RL). We introduce DiPLO (self-distilled Diffusion Planning for Loco-manipulation), a framework that combines a self-distilled diffusion planner with a low-level whole-body tracking policy. Our planner is pretrained via supervised learning on motions derived from human-to-humanoid retargeting, while the tracker is trained via RL to execute them. DiPLO centers around two complementary post-training stages. First, we introduce Self-Distillation Diffusion Policy Optimisation (SD:DPO) to remove the planner's dependence on strong task conditioning, which we identify as a crucial ingredient for effective pretraining, as downstream fine-tuning does not recover comparable performance when it is omitted.. We then fine-tune this distilled model with Diffusion-Augmented Proximal Policy Optimization (DA:PPO), a maximum-entropy RL method for diffusion models, to improve task success and align generated plans with the frozen tracker's execution capabilities. Together, these stages enable motion generation through state-history and goal conditioning alone, enabling 99% task success in pick-carry-place tasks, compared to just 45% for the pretrained model. The resulting planner also generates motions for unseen object goals, with further evaluations on kicking and pushing/pulling tasks. Finally, we deploy our pipeline on the hardware, using our DA:PPO planner-tracker on a Unitree G1, achieving repeated successful executions without any real-world fine-tuning.
Primary: Technical University of Munich (TUM)
All Institutions: Technical University of Munich (TUM), McGill University, INRIA, Institute for Advanced Study (IAS)
DiPLO introduces a self-distilled diffusion planning framework that enables humanoid robots to perform complex loco-manipulation tasks from limited demonstrations by decoupling motion generation from execution and using a two-stage post-training process to remove dependence on kinematic references. The method demonstrates strong generalization to unseen goals and successful real-world deployment, highlighting the potential of hierarchical learning approaches for embodied AI.
The paper proposes DiPLO, a hierarchical framework for humanoid loco-manipulation that decouples high-level motion planning (diffusion model) from low-level execution (RL tracking policy). The core methodological contribution is a two-stage post-training process: (1) Self-Distillation Diffusion Policy Optimization (SD:DPO), which distills a teacher model conditioned on kinematic references into a student model conditioned only on state history and goals, effectively removing the need for explicit task priors at deployment; and (2) Diffusion-Augmented Proximal Policy Optimization (DA:PPO), which fine-tunes the distilled planner using maximum-entropy RL to align generated plans with the frozen tracker's capabilities. The use of SO(3) diffusion for rotational features is a technically sound choice that respects the manifold geometry of rotations. The separation of planning and tracking allows the planner to learn diverse motion structures from limited data while the tracker learns robust feedback control via RL, addressing the mode-covering vs. mode-seeking trade-off inherent in generative models vs. RL.
The experimental evaluation is rigorous and comprehensive. The authors provide extensive ablations on pretraining data augmentation (SBTO vs. symmetry), the importance of task conditioning during pretraining, and the specific benefits of SO(3) diffusion. They compare motion-level planning against action-level diffusion baselines (PDP, BeyondMimic), demonstrating the superiority of the hierarchical approach for survival and task success. The generalization evaluation, where the robot achieves unseen goals up to 5 meters away, is a strong indicator of the method's robustness. The real-world deployment on a Unitree G1 humanoid, achieving 100% success in pick-carry-place tasks without real-world fine-tuning, provides strong evidence of practical viability.
The paper provides detailed descriptions of the diffusion processes (VP diffusion for Euclidean features, IG_SO(3) for rotations), the DA-MDP formulation, and the training objectives. However, specific hyperparameters, network architectures (DiT details), and code availability are not explicitly provided in the text (no GitHub link found in the provided text). The reliance on specific datasets (OmniRetarget, OMOMO) and simulation environments (mjlab) may limit immediate reproducibility for those without access to these resources.
The method relies on external motion capture for object pose estimation in the real-world setup, which is a significant practical limitation for general deployment. The planning frequency is limited to ~12.5 Hz due to diffusion sampling, which may be too slow for highly dynamic tasks requiring faster replanning. The evaluation is primarily focused on pick-carry-place and similar tasks; performance on more complex, multi-object, or highly dynamic interactions is not fully explored. The dependence on a frozen tracker means that if the tracker fails, the planner cannot adapt its strategy in real-time to compensate for execution errors beyond the replanning horizon.
This work contributes to the growing field of humanoid robotics by providing a scalable method for learning complex loco-manipulation skills from limited demonstrations. The insight that strong task conditioning is useful for pretraining but can be distilled away for deployment is a valuable principle for robot learning. The combination of diffusion models for planning and RL for tracking offers a robust paradigm for handling the non-stationarity and balance constraints inherent in humanoid control. DiPLO introduces a self-distilled diffusion planning framework that enables humanoid robots to perform complex loco-manipulation tasks from limited demonstrations by decoupling motion generation from execution and using a two-stage post-training process to remove dependence on kinematic references. The method demonstrates strong generalization to unseen goals and successful real-world deployment, highlighting the potential of hierarchical learning approaches for embodied AI.
Every robot already carries high-resolution contact sensors: its own joints. Legged robots and humanoids exploit them to walk, run, and track whole-body motions without vision, but there the contacts are large and forceful. Is joint sensing also enough for precise, contact-rich assembly, where the robot must find a millimeter-scale opening, mesh gear teeth, or catch a thread through light contact? We study this question by training blind assembly policies that observe only a short history of joint positions, velocities, and their own actions, without visual, force, torque, or tactile sensing. The poses of both the fixture and the part are unknown to the policy, and the grasp is randomized substantially. The policy must therefore assemble the parts through contact, sensed exclusively through its own proprioception. Trained with reinforcement learning entirely in simulation over randomized parts, grasps, and contacts, such policies learn peg insertion, gear meshing, and nut threading. The peg insertion policy transfers zero-shot to the real world and inserts pegs of different shapes and sizes in 73% of trials. Controlled comparisons with matched visual policies in simulation show that blind policies generalize far better to unseen part shapes and sizes, though they can be slower. Training such policies needs thousands of different assemblies, each simulated with its clearance intact, so we also release an open-source generator that builds them procedurally from exact convex pieces for MuJoCo; it is more accurate and faster than convex decomposition or MuJoCo's signed-distance collision. Videos and interactive simulations are at https://younghyopark.me/blind-proprioceptive-assembly/.
Primary: Massachusetts Institute of Technology
All Institutions: Massachusetts Institute of Technology
The paper demonstrates that proprioceptive sensing alone is sufficient for precise, contact-rich robotic assembly tasks like peg insertion, gear meshing, and nut threading, achieving zero-shot sim-to-real transfer and superior generalization to unseen parts compared to visual policies. By introducing a rigorous simulation framework with exact convex collision geometry and a novel contact-supervised RL training method, the authors provide a robust, sensor-light alternative to vision-based manipulation, significantly advancing the state of the art in blind dexterity and sim-to-real transfer for precision tasks.
The paper proposes a novel approach to precise robotic assembly using only proprioceptive sensing (joint positions, velocities, and actions), explicitly excluding vision, force, torque, or tactile sensors. The core method involves training Reinforcement Learning (PPO) policies in simulation with extensive domain randomization of part geometry, grasp, and contact properties. A key technical contribution is the "contact supervision" auxiliary loss, which trains the policy's latent representation to predict contact states (free, touching, aligned) without providing privileged information to the actor, thereby accelerating learning from sparse rewards. Additionally, the authors introduce "AssemblyGen," an open-source procedural generator for MuJoCo that creates exact convex collision geometries for tight-clearance assemblies (pegs, gears, nuts), addressing a significant simulation bottleneck where standard convex decomposition or SDF methods fail to preserve sub-millimeter clearances accurately.
The experimental evaluation is rigorous and comprehensive. The authors demonstrate that blind policies achieve near-perfect success rates on in-distribution tasks and, crucially, generalize significantly better to unseen part shapes and sizes compared to matched visual policies. The zero-shot sim-to-real transfer is a strong result, with the peg insertion policy achieving 73% success on real hardware without fine-tuning, including on out-of-distribution pegs. The ablation studies effectively isolate the contribution of the contact supervision loss and the collision geometry generator. The comparison against scripted spiral search baselines highlights the efficiency of the learned reactive search strategy.
The paper provides high reproducibility standards. It releases an open-source generator for the simulation assets, which is a major barrier in this field. Detailed hyperparameters, architecture descriptions, and training ranges are provided in the appendix. The use of standard simulators (MuJoCo) and common algorithms (PPO) further aids reproducibility. The specific hardware setup (Flexiv Rizon 4S, Robotiq 2F-85) is clearly defined.
The primary limitation is the assumption that the robot starts in contact with the fixture; the policy does not handle the initial approach phase from a distance. The behavior is local and cannot recover from large deviations (e.g., if the part slips out of the grasp). The real-world evaluation is limited to peg insertion; gear meshing and nut threading were only validated in simulation. The reliance on precise simulation of friction and contact dynamics, despite domain randomization, remains a potential source of sim-to-real gap for other tasks.
This work challenges the prevailing assumption that precise manipulation requires vision or force sensing. By demonstrating that proprioception alone is sufficient for millimeter-scale assembly, it opens new avenues for robust, low-cost robotic systems that do not require expensive sensors or complex calibration. The released simulation tools will likely benefit the broader robotics community working on contact-rich tasks. The finding that blind policies generalize better to unseen geometries than visual policies is a significant insight for the design of robust manipulation policies. The paper demonstrates that proprioceptive sensing alone is sufficient for precise, contact-rich robotic assembly tasks like peg insertion, gear meshing, and nut threading, achieving zero-shot sim-to-real transfer and superior generalization to unseen parts compared to visual policies. By introducing a rigorous simulation framework with exact convex collision geometry and a novel contact-supervised RL training method, the authors provide a robust, sensor-light alternative to vision-based manipulation, significantly advancing the state of the art in blind dexterity and sim-to-real transfer for precision tasks.
We introduce REKI, a 2.4B vision-language-action model (VLA) pretrained exclusively on public data that sets a new Pareto frontier between performance and model size: on LIBERO-Plus, RoboTwin Clean2Rand and RoboCasa365, it is outperformed only by models about twice its size. REKI consists of a vision-language model (VLM) followed by a flow-matching action expert, and is pretrained on a curated mixture of public robot, egocentric human and vision-language data. Additionally, we endow it with a memory that gives the policy access to its recent past at negligible cost: a few register tokens in the action expert summarise the output of the VLM at each frame and persist in the expert's cache. This memory improves success in simulation and on real robots, and makes oscillations between poses about four times rarer. REKI uses a simple model design and training paradigm, and is optimised to be efficient at training and inference. We release the full code across data curation, training, inference and evaluation, deployment, and all pretrained and finetuned model weights: https://github.com/kyutai-labs/reki.
Primary: Kyutai
All Institutions: Kyutai
REKI introduces an efficient 2.4B VLA model with a novel register-token memory mechanism that achieves state-of-the-art performance on key robotics benchmarks while maintaining a small model size. The combination of flow-matching action experts, public-data pretraining, and a lightweight temporal memory strategy provides a robust and reproducible baseline that advances the field of vision-language-action modeling by balancing performance with computational efficiency.
The paper proposes REKI, a 2.4B parameter Vision-Language-Action (VLA) model. The architecture consists of a standard Vision-Language Model (VLM) backbone followed by a flow-matching action expert. The primary methodological contribution is the introduction of a lightweight memory mechanism using "register tokens" within the action expert. These tokens summarize the VLM's output at each frame and persist in the expert's cache, allowing the policy to access recent history with negligible computational overhead. The model is pretrained on a curated mixture of public robot, egocentric human, and vision-language data. The approach is notable for its efficiency and the specific design choice of using register tokens for temporal context rather than heavier recurrent or transformer-based memory blocks.
The evaluation is conducted on standard robotics benchmarks: LIBERO-Plus, RoboTwin Clean2Rand, and RoboCasa365. The paper claims REKI sets a new Pareto frontier, outperforming models of similar size and being outperformed only by models approximately twice its size. Specific empirical findings include a four-fold reduction in pose oscillations due to the memory mechanism. The inclusion of real-robot evaluation strengthens the claims, though the full text provided is largely a structural outline, so specific numerical comparisons must be inferred from the abstract's strong claims.
The paper explicitly states that full code for data curation, training, inference, evaluation, deployment, and all pretrained/finetuned weights are released. This high level of open-sourcing significantly enhances reproducibility and community utility.
The provided text is a preprint skeleton with section headers but lacks the detailed body text for rigorous scrutiny of specific ablation studies or failure cases. The reliance on "public data" may limit performance compared to models trained on proprietary, high-quality datasets, though the paper argues for efficiency. The "register token" memory is described as having "negligible cost," but the exact latency trade-offs in high-frequency control loops need verification in the full text.
By providing a strong, efficient baseline that is fully open-sourced, REKI lowers the barrier to entry for VLA research. The memory mechanism could be adopted by other architectures to improve temporal consistency in robotic control. The focus on public data pretraining is significant for democratizing access to capable robot policies. REKI introduces an efficient 2.4B VLA model with a novel register-token memory mechanism that achieves state-of-the-art performance on key robotics benchmarks while maintaining a small model size. The combination of flow-matching action experts, public-data pretraining, and a lightweight temporal memory strategy provides a robust and reproducible baseline that advances the field of vision-language-action modeling by balancing performance with computational efficiency.