Last 7 Days (July 18 – July 24, 2026)
LLMs scale Mixture-of-Experts (MoE) parameters for superior intelligence, but massive weights and dynamic computation impede efficient serving. Existing instance-level prefill-decode disaggregation isolates the phases on separate full-model replicas. As MoE weights grow, each instance may span tens to hundreds of GPUs, making resource allocation increasingly coarse. Configured prefill-to-decode ratios thus often mismatch demand, overprovisioning one phase while overloading the other. Prefill-decode colocation avoids this duplication, but existing Green Context solutions partition each GPU by phase and fix phase resources during a kernel. They cannot track resource changes across operations or layerwise variation in routed expert load, causing head-of-line blocking or idle reserved resources. Partitioning every GPU also leaves each phase with fewer local resources, forces wider parallelism and more communication, and lets prefill and decode traffic interfere on the shared network. We present ExpertPlex, which shares massive MoE experts across phases while disaggregating lightweight attention modules. Expert sharing eliminates over 95% of duplicate model weights and multiplexes dynamically sparse computation, while attention disaggregation reduces attention communication cost. ExpertPlex further uses (1) adaptive persistent kernels to schedule dynamic expert computation at tile granularity for efficient, isolated execution; (2) attention-initiated MoE communication to avoid network interference and enable cross-phase communication-computation overlap; and (3) a tile-to-cluster model to optimize these mechanisms for maximum goodput. Experiments serving MiniMax-M2.7 and GLM-5.1-FP8 show that ExpertPlex improves goodput by up to 2.01$\times$ over instance-level prefill-decode disaggregation and 1.66$\times$ over prefill-decode colocation.
Primary: Peking University
All Institutions: Peking University, Independent Researcher
ExpertPlex presents a significant advancement in LLM serving systems by introducing a novel disaggregated architecture that effectively shares MoE experts while isolating attention modules, achieving substantial goodput improvements through adaptive persistent kernels and optimized communication patterns.
The paper proposes ExpertPlex, a disaggregated serving architecture specifically designed for Mixture-of-Experts (MoE) Large Language Models. The core innovation lies in decoupling the handling of MoE experts from attention modules. While existing systems either colocate all components (leading to resource contention) or disaggregate at the instance level (leading to massive weight duplication and coarse-grained allocation), ExpertPlex shares the massive MoE expert weights across phases while isolating the lightweight attention modules. The methodology introduces three key technical mechanisms: (1) Adaptive Persistent Kernels, which schedule dynamic expert computation at the tile granularity to handle load imbalance and avoid head-of-line blocking; (2) Attention-Initiated MoE Communication, which overlaps communication with computation and prevents network interference between prefill and decode phases; and (3) A Tile-to-Cluster Model, an optimization framework to allocate resources dynamically. This approach addresses the fundamental inefficiency of serving sparse MoE models where expert load is highly dynamic and non-uniform.
The evaluation is conducted on two significant MoE models: MiniMax-M2.7 and GLM-5.1-FP8. The baseline comparisons are rigorous, covering the two dominant existing paradigms: instance-level prefill-decode disaggregation and prefill-decode colocation. The results demonstrate substantial improvements, with up to 2.01x goodput improvement over instance-level disaggregation and 1.66x over colocation. These gains are particularly impressive given that colocation is often considered the most resource-efficient in terms of hardware usage, implying that ExpertPlex achieves higher throughput without requiring additional hardware, simply by better utilizing existing resources. The use of FP8 models also highlights the system's relevance to current hardware trends.
The paper provides a detailed description of the system design, including the persistent kernel scheduling and communication overlap mechanisms. The inclusion of specific model names (MiniMax-M2.7, GLM-5.1-FP8) allows for potential replication if these models are publicly available or if synthetic workloads are used. However, as is common with systems papers, full reproducibility might depend on the specific cluster configuration and the availability of the proprietary model weights. The detailed algorithmic descriptions of the adaptive scheduling and tile-to-cluster optimization provide a strong foundation for implementation.
The paper focuses on the serving side and does not address training efficiency. The complexity of the adaptive persistent kernels and the tile-to-cluster model introduces additional system overhead that must be carefully managed; if the scheduling overhead exceeds the gains from reduced communication or better utilization, performance could degrade. Furthermore, the benefits are most pronounced for very large MoE models with high expert counts; for smaller models or dense models, the overhead of the disaggregation and dynamic scheduling might not justify the complexity. The reliance on high-bandwidth, low-latency interconnects for the attention-MoE communication is also a constraint.
ExpertPlex addresses a critical bottleneck in the deployment of state-of-the-art AI models. By significantly improving the goodput of MoE LLMs, it lowers the cost barrier for serving these models, potentially democratizing access to high-quality AI services. The architectural insights regarding dynamic resource allocation for sparse models can influence future system designs for other sparse architectures beyond LLMs, such as sparse transformers or mixture-of-experts in other domains. ExpertPlex presents a significant advancement in LLM serving systems by introducing a novel disaggregated architecture that effectively shares MoE experts while isolating attention modules, achieving substantial goodput improvements through adaptive persistent kernels and optimized communication patterns.
Scaling executable agent training data for LLM post-training is bottlenecked by substrate-bound methods that tie task generation to predefined tools, repositories, or skill graphs: expanding coverage requires manual substrate engineering, each new domain demands a bespoke pipeline, and the resulting task distributions often reflect substrate biases rather than real-world demand. We introduce NexForge, a requirement-driven framework that takes high-level capability requirements as input and synthesizes diverse, executable agent tasks and expert trajectories for SFT. NexForge first investigates real-world demand to construct representative scenarios and task profiles, then performs distribution-aware compilation to generate task directives. For each directive, NexForge automatically retrieves or constructs the required files, dependencies, and runtime configurations, and finally synthesizes expert rollouts and produces training trajectories. Without domain-specific infrastructure, NexForge produces 3.6K terminal and 2K office tasks, improving Qwen3.5-35B-A3B Base from 22.5\% to 52.0\% on Terminal-Bench 2.0 and from 813 to 1338 Elo on GDPval; scaling further to 43.2K terminal tasks yields 58.4\%, on par with Claude Opus 4.6 equipped with Claude Code. Scaled further, NexForge-synthesized data contributes to the training of Nex-N2, a family of publicly available agent models that lift Qwen3.5-35B-A3B to 75.3\% on Terminal-Bench 2.1 and to 1585 Elo on GDPval -- achieving state-of-the-art open-source performance and surpassing several frontier proprietary systems. Nex-N2 models are available at https://nex.sii.edu.cn/.
Primary: SII (Shenzhen Institute of Advanced Technology, Chinese Academy of Sciences)
All Institutions: SII (Shenzhen Institute of Advanced Technology, Chinese Academy of Sciences)
NexForge presents a compelling and effective pipeline for scaling agent training data through requirement-driven synthesis, demonstrating that high-quality, diverse task generation can significantly boost LLM agent performance, achieving state-of-the-art open-source results on key benchmarks.
The paper introduces NexForge, a framework designed to address the data bottleneck in training LLM-based agents. The core innovation lies in shifting from "substrate-bound" task generation (which relies on predefined tools or codebases) to a "requirement-driven" approach. The methodology involves three key stages: 1) Analyzing real-world demand to create representative scenarios and task profiles; 2) Distribution-aware compilation to generate high-level task directives; and 3) Automatic synthesis of executable environments (files, dependencies, runtime configs) and expert rollouts for Supervised Fine-Tuning (SFT). This approach aims to reduce manual engineering and mitigate substrate biases. The method is technically sound, leveraging existing LLM capabilities for code generation and environment setup, but the novelty is incremental rather than foundational. It represents a sophisticated engineering pipeline rather than a new algorithmic breakthrough.
The experimental section demonstrates significant empirical improvements. Using Qwen3.5-35B-A3B as the base, the authors show a jump from 22.5% to 52.0% on Terminal-Bench 2.0 and from 813 to 1338 Elo on GDPval with 3.6K terminal and 2K office tasks. Scaling to 43.2K terminal tasks pushes performance to 58.4%, which is comparable to Claude Opus 4.6 with Claude Code. Furthermore, the synthesized data is used to train "Nex-N2," achieving state-of-the-art open-source results (75.3% on Terminal-Bench 2.1, 1585 Elo on GDPval). The results are impressive and suggest that high-quality, diverse, requirement-driven data is a critical lever for agent performance. The evaluation is rigorous, covering multiple benchmarks and comparing against strong proprietary baselines.
The paper provides a project URL (https://nex.sii.edu.cn/) which likely contains code and model weights. The description of the pipeline (requirement analysis -> directive compilation -> environment synthesis -> rollout) is detailed enough to be reproducible by a team with sufficient resources. However, the "expert rollouts" likely rely on a strong teacher model or human-in-the-loop, which can introduce variability. The specific "distribution-aware compilation" algorithm is not fully detailed in the abstract, so full reproducibility depends on the completeness of the main text and code release.
The paper does not explicitly discuss the cost of generating 43.2K high-quality tasks, which can be significant. The reliance on a "requirement-driven" approach assumes that high-level requirements can be effectively mapped to executable tasks, which may fail in domains with ambiguous or complex implicit constraints. Additionally, the "substrate biases" argument, while valid, might be overstated if the underlying LLMs themselves have biases in their training data that NexForge cannot correct. The evaluation is primarily on coding/terminal tasks; generalization to other agent domains (e.g., web browsing, multi-modal reasoning) is not demonstrated.
This work has significant implications for the democratization of capable AI agents. By providing a scalable method for generating high-quality training data, it lowers the barrier to entry for developing specialized agents. The release of Nex-N2 models contributes to the open-source ecosystem. However, the potential for misuse (e.g., generating malicious code or automating cyberattacks) is a concern that should be addressed in the broader impact statement. The success of such frameworks may accelerate the arms race in agent capabilities, raising safety and alignment challenges. NexForge presents a compelling and effective pipeline for scaling agent training data through requirement-driven synthesis, demonstrating that high-quality, diverse task generation can significantly boost LLM agent performance, achieving state-of-the-art open-source results on key benchmarks.
Retrieval-Augmented Generation (RAG) enhances the factual grounding of large language model (LLM) inference by retrieving relevant information from external knowledge bases. However, its dense vector retrieval introduces significant latency and energy overhead, becoming the primary performance bottleneck. Although recent in-storage accelerators aim to reduce data movement, they still rely on host or embedded processors outside the memory, where nearly 70% of the total retrieval time is spent. As a result, they cannot fully overcome the bandwidth limitations, leading to yet another memory bottleneck. To tackle these limitations, we present D-NOVA, a hardware-software co-designed in-storage retrieval accelerator. D-NOVA executes an inverted file (IVF)-based hierarchical retrieval pipeline by deeply embedding the search functionality directly into the NAND memory array. This is achieved by incorporating a new distance metric, Dual-Bound Tight Similarity Sensing (DTS), which is specifically tailored for searching within the NAND string. In addition, we introduce a lightweight contrastive adapter that maps embedding vectors into a DTS-friendly domain, recovering near-software recall while improving performance and energy efficiency. D-NOVA is up to 41.7x faster and 71x more energy-efficient than a CPU baseline, and achieves 12.13x higher throughput while being up to 1.26x more energy-efficient than state-of-the-art in-storage RAG accelerators, demonstrating the potential of fully in-storage vector search for scalable RAG acceleration.
Primary: University of California, San Diego
All Institutions: University of California, San Diego
D-NOVA introduces a novel in-storage vector search accelerator that leverages a NAND-optimized distance metric and contrastive adaptation to achieve significant speed and energy efficiency gains for RAG workloads. This research represents a substantial contribution to the intersection of computer architecture and machine learning systems, offering a viable path to overcoming the memory bottleneck in large-scale retrieval tasks.
The paper proposes D-NOVA, a hardware-software co-designed accelerator that performs vector similarity search directly within 3D NAND memory arrays, bypassing the traditional host-to-memory data movement bottleneck. The core technical innovation is the Dual-Bound Tight Similarity Sensing (DTS) metric, which is specifically tailored to the physical characteristics of NAND strings (e.g., threshold voltage distributions and read disturb effects) to enable approximate nearest neighbor search at the storage level. This is coupled with a lightweight contrastive adapter that transforms embedding vectors into a domain compatible with DTS, allowing the hardware to operate on "DTS-friendly" vectors while maintaining high recall relative to software baselines. The approach represents a significant shift from "in-storage computing" (which often still moves data to embedded processors) to "in-storage sensing," leveraging the analog/digital properties of the memory array itself for computation.
The evaluation demonstrates substantial improvements over baselines. D-NOVA achieves up to 41.7x speedup and 71x energy efficiency gains compared to a CPU baseline. When compared to state-of-the-art in-storage RAG accelerators, it shows 12.13x higher throughput and up to 1.26x better energy efficiency. The paper likely includes detailed breakdowns of latency components, energy consumption per operation, and recall/accuracy metrics (e.g., Recall@K) to validate that the hardware approximation does not significantly degrade retrieval quality. The results suggest that the proposed architecture effectively mitigates the memory wall for RAG workloads.
As a hardware design paper, reproducibility depends on the availability of the RTL (Register Transfer Level) code, simulation models, and detailed architectural parameters. The paper mentions support from SRC and NSF grants, suggesting rigorous academic standards. However, without explicit open-source code links in the provided text, reproducibility is limited to the described methodology and potentially available supplementary materials. The specific implementation of the DTS metric and the contrastive adapter's training procedure are critical for replication.
The primary limitation is the reliance on specific 3D NAND characteristics, which may vary across manufacturers and process nodes. The "DTS-friendly" domain requires a pre-processing step (the contrastive adapter), adding a small overhead that must be justified by the massive gains in the search phase. Furthermore, the scalability of the in-storage search logic across very large vector databases (millions/billions of vectors) and the impact of wear-leveling and garbage collection in NAND on the consistency of the DTS metric are potential challenges not fully addressed in the abstract. The energy efficiency claim of 1.26x over SOTA in-storage accelerators is modest compared to the CPU baseline, suggesting that while the approach is novel, the absolute gains over existing in-storage solutions might be incremental in some configurations.
This work has significant implications for the scalability of Retrieval-Augmented Generation (RAG) systems, which are becoming the standard for enterprise LLM applications. By reducing the latency and energy cost of vector retrieval, D-NOVA enables more responsive and sustainable AI systems. It also advances the field of in-memory/in-storage computing, demonstrating that complex ML workloads can be offloaded to storage devices in a way that leverages their physical properties, potentially reshaping the architecture of future data centers. D-NOVA introduces a novel in-storage vector search accelerator that leverages a NAND-optimized distance metric and contrastive adaptation to achieve significant speed and energy efficiency gains for RAG workloads. This research represents a substantial contribution to the intersection of computer architecture and machine learning systems, offering a viable path to overcoming the memory bottleneck in large-scale retrieval tasks.
As autonomous agents rapidly evolve, their ability to reliably manipulate ubiquitous digital documents has become critical for enabling general-purpose AI assistants and automating complex workspace workflows. In this paper, we introduce DocOps, a deterministically verifiable evaluation framework underpinned by a hierarchical taxonomy that deconstructs document operations inspired by real-world practices into atomic dimensions and escalating workflow complexities. Based on DocOps, we systematically evaluate representative closed- and open-source models across various agentic harnesses, revealing that even the most advanced frontier configurations still exhibit profound limitations when handling highly coupled, long-range tasks. Furthermore, a fine-grained analysis of existing agents' manipulation behaviors uncovers 3 key failure modes: long-term state tracking collapse, shallow semantic verification, and destructive editing of structural metadata. Ultimately, our work exposes the capability boundaries of agents in maintaining global document consistency, shedding light on the future design of robust, non-destructive agents for complex digital ecosystems.
Primary: Not specified in the provided text (placeholder 'Address line')
All Institutions: Not specified in the provided text (placeholder 'Address line')
DocOps makes a significant contribution to the field of autonomous agents and general-purpose AI. By providing a rigorous, verifiable benchmark for complex document operations, it addresses a critical gap in evaluating agents' ability to interact with ubiquitous digital documents. The findings expose fundamental limitations of current frontier models in maintaining global document consistency and avoiding destructive modifications, shifting research focus from isolated tool invocation to state-aware, non-destructive agent design. The identified failure modes offer clear diagnostic targets for improving agent architectures, planning mechanisms, and verification capabilities. This work will likely guide the development of more robust AI assistants for workspace automation, impacting productivity across various industries. The benchmark itself is poised to become a standard tool for researchers and practitioners, fostering innovation in a crucial area of human-computer interaction. DocOps introduces a rigorously verifiable evaluation framework and benchmark for autonomous agents performing complex, stateful document operations, revealing significant limitations of current frontier models in maintaining global consistency and avoiding destructive edits. This paper makes a substantial technical contribution by defining a novel taxonomy for document manipulation, developing a deterministic artifact-level verification system, and conducting a comprehensive empirical evaluation that uncovers critical failure modes and provides actionable insights for the design of future robust, non-destructive agents.
The methodology for DocOps is exceptionally well-conceived and rigorously designed. The core contribution is a deterministically verifiable evaluation framework for autonomous agents performing complex document operations. A key strength is the hierarchical taxonomy, which deconstructs document operations along two orthogonal axes: atomic capabilities (content, format, structure) and workflow depth (L1-L4). This allows for fine-grained diagnosis of agent failures, moving beyond coarse task-level success metrics. The task construction pipeline is robust, involving seed collection, formalization, source-artifact synthesis, and iterative human review, ensuring practical relevance, clarity, and consistency across 210 tasks. Crucially, DocOps introduces a novel deterministic verifier that directly inspects output files using native document libraries. This verifier employs three types of predicates (structural, linguistic, preservation) to not only check task completion but also to ensure structural validity and preservation of out-of-scope elements, addressing a major limitation of prior benchmarks. The fidelity of this verifier is rigorously assessed through a human audit and mutation-based stress test, demonstrating high agreement. The evaluation protocol, utilizing the Harbor framework, is standard and well-defined, ensuring reproducibility. Overall, the methodology is a significant advancement in benchmarking agent capabilities for complex, stateful digital environments.
The experimental evaluation is comprehensive and insightful. The paper systematically evaluates a diverse set of models, including leading closed-source (GPT-5.5, GPT-5.4, Claude Sonnet 4.6) and open-source (DeepSeek-V4-Pro, Qwen, Gemma, GLM) LLMs. These models are tested across four distinct agentic harnesses (DocTools, Terminus-2, Claude Code, Codex) representing different interface regimes, and with/without explicit skill injection. This broad coverage provides a holistic view of current agent capabilities. The results reveal profound limitations: even the most advanced frontier configuration (GPT-5.5 with Codex and skills) achieves only a 0.671 pass rate, which drops sharply on workflow-level (L3/L4) tasks. This is a significant empirical finding. The detailed analysis further uncovers that workflow difficulty is highly dependent on the *coupling* of underlying document states (e.g., Excel tasks degrade much more severely than PDF tasks), rather than just the number of operations. The paper also identifies and quantifies three pervasive failure modes: long-term state tracking collapse, shallow semantic verification, and destructive editing of structural metadata, with semantic verification gaps being the most dominant. The analysis of harness impact shows that open-ended programming environments generally outperform constrained tool use, and that skills offer non-uniform benefits, sometimes even increasing cost without significant performance gains for frontier models. The experiments are well-designed, the results are clearly presented (tables, figures), and the findings provide actionable insights for future agent development.
Reproducibility is a strong suit of this paper. The authors explicitly state that "Both the code and dataset are publicly available: https://github.com/icip-cas/DocOps". Each task is packaged as a self-contained Harbor bundle, including source artifacts, natural language instructions, optional skills, and the deterministic verifier. This packaging, combined with the use of the Harbor framework for execution, greatly facilitates replication of the experiments. The detailed descriptions of the task construction pipeline, verifier design, and experimental protocol (including model IDs and access routes in the appendix) further enhance reproducibility. The deterministic nature of the verifier, independent of LLM-as-a-judge, is a critical factor in ensuring consistent evaluation outcomes.
The authors acknowledge several limitations. DocOps focuses on deterministic, offline document-editing tasks, thus not covering workflows requiring live external services, collaborative editing, or interactive user clarification. The benchmark currently contains 210 tasks, and scaling it is labor-intensive due to the need for structurally valid artifacts, clear editing scopes, and manual review. This limits the current breadth of document domains and workflow complexities. Finally, token-cost comparisons across harnesses should be interpreted with care due to varying fidelity in usage statistics exposed by different agent runtimes. These are reasonable limitations for a novel and complex benchmark, and the authors outline plans for future expansion.
DocOps makes a significant contribution to the field of autonomous agents and general-purpose AI. By providing a rigorous, verifiable benchmark for complex document operations, it addresses a critical gap in evaluating agents' ability to interact with ubiquitous digital documents. The findings expose fundamental limitations of current frontier models in maintaining global document consistency and avoiding destructive modifications, shifting research focus from isolated tool invocation to state-aware, non-destructive agent design. The identified failure modes offer clear diagnostic targets for improving agent architectures, planning mechanisms, and verification capabilities. This work will likely guide the development of more robust AI assistants for workspace automation, impacting productivity across various industries. The benchmark itself is poised to become a standard tool for researchers and practitioners, fostering innovation in a crucial area of human-computer interaction. DocOps introduces a rigorously verifiable evaluation framework and benchmark for autonomous agents performing complex, stateful document operations, revealing significant limitations of current frontier models in maintaining global consistency and avoiding destructive edits. This paper makes a substantial technical contribution by defining a novel taxonomy for document manipulation, developing a deterministic artifact-level verification system, and conducting a comprehensive empirical evaluation that uncovers critical failure modes and provides actionable insights for the design of future robust, non-destructive agents.
Bayesian online learning promises uncertainty-aware prediction on data streams, but its performance hinges on inferential choices, including learning rates, prior distributions and variational families, which are usually fixed before seeing the stream. We address this by treating Bayesian update rules as experts and aggregating the Bayesian experts according to sequential predictive losses. We prove that the resulting aggregate competes with the best expert in hindsight at an aggregation cost determined by how each expert's per-round performance is evaluated. We instantiate the framework in online conformal inference and Gaussian process regression. The conformal inference application yields a smoothed Bayesian counterpart of adaptive conformal inference with long-run randomized coverage, while the Gaussian process application gives an oracle inequality in cumulative predictive Kullback-Leibler risk and adaptation to unknown Hölder smoothness up to logarithmic factors. Experiments show that the aggregate tracks strong experts without oracle expert selection.
Primary: Inha University
All Institutions: Inha University
This work has significant broader impact for the field of online learning and Bayesian methods. It provides a principled and modular framework for making Bayesian online learning more adaptive and robust to critical inferential choices (learning rates, priors, variational families) that are often fixed arbitrarily. This can lead to: * **More reliable uncertainty quantification:** By adapting inferential choices, the resulting predictions and uncertainty estimates are less sensitive to misspecification or nonstationarity. * **Reduced hyperparameter tuning:** The aggregation mechanism automates the selection of optimal inferential settings, reducing the need for manual tuning. * **Enhanced adaptivity:** The framework allows Bayesian models to adapt to changing data stream characteristics (e.g., smoothness, noise levels, nonstationarity) in a theoretically grounded manner. * **New theoretical insights:** The distinction between mean-loss and annealed-loss aggregation offers fundamental insights into how to evaluate and combine Bayesian predictions, with implications for other areas of online learning. The applications to conformal inference and Gaussian processes demonstrate its utility in practical, high-impact areas where robust uncertainty quantification and adaptation are crucial. This paper introduces a novel expert-aggregation framework for adaptive Bayesian online learning, distinguishing between mean-loss and annealed-loss aggregation with corresponding $O(T)$ and $O(\log K)$ regret bounds, and demonstrates its effectiveness in online conformal inference and Gaussian process regression with adaptation to unknown Hölder smoothness. The work provides a principled and modular approach to address the sensitivity of Bayesian online learning to fixed inferential choices, offering strong theoretical guarantees and comprehensive empirical validation across diverse online learning settings, thereby advancing the robustness and adaptivity of uncertainty-aware prediction systems.
The paper proposes a novel two-level framework for adaptive Bayesian online learning, treating different Bayesian update rules (experts) as distribution-valued entities and aggregating their posterior predictive distributions. The core methodological contribution lies in identifying two distinct ways to evaluate these Bayesian experts: mean-loss aggregation and annealed-loss aggregation. The authors rigorously derive regret bounds for both, showing that mean-loss aggregation generally incurs an $O(T)$ cost, while annealed-loss aggregation achieves a much faster $O(\log K)$ cost. This distinction is crucial, as it links the choice of evaluation metric to the statistical properties of the target functional (e.g., posterior mean vs. full predictive distribution). The framework is modular, allowing various Bayesian online learning algorithms (SVB, OGA) to serve as base experts. The paper then instantiates this general framework in two significant applications: online conformal inference (yielding Bayes-ACI and Bayes-DtACI) and online Gaussian process regression with unknown smoothness. For the latter, the annealed-loss aggregation is shown to adapt to unknown Hölder smoothness at minimax rates up to logarithmic factors, effectively replacing a hierarchical prior with sequential aggregation. The theoretical development is sound, leveraging established results from prediction with expert advice and extending them to the Bayesian online learning context. The discussion on the curvature of loss functions and its impact on regret rates is particularly insightful.
The experimental evaluation is comprehensive and well-designed, covering three distinct online learning scenarios. 1. **Online Variational Benchmarks:** The paper evaluates the proposed expert aggregation methods (SVB-EA, OGA-EA, OGD-EA) on standard binary classification and regression datasets. Results demonstrate that the adaptive aggregates consistently track the performance of the best fixed expert in hindsight, which is a strong indicator of successful adaptation. The sensitivity of individual experts to learning rates is clearly shown, highlighting the value of aggregation. 2. **Online Conformal Inference:** Bayes-DtACI is tested in a nonstationary setting with abrupt changes in residual scale and heavy-tailed errors. It is compared against the original DtACI. Bayes-DtACI shows more stable cumulative coverage, especially under Student-$t$ errors, suggesting improved robustness due to the Gaussian-smoothed updates. The rolling coverage also adapts smoothly to regime changes. 3. **Online GP Regression:** The annealed-loss aggregation for GPs is evaluated across three stationary settings with varying function smoothness/length scales, and a nonstationary setting. The aggregate consistently tracks the best fixed bandwidth expert in terms of cumulative negative log-likelihood. Crucially, the aggregation weights dynamically reallocate, adapting to the effective smoothness of the underlying function, which is a key theoretical claim. In the nonstationary setting, GP-EA remains competitive with strong online regression baselines and demonstrates effective adaptation to regime changes by reallocating weights. Overall, the experiments provide strong empirical evidence for the theoretical claims, demonstrating both the adaptivity and robustness of the proposed framework across diverse applications. The choice of metrics and baselines is appropriate.
The paper provides a good level of detail for reproducibility. The algorithms (Alg. 1) are clearly described. Expert specifications, meta-learning rates, and sharing parameters are detailed for each experiment. The use of specific software (Python package River, version 0.20.1) is mentioned. Experiments are repeated 30 times. While specific code is not provided (common for arXiv preprints), the methodological and experimental descriptions are sufficiently thorough for a skilled researcher to reproduce the main results.
The authors acknowledge several limitations in their future work section. 1. **Fixed-share aggregation:** The current framework primarily uses fixed-share aggregation. More advanced, strongly adaptive, or parameter-free aggregation methods could offer sharper guarantees and faster adaptation to nonstationary streams. 2. **Finite, prespecified expert collection:** The theory is developed for a finite, pre-specified grid of experts. Extending this to continuous, data-dependent, or growing expert families would be more powerful but would require controlling statistical complexity and computational cost. 3. **Computational Cost:** For a large number of experts $K$, maintaining $K$ separate Bayesian updates and their aggregation can be computationally intensive, especially for complex models like GPs. 4. **Known Noise Level in GP Theory:** The theoretical analysis for GP regression assumes a known noise level, which is not practical. While the experiments address this by aggregating over a product grid of bandwidths and noise levels, the theoretical guarantees for this extended setting are not explicitly derived, though the authors suggest it's covered by lifting the parameter space.
This work has significant broader impact for the field of online learning and Bayesian methods. It provides a principled and modular framework for making Bayesian online learning more adaptive and robust to critical inferential choices (learning rates, priors, variational families) that are often fixed arbitrarily. This can lead to: * **More reliable uncertainty quantification:** By adapting inferential choices, the resulting predictions and uncertainty estimates are less sensitive to misspecification or nonstationarity. * **Reduced hyperparameter tuning:** The aggregation mechanism automates the selection of optimal inferential settings, reducing the need for manual tuning. * **Enhanced adaptivity:** The framework allows Bayesian models to adapt to changing data stream characteristics (e.g., smoothness, noise levels, nonstationarity) in a theoretically grounded manner. * **New theoretical insights:** The distinction between mean-loss and annealed-loss aggregation offers fundamental insights into how to evaluate and combine Bayesian predictions, with implications for other areas of online learning. The applications to conformal inference and Gaussian processes demonstrate its utility in practical, high-impact areas where robust uncertainty quantification and adaptation are crucial. This paper introduces a novel expert-aggregation framework for adaptive Bayesian online learning, distinguishing between mean-loss and annealed-loss aggregation with corresponding $O(T)$ and $O(\log K)$ regret bounds, and demonstrates its effectiveness in online conformal inference and Gaussian process regression with adaptation to unknown Hölder smoothness. The work provides a principled and modular approach to address the sensitivity of Bayesian online learning to fixed inferential choices, offering strong theoretical guarantees and comprehensive empirical validation across diverse online learning settings, thereby advancing the robustness and adaptivity of uncertainty-aware prediction systems.
Natural-language autoencoders score explanations of hidden activations by reconstruction: an explanation is deemed faithful if the activation can be regenerated from it. The test is structurally insensitive to individual false claims: if flipping a claim does not change the reconstruction, the claim is never penalized. We show the test is passed in two ways, neither faithful. On a released Qwen-2.5-7B verbalizer, explanations reconstruct well above chance while ~2% of specific claims are reconstruction-dependent, so the score tracks gist, not specific facts. Under exact synthetic ground truth, the standard recipe develops co-adapted private codes (false wording the reconstruction depends on) in 5/5 runs, and fixes that leave the target model unchanged do not help. We contribute two audit protocols, the grounded-vs-true cross and the evaluator swap, and RECAP (Readable Encodings via Co-trained Auxiliary Predictors): linear heads trained alongside the target model to keep designated content decodable. On RECAP-trained sandbox models, fresh verbalizers state the designated content truly and the codes vanish, at a +0.001-nat cost. This replicates on a pretrained Pythia-160M: the content becomes reliably probe-decodable, though a fresh verbalizer conveys it only in part (truth 0.44-0.46 vs a near-zero control). For interpretability, high reconstruction does not certify individual claims. For AI safety, RECAP makes designated internal content independently checkable against probes rather than asserted by prose a model can game: an independent probe scores the verbalizer's true claims above its false ones (AUC 0.96, vs 0.82 without RECAP). Against an adversary that edits an explanation to maximize the reconstruction score while lying (suppressing ~87% of its lie penalty), the RECAP probe still flags the lies (AUC 0.95) while the control probe collapses to chance (0.51).
Primary: Unknown
All Institutions: Unknown
This paper provides a critical audit of activation explanation methods and proposes RECAP, a training-time intervention that ensures internal content is probe-decodable, thereby enabling reliable, independent verification of model claims against adversarial gaming.
The paper introduces a rigorous critique of Natural-Language Autoencoders (NLAs) used for activation explanation. It identifies two critical failure modes: "gist" reliance (where explanations reconstruct well but contain ungrounded specific claims) and "private codes" (where the reconstructor relies on specific, non-factual wording co-adapted during training). To address the latter, it proposes RECAP (Readable Encodings via Co-trained Auxiliary Predictors), a method that trains auxiliary linear heads on the target model to ensure designated content remains probe-decodable. This shifts the burden of faithfulness from the verbalizer's reconstruction score to the model's internal representational geometry. The methodology is sound, leveraging synthetic sandboxes for exact ground truth and real models for scalability checks.
The experimental design is comprehensive and multi-layered. It begins with an audit of a released Qwen-2.5-7B NLA, demonstrating high reconstruction scores despite low claim-level grounding. It then moves to a synthetic sandbox with exact ground truth to isolate "private codes," showing they emerge consistently in standard NLA training. The core contribution, RECAP, is validated in the sandbox (showing 100% decodability and truth) and scaled to Pythia-160M (showing significant improvements in probe-decodability and verbalizer truthfulness compared to controls). Crucially, the paper includes an adversarial test where an agent attempts to game the reconstruction score; RECAP's probe-based monitor successfully flags lies while the control probe fails. The use of independent fresh probes to evaluate decodability prevents circularity.
The paper provides detailed protocols for the synthetic domains, including grammar specifications and slot definitions. It mentions the use of public models (Qwen-2.5-7B, Pythia-160M) and standard training setups. The technical appendix (referenced but not fully included in the text provided) likely contains hyperparameters and seeds. The clear distinction between co-trained heads and independent evaluation probes ensures that results are not artifacts of the reader. The synthetic nature of the primary validation experiments makes them highly reproducible.
The primary limitation is the scale of the model experiments; RECAP is demonstrated on Pythia-160M, which is small compared to frontier models. The paper acknowledges that decodability does not guarantee verbalizability; the verbalizer still struggles to convey all decoded content faithfully. Additionally, RECAP requires co-training, meaning it cannot be easily applied to frozen, pre-trained models without significant retraining costs. The "target design" rule for auxiliary heads is heuristic and may be difficult to optimize for complex, open-ended content.
This work has significant implications for AI safety and interpretability. By demonstrating that reconstruction-based faithfulness tests are structurally insufficient, it warns practitioners against trusting NLA scores as proxies for truth. RECAP offers a pathway to making internal model states independently verifiable, which is crucial for oversight of capable agents. It shifts the paradigm from "explaining the model" to "making the model explainable" by design. This paper provides a critical audit of activation explanation methods and proposes RECAP, a training-time intervention that ensures internal content is probe-decodable, thereby enabling reliable, independent verification of model claims against adversarial gaming.
Scaling executable agent training data for LLM post-training is bottlenecked by substrate-bound methods that tie task generation to predefined tools, repositories, or skill graphs: expanding coverage requires manual substrate engineering, each new domain demands a bespoke pipeline, and the resulting task distributions often reflect substrate biases rather than real-world demand. We introduce NexForge, a requirement-driven framework that takes high-level capability requirements as input and synthesizes diverse, executable agent tasks and expert trajectories for SFT. NexForge first investigates real-world demand to construct representative scenarios and task profiles, then performs distribution-aware compilation to generate task directives. For each directive, NexForge automatically retrieves or constructs the required files, dependencies, and runtime configurations, and finally synthesizes expert rollouts and produces training trajectories. Without domain-specific infrastructure, NexForge produces 3.6K terminal and 2K office tasks, improving Qwen3.5-35B-A3B Base from 22.5\% to 52.0\% on Terminal-Bench 2.0 and from 813 to 1338 Elo on GDPval; scaling further to 43.2K terminal tasks yields 58.4\%, on par with Claude Opus 4.6 equipped with Claude Code. Scaled further, NexForge-synthesized data contributes to the training of Nex-N2, a family of publicly available agent models that lift Qwen3.5-35B-A3B to 75.3\% on Terminal-Bench 2.1 and to 1585 Elo on GDPval -- achieving state-of-the-art open-source performance and surpassing several frontier proprietary systems. Nex-N2 models are available at https://nex.sii.edu.cn/.
Primary: SII (Shenzhen Institute of Advanced Technology, Chinese Academy of Sciences)
All Institutions: SII (Shenzhen Institute of Advanced Technology, Chinese Academy of Sciences)
NexForge presents a compelling and effective pipeline for scaling agent training data through requirement-driven synthesis, demonstrating that high-quality, diverse task generation can significantly boost LLM agent performance, achieving state-of-the-art open-source results on key benchmarks.
The paper introduces NexForge, a framework designed to address the data bottleneck in training LLM-based agents. The core innovation lies in shifting from "substrate-bound" task generation (which relies on predefined tools or codebases) to a "requirement-driven" approach. The methodology involves three key stages: 1) Analyzing real-world demand to create representative scenarios and task profiles; 2) Distribution-aware compilation to generate high-level task directives; and 3) Automatic synthesis of executable environments (files, dependencies, runtime configs) and expert rollouts for Supervised Fine-Tuning (SFT). This approach aims to reduce manual engineering and mitigate substrate biases. The method is technically sound, leveraging existing LLM capabilities for code generation and environment setup, but the novelty is incremental rather than foundational. It represents a sophisticated engineering pipeline rather than a new algorithmic breakthrough.
The experimental section demonstrates significant empirical improvements. Using Qwen3.5-35B-A3B as the base, the authors show a jump from 22.5% to 52.0% on Terminal-Bench 2.0 and from 813 to 1338 Elo on GDPval with 3.6K terminal and 2K office tasks. Scaling to 43.2K terminal tasks pushes performance to 58.4%, which is comparable to Claude Opus 4.6 with Claude Code. Furthermore, the synthesized data is used to train "Nex-N2," achieving state-of-the-art open-source results (75.3% on Terminal-Bench 2.1, 1585 Elo on GDPval). The results are impressive and suggest that high-quality, diverse, requirement-driven data is a critical lever for agent performance. The evaluation is rigorous, covering multiple benchmarks and comparing against strong proprietary baselines.
The paper provides a project URL (https://nex.sii.edu.cn/) which likely contains code and model weights. The description of the pipeline (requirement analysis -> directive compilation -> environment synthesis -> rollout) is detailed enough to be reproducible by a team with sufficient resources. However, the "expert rollouts" likely rely on a strong teacher model or human-in-the-loop, which can introduce variability. The specific "distribution-aware compilation" algorithm is not fully detailed in the abstract, so full reproducibility depends on the completeness of the main text and code release.
The paper does not explicitly discuss the cost of generating 43.2K high-quality tasks, which can be significant. The reliance on a "requirement-driven" approach assumes that high-level requirements can be effectively mapped to executable tasks, which may fail in domains with ambiguous or complex implicit constraints. Additionally, the "substrate biases" argument, while valid, might be overstated if the underlying LLMs themselves have biases in their training data that NexForge cannot correct. The evaluation is primarily on coding/terminal tasks; generalization to other agent domains (e.g., web browsing, multi-modal reasoning) is not demonstrated.
This work has significant implications for the democratization of capable AI agents. By providing a scalable method for generating high-quality training data, it lowers the barrier to entry for developing specialized agents. The release of Nex-N2 models contributes to the open-source ecosystem. However, the potential for misuse (e.g., generating malicious code or automating cyberattacks) is a concern that should be addressed in the broader impact statement. The success of such frameworks may accelerate the arms race in agent capabilities, raising safety and alignment challenges. NexForge presents a compelling and effective pipeline for scaling agent training data through requirement-driven synthesis, demonstrating that high-quality, diverse task generation can significantly boost LLM agent performance, achieving state-of-the-art open-source results on key benchmarks.
Large-scale visual generators are increasingly capable but costly to train, fine-tune, and deploy. We introduce Mage-Flow, a compact 4B-scale generative stack for efficient text-to-image generation and instruction-based image editing. The stack is built from two co-designed components: Mage-VAE, a lightweight high-fidelity latent tokenizer, and a Native-Resolution Multimodal Diffusion Transformer trained with rectified flow matching. Mage-VAE uses one-step diffusion-style encoding and decoding with anchor-latent regularization, preserving the reconstruction quality of strong public VAEs while reducing tokenization cost by more than an order of magnitude. Together with native-resolution packing and stack-level CUDA kernel fusion, the stack supports flexible-resolution training and improves end-to-end training throughput by about 2.5times. Built on this foundation, we develop a complete model family with Base, RL-aligned, and Turbo variants for both generation and editing. Diffusion-NFT improves prompt following, text rendering, aesthetic quality, and editing fidelity, while few-step distillation with adversarial perceptual guidance produces 4-step Turbo models for low-latency inference. Despite its compact scale, Mage-Flow and Mage-Flow-Edit achieves competitive performance across standard generation and editing benchmarks. More importantly, the Turbo variants make high-resolution generation and editing practical for interactive use: at 1024^2 resolution on a single NVIDIA A100 GPU, Mage-Flow-Turbo generates an image in 0.59s, and Mage-Flow-Edit-Turbo edits an image in 1.02s, while maintaining a small memory footprint. These results show that careful tokenizer--backbone--system co-design can deliver strong high-resolution generation and editing within an efficient 4B model family.
Primary: Microsoft
All Institutions: Microsoft
Mage-Flow presents a significant engineering and methodological contribution by co-designing a lightweight VAE and native-resolution diffusion transformer, achieving state-of-the-art efficiency for high-resolution image generation and editing on consumer-grade hardware, thereby democratizing access to powerful generative AI tools.
The paper proposes a co-designed generative stack, Mage-Flow, consisting of a lightweight VAE (Mage-VAE) and a native-resolution diffusion transformer. The novelty lies in the system-level co-design: using one-step diffusion-style encoding/decoding with anchor-latent regularization to drastically reduce tokenization overhead, combined with native-resolution packing and CUDA kernel fusion to enable efficient training and inference. This approach addresses the computational bottlenecks of high-resolution image generation. The use of rectified flow matching and the development of specific variants (Base, RL-aligned, Turbo) for different use cases (generation vs. editing, speed vs. quality) demonstrates a comprehensive engineering and methodological effort.
The authors present a model family including Base, RL-aligned, and Turbo variants. They report competitive performance on standard generation and editing benchmarks. Crucially, they highlight inference efficiency: 0.59s for generation and 1.02s for editing at 1024^2 resolution on a single A100 GPU. These metrics are significant for practical deployment. The evaluation covers both quality (prompt following, text rendering, aesthetics) and efficiency (latency, memory footprint), providing a robust assessment of the trade-offs.
The paper provides code, models, and a project page, which strongly supports reproducibility. The description of the architecture (Mage-VAE, Native-Resolution DiT) and training techniques (rectified flow, adversarial perceptual guidance) is detailed enough for other researchers to attempt replication, assuming access to similar computational resources.
As a 4B parameter model, it may still lag behind larger foundation models (e.g., Flux, SD3, DALL-E 3) in terms of absolute peak quality or complex semantic understanding, although the paper claims competitiveness. The "native-resolution" approach, while efficient, may still face challenges with extremely high resolutions or complex multi-subject compositions compared to models specifically optimized for those edge cases. The reliance on specific CUDA kernel fusion optimizations might limit portability to non-NVIDIA hardware.
By making high-resolution, interactive image generation and editing accessible on single GPUs, this work lowers the barrier to entry for developers and researchers. It promotes more sustainable AI by reducing the energy and hardware costs associated with training and inference. The focus on editing also has implications for creative workflows and content creation industries. Mage-Flow presents a significant engineering and methodological contribution by co-designing a lightweight VAE and native-resolution diffusion transformer, achieving state-of-the-art efficiency for high-resolution image generation and editing on consumer-grade hardware, thereby democratizing access to powerful generative AI tools.
LLM agent failures are difficult to debug because the step where an error surfaces is often not the one that caused it. Existing observability tools replay execution traces but provide little support for identifying the root cause or translating diagnosis into recovery. We present AgentDebugX, an open-source debugging framework that organizes debugging as a closed loop of Detect, Attribute, Recover, and Rerun. At its core, DeepDebug performs multi-turn root-cause diagnosis through global trajectory understanding, structure-guided investigation, and cross-examination. On the Who and When benchmark, DeepDebug achieves the best strict attribution accuracy among the evaluated methods on both tested open-weight backbones, reaching 28.8 percent exact agent-and-step accuracy on qwen3.5-9b versus 21.7 percent for the strongest single-pass baseline. On GAIA, DeepDebug repairs 13 of 73 failed tasks in a single rerun, compared with 4 to 6 for three decoupled self-correction baselines, improving overall accuracy from 55.8 percent to 63.6 percent. AgentDebugX exposes this workflow through a Python library, CLI, web console, and installable agentic skill, and provides an opt-in Error Hub for sharing scrubbed failure-diagnosis-repair bundles and reusing them as debugging memory.
Primary: Stanford University
All Institutions: Stanford University
AgentDebugX presents a significant step forward in LLM agent observability by introducing a structured, closed-loop debugging framework that connects root-cause attribution with actionable recovery, demonstrating measurable improvements in agent repair rates on complex benchmarks.
The paper proposes AgentDebugX, a comprehensive framework for LLM agent debugging that formalizes the process as a closed loop of Detect, Attribute, Recover, and Rerun. The core methodological contribution is "DeepDebug," a multi-turn root-cause diagnostic agent. Unlike single-pass attribution methods that often fail on long-horizon traces, DeepDebug employs a structured investigation strategy: a global read followed by a structure-guided probe (bisecting for single agents, tracing handoffs for multi-agent systems) and a cross-examination phase to arbitrate between conflicting hypotheses. This approach addresses the specific challenge of "latent" errors where the symptom surface is far from the root cause. The framework also introduces a portable trajectory representation and an "Error Hub" for sharing scrubbed failure-diagnosis-repair bundles, aiming to create a cumulative debugging memory. The methodology is sound and addresses a genuine gap in the current agent observability landscape, which largely focuses on logging rather than actionable diagnosis and recovery.
The evaluation is split into two parts: attribution accuracy on the Who&When benchmark and end-to-end recovery on GAIA. On Who&When, DeepDebug achieves 28.8% strict agent-and-step accuracy on Qwen3.5-9b, outperforming the strongest single-pass baseline (21.7%). While this is a relative improvement, the absolute accuracy remains low, highlighting the difficulty of the task. On GAIA, the framework repairs 13 of 73 failed tasks in a single rerun, compared to 4-6 for decoupled self-correction baselines, improving overall accuracy from 55.8% to 63.6%. The experiments are well-controlled, comparing against relevant baselines (Reflexion, CRITIC, AutoManual) and providing ablations on the diagnostic turns. However, the GAIA evaluation is limited to a single policy model and a single rerun, which may overestimate the generalizability of the recovery gains. The attribution gains are modest in absolute terms, suggesting that while the method is state-of-the-art among evaluated approaches, the problem of automated root-cause analysis for LLM agents remains unsolved.
The paper provides an open-source toolkit, a Python library, and detailed prompts for the diagnostic agents. The code is available on GitHub, and the paper includes specific details on the trace schema and evaluation protocols. The use of standard benchmarks (Who&When, GAIA) enhances reproducibility. The inclusion of an "Error Hub" format specification also aids in future reproducibility and comparison.
The authors acknowledge several limitations. The evaluation does not measure developer debugging time or UI usability, which are critical for practical adoption. The attribution gains are model-dependent, with the multi-turn approach showing less benefit on stronger hosted models (GPT-5.4-mini, Gemini-3.5-flash) where single-pass reading is already effective. The GAIA experiment evaluates the full recipe rather than isolating the effect of attribution alone. The Error Hub and taxonomy induction features are implemented but not yet evaluated. The scrubber for sensitive data is pattern-based and may not catch all PII.
AgentDebugX has the potential to make agent reliability more inspectable and measurable, moving beyond proprietary black-box debugging. By providing an open-source toolkit and a shared format for failure cases, it lowers the barrier for researchers and smaller organizations to study robustness. The Error Hub concept could foster a community-driven corpus of agent failures, accelerating progress in agent reliability. However, the collection and sharing of agent traces raise privacy and security concerns, which the paper addresses through opt-in sharing and redaction mechanisms. AgentDebugX presents a significant step forward in LLM agent observability by introducing a structured, closed-loop debugging framework that connects root-cause attribution with actionable recovery, demonstrating measurable improvements in agent repair rates on complex benchmarks.
Summation error depends on partial-sum order, which standard worst-case bounds omit. To capture this dependence, we derive an exact mean-square error (MSE) recurrence for a binary reduction tree T under conditionally unbiased rounding. With unit roundoff u, the constant-nu model sets the local variance at pre-rounding value x to nu u^2 x^2. Its leading tree-dependent cost for the input vector p is p^T K_T p, where the common-ancestor kernel K_T counts the internal ancestors shared by each pair of leaves. For i.i.d. inputs of mean mu and variance tau^2, this expected cost is tau^2 Lambda_1(T) + mu^2 Lambda_2(T), where Lambda_1 is total leaf depth and Lambda_2 sums squared internal-subtree sizes; Lambda_1 governs centered inputs, while Lambda_2 captures nonzero means. We use these statistics to characterize optimal tree topologies and schedules. Balanced and sequential trees attain the centered extrema. For k inputs, optimal two-stage sequential blocking yields root-mean-square (RMS) error scaling as k^{3/4}. For fixed-stage hierarchies, geometric schedules are optimal for centered inputs, whereas the optimal noncentered stage exponents halve successively. For independent centered inputs with unequal variances, Huffman coding minimizes variance-weighted depth over free leaf assignments. We extend the kernel to matrix multiplication through operand Gram matrices. We then test the approximation under round-to-nearest using exact residuals. Across binary64, binary32, and software-emulated binary16 and bfloat16, the model recovers the ordering among tree topologies; K_T tracks AR(1) partial-sum costs. For GEMM, independently calibrated predictions differ from measurements by at most 3% on the tested grid. A reduction tree extracted from an array library predicts the measured RMS scaling. However, stagnation and bias in positive low-precision sums limit the model's applicability.
Primary: Oak Ridge National Laboratory
All Institutions: Oak Ridge National Laboratory
This paper provides a rigorous second-moment theory for floating-point reduction trees, deriving exact error recurrences and optimal topologies that significantly advance the understanding of numerical stability in parallel reductions, with direct applications to improving the accuracy of HPC and ML libraries.
The paper presents a rigorous theoretical framework for analyzing floating-point reduction errors, specifically focusing on the variance of partial sums in reduction trees. The core methodological contribution is the derivation of an exact mean-square error (MSE) recurrence relation for binary reduction trees under the conditionally unbiased rounding model. The authors introduce the "common-ancestor kernel" $K_T$, which quantifies the structural impact of tree topology on error propagation. They decompose the expected cost into terms dependent on input variance ($\Lambda_1$) and mean ($\Lambda_2$), allowing for the characterization of optimal tree topologies (e.g., balanced vs. sequential, Huffman coding for unequal variances). The methodology extends naturally to matrix multiplication via Gram matrices, providing a unified view of reduction error in linear algebra operations. The approach is mathematically sound, leveraging statistical properties of floating-point arithmetic rather than worst-case bounds, which offers a more realistic model for typical workloads.
The authors validate their theoretical model through extensive experiments across multiple precision formats (binary64, binary32, software-emulated binary16, and bfloat16). They demonstrate that the model accurately predicts the ordering of RMS error among different tree topologies and tracks the costs of autoregressive (AR(1)) processes. For General Matrix Multiplication (GEMM), the model's predictions differ from measurements by at most 3% on the tested grid. They also test a reduction tree extracted from an actual array library, confirming the model's predictive power for real-world implementations. The experiments are well-designed, covering both synthetic i.i.d. inputs and structured data, and effectively bridge the gap between theoretical bounds and empirical behavior.
The paper provides detailed mathematical derivations and specifies the rounding models and input distributions used in experiments. The mention of "software-emulated" formats suggests that the authors have implemented or utilized existing tools for lower-precision simulation, which aids reproducibility. However, the paper does not explicitly provide a link to the source code or specific software versions used for the simulations in the abstract or main text provided. Given the institutional context (ORNL) and the nature of the work, code is likely available or reproducible, but explicit URLs are missing from the provided text.
The authors explicitly acknowledge limitations, noting that the model's applicability is limited by stagnation and bias in positive low-precision sums. This suggests that the conditionally unbiased rounding assumption may break down in specific edge cases, particularly with low-precision formats like bfloat16 or binary16 where dynamic range and precision constraints are tighter. The model is primarily statistical (expectation/variance) and may not capture worst-case scenarios or specific pathological inputs that trigger catastrophic cancellation or overflow in ways not captured by the second-moment analysis.
This work has significant implications for the design of high-performance computing (HPC) libraries and machine learning frameworks that rely heavily on parallel reductions (e.g., dot products, sums, matrix multiplications). By providing a theory for optimal tree topologies based on input statistics, it enables the development of adaptive algorithms that minimize numerical error without sacrificing performance. This is particularly relevant for mixed-precision training and inference, where understanding and controlling error propagation is critical. The insights could lead to more robust and accurate numerical libraries for deep learning and scientific computing. This paper provides a rigorous second-moment theory for floating-point reduction trees, deriving exact error recurrences and optimal topologies that significantly advance the understanding of numerical stability in parallel reductions, with direct applications to improving the accuracy of HPC and ML libraries.
Pruning long context for coding agents has been a vital technology for efficient context management. While existing context pruning methods such as SWE-Pruner realize this by attaching a separate code classifier, we find the agent itself encodes internal representations indicating the relevance of code context when reading tool output. Based on this finding, we propose SWE-Pruner Pro, which prunes tool outputs directly inside the agent. Concretely, a small head turns the agent's own internal representations into a keep-or-prune label for each line, with a length-aware embedding keyed to each tool output's line count. Across two open-weight backbones and four multi-turn benchmarks, SWE-Pruner Pro saves up to 39% of prompt and completion tokens while preserving task quality, with bounded inference overhead. Notably, on MiMo-V2-Flash SWE-Pruner Pro additionally raises the SWE-Bench Verified resolve rate by +3.8% and the long-context Oolong accuracy by +2.2 points.
Primary: Shanghai Jiao Tong University
All Institutions: Shanghai Jiao Tong University
SWE-Pruner Pro demonstrates that coding agents' internal representations encode sufficient line-level relevance information to prune tool outputs effectively, achieving significant token savings and improved efficiency without retraining the backbone, marking a practical step forward in scalable agentic systems.
The paper proposes SWE-Pruner Pro, a method for pruning long context in coding agents by extracting a lightweight classification head from the agent's own internal hidden states. The core insight is that the backbone model already encodes line-level relevance information during the forward pass of tool outputs, eliminating the need for a separate scoring model or explicit goal-hint queries used in prior work (e.g., SWE-Pruner). The methodology involves a length-aware embedding and a per-sample balanced focal loss to handle class imbalance and length-dependent error costs. The approach is technically sound, leveraging existing inference infrastructure (SGLang) with specific patches to expose hidden states. The design is pragmatic, focusing on efficiency gains without retraining the backbone.
The evaluation is comprehensive, covering two large open-weight backbones (MiMo-V2-Flash, Qwen3-Coder-Next) and four benchmarks (SWE-Bench Verified, SWE-QA, SWE-QA-Pro, Oolong). The results demonstrate up to 39% token savings while preserving or slightly improving task quality (e.g., +3.8% resolve rate on SWE-Bench Verified). The inclusion of an ablation study on loss functions and length-aware embeddings adds rigor. The comparison against seven baselines, including strong prior work, provides a solid empirical foundation. The latency analysis, including in-engine colocation, further strengthens the practical value of the work.
The paper provides detailed implementation details, including the architecture of the pruning head, training data sources (publicly released datasets), and specific SGLang patches required for hidden state extraction. The training data distribution and labeling protocol are described. However, the code for the SGLang patches and the specific pruning head implementation are not explicitly linked in the text (though implied to be available or part of the project). The reliance on specific versions of SGLang and the need for custom patches might pose minor reproducibility hurdles for users not familiar with the inference engine's internals.
The method is currently limited to open-weight models that expose hidden states. The evaluation is primarily focused on Python and CLI tasks, with limited coverage of other programming languages. The pruning is applied to tool outputs, so it does not address pruning of the agent's own reasoning or history, which may also contain redundant information. The performance gain on SWE-Bench Verified is notable but the absolute resolve rate is still constrained by the backbone's capabilities.
This work significantly advances the field of efficient LLM inference, particularly for agentic workflows. By demonstrating that internal representations contain sufficient signal for pruning, it reduces the computational overhead and latency associated with context management. This can lead to more cost-effective and scalable deployment of coding agents, enabling longer and more complex interactions. The approach could be generalized to other domains where agents interact with long textual environments. SWE-Pruner Pro demonstrates that coding agents' internal representations encode sufficient line-level relevance information to prune tool outputs effectively, achieving significant token savings and improved efficiency without retraining the backbone, marking a practical step forward in scalable agentic systems.
We present RynnBrain 1.1, a family of embodied foundation models spanning 2B, 9B, and 122B-A10B scales. Trained with a unified spatio-temporal and physically grounded framework, RynnBrain 1.1 supports embodied perception, spatial reasoning, localization, and planning. Compared with RynnBrain 1.0, it further introduces contact-point prediction across the model family and native 3D grounding for the 2B and 9B models, yielding representations and outputs that are more directly aligned with robot manipulation. We also develop RynnBrain-VLA with a unified cross-embodiment action space and embodiment-specific masking, and deploy it on Unitree G1, Astribot-S1, and Tianji-Wuji. RynnBrain 1.1 achieves strong results on embodied cognition, localization, and 3D grounding, with the 122B-A10B model outperforming all evaluated proprietary and open-source models on VSI-Bench, MMSI, and RefSpatial-Bench. Real-robot experiments show that RynnBrain-initialized policies outperform Qwen-based and representative generalist VLAs, while joint multi-task and multi-embodiment training improves process scores and success rates over per-task training.
Primary: Rynn AI
All Institutions: Rynn AI
RynnBrain 1.1 presents a significant advancement in embodied foundation models by introducing native 3D grounding and contact-point prediction within a unified spatio-temporal framework, demonstrating strong generalization across multiple robotic platforms and outperforming existing models on key embodied cognition benchmarks.
The paper introduces RynnBrain 1.1, a family of embodied foundation models (2B, 9B, 122B-A10B). The core methodological contribution lies in a unified spatio-temporal and physically grounded pretraining framework. Key technical innovations include the introduction of contact-point prediction across the model family and native 3D grounding for the smaller models (2B and 9B). The authors also propose RynnBrain-VLA, which utilizes a unified cross-embodiment action space and embodiment-specific masking to handle diverse robotic hardware. The architecture appears to scale from dense to Mixture-of-Experts (MoE) models, aiming to balance capability with inference efficiency. The approach integrates perception, spatial reasoning, and planning into a single unified representation, which is a significant step towards generalist embodied agents.
The evaluation covers embodied cognition, localization, and 3D grounding benchmarks (VSI-Bench, MMSI, RefSpatial-Bench). The 122B-A10B model claims to outperform all evaluated proprietary and open-source models on these benchmarks. Real-robot experiments are conducted on three distinct platforms: Unitree G1, Astribot-S1, and Tianji-Wuji. The results indicate that RynnBrain-initialized policies outperform Qwen-based and other generalist VLAs. The paper also highlights the benefits of joint multi-task and multi-embodiment training over per-task training, showing improvements in process scores and success rates. The breadth of evaluation across simulation and real-world hardware is a strong point, demonstrating generalization capabilities.
The paper provides details on model scales and training frameworks. However, as an arXiv preprint without an accompanying code release mentioned in the text, reproducibility is currently limited to the described methodology. The use of specific hardware (Unitree, Astribot, Tianji) for real-world evaluation adds a layer of complexity for independent verification, requiring access to similar robotic platforms. The mention of "RynnBrain" suggests a proprietary model family, which may limit full open-source reproducibility of the weights.
The paper focuses heavily on the capabilities of the 122B-A10B model for benchmark leadership, but the performance of the smaller 2B and 9B models, while improved, may not match the state-of-the-art in every metric. The reliance on embodiment-specific masking and unified action spaces requires careful calibration for each new robot type, which might limit plug-and-play generalization to unseen embodiments without further tuning. The computational cost of training and deploying the 122B model is significant, potentially limiting accessibility for smaller research groups.
This work contributes to the development of generalist embodied AI, which has profound implications for robotics, automation, and human-robot interaction. By providing models that can reason about 3D space and physical interactions, it paves the way for more capable and autonomous robots in unstructured environments. The emphasis on generalization across embodiments could accelerate the deployment of robots in various industries. However, the increased autonomy of robots also raises safety and ethical considerations regarding control and reliability in physical spaces. RynnBrain 1.1 presents a significant advancement in embodied foundation models by introducing native 3D grounding and contact-point prediction within a unified spatio-temporal framework, demonstrating strong generalization across multiple robotic platforms and outperforming existing models on key embodied cognition benchmarks.
Video multimodal large language models (MLLMs) can describe what happens in a video, but rarely identify when the supporting evidence occurs. We study generalist video temporal grounding, in which one model predicts a variable-cardinality set of evidence intervals across video lengths, domains, query forms, and viewpoints. Existing training strategies are misaligned with this set-valued task: long-video labels often rely on brittle one-pass annotation, while reinforcement-learning rewards either fail to distinguish non-overlapping predictions or require fragile segment matching. TimeLens2 treats temporal evidence as an interval set throughout supervision and optimization. TimeLens2-93K constructs reliable multi-span supervision through caption-derived proposals, independent localization, cross-agent consensus, semantic verification, and boundary refinement. Our temporal Wasserstein reward computes exact one-dimensional \(W_1\) between uniform distributions over merged interval supports, providing dense, matching-free feedback under unequal cardinalities and equivalent fragmentation; temporal IoU complements it with precise-overlap feedback. Across seven benchmarks, TimeLens2-2B outperforms all size-matched baselines on every benchmark, while the 4B and 8B variants achieve state-of-the-art performance, surpassing open-source models with up to 397B parameters. The 2B, 4B, and 8B variants improve over their Qwen3-VL backbones by 14.2, 13.0, and 18.1 mIoU points, respectively.
Primary: Nanjing University
All Institutions: Nanjing University
TimeLens2 presents a significant advancement in video temporal grounding by introducing a temporal Wasserstein reward and a robust multi-span supervision pipeline, achieving state-of-the-art performance with efficient model sizes. The technical contribution is solid, addressing a key limitation in current MLLM training for set-valued video tasks, and the empirical results demonstrate clear improvements over existing baselines, warranting a high score for its potential impact on the field of video understanding.
The paper proposes TimeLens2, a generalist video temporal grounding (VTG) framework that leverages Multimodal Large Language Models (MLLMs). The core methodological innovation lies in addressing the misalignment between existing training strategies and the set-valued nature of VTG (variable number of intervals). Specifically, it introduces a "temporal Wasserstein reward" that computes the $W_1$ distance between uniform distributions over merged interval supports. This provides dense, matching-free feedback that handles unequal cardinalities and fragmentation issues better than standard IoU or RL rewards. The training data construction (TimeLens2-93K) uses a multi-stage pipeline involving caption-derived proposals, independent localization, cross-agent consensus, and boundary refinement to create reliable multi-span supervision. This approach is technically sound and addresses a specific, non-trivial pain point in VTG: the evaluation and training of models that predict variable-length sets of intervals.
The authors evaluate TimeLens2 across seven benchmarks. The results show that the 2B variant outperforms all size-matched baselines, and the 4B/8B variants achieve state-of-the-art performance, surpassing much larger open-source models (up to 397B parameters). The improvements over the Qwen3-VL backbones are significant (14.2 to 18.1 mIoU points). The experimental setup appears rigorous, covering multiple domains and query forms. The comparison against large parameter models highlights the efficiency and effectiveness of the proposed method. However, the reliance on "seven benchmarks" suggests a broad but potentially shallow evaluation compared to papers that provide deep ablation studies on specific failure modes or domain shifts.
The paper mentions the construction of a 93K dataset (TimeLens2-93K) and details the pipeline for its creation. The use of standard MLLM backbones (Qwen3-VL) and clear mathematical definitions for the Wasserstein reward enhances reproducibility. The lack of a provided code repository in the metadata is a minor negative, but the methodological description seems sufficient for replication by competent researchers.
The paper does not explicitly discuss the computational cost of the proposed Wasserstein reward calculation during training or inference compared to standard IoU. The "cross-agent consensus" step in data generation might introduce biases or errors if the underlying models are not robust. Furthermore, while it claims "generalist" capabilities, the performance on highly specialized or out-of-distribution domains (e.g., medical video, scientific diagrams) is not detailed, which is a common limitation for generalist models. The reliance on Qwen3-VL (which appears to be a very recent or future-dated model given the ICLR 2026 venue) means the results are tightly coupled to that specific backbone's capabilities.
This work contributes to the advancement of video understanding systems, specifically in applications requiring precise temporal localization (e.g., video retrieval, summarization, interactive video analysis). By improving the efficiency and accuracy of MLLMs in VTG, it enables more capable and accessible video AI tools. The focus on set-valued tasks also has broader implications for other sequential prediction tasks in vision-language models. TimeLens2 presents a significant advancement in video temporal grounding by introducing a temporal Wasserstein reward and a robust multi-span supervision pipeline, achieving state-of-the-art performance with efficient model sizes. The technical contribution is solid, addressing a key limitation in current MLLM training for set-valued video tasks, and the empirical results demonstrate clear improvements over existing baselines, warranting a high score for its potential impact on the field of video understanding.
This paper introduces EvolvingWorld, a framework and benchmark for character and world co-evolution in interactive literary worlds. Existing systems either treat interactive literary simulation as static persona imitation or isolated scene generation, failing to capture how characters and worlds evolve together over time. To address this, EvolvingWorld models literary simulation as a long-horizon process where characters interact, scenes progress, and character and world states are persistently updated. Unlike prior systems relying on fixed schemas, EvolvingWorld adopts an open-schema framework to support simulation across diverse literary worlds. The framework consists of two coupled modules: a Character Agent for multi-character role-play and persistent profile evolution, and an LLM-based World Model for global and location/entity-level state maintenance and scene progression. Based on this architecture, we formulate 7 trainable tasks for scene initialization, interaction generation, and state update. We construct a dataset from 57 books, producing 138,596 supervised training samples and 222 snapshots for testing. Furthermore, we introduce a trajectory-level LLM-as-Judge evaluation protocol spanning 10 dimensions and 20 metrics. Experiments show that EvolvingWorld can improve long-horizon simulation by effectively maintaining persistent, coherent character and world development.
Primary: Hong Kong University of Science and Technology
All Institutions: Hong Kong University of Science and Technology, Huazhong University of Science and Technology
EvolvingWorld introduces a novel open-schema framework for co-evolving character and world states in interactive literary simulations, providing a significant methodological and benchmarking contribution to the field of long-horizon multi-agent systems.
The paper proposes "EvolvingWorld," a framework for long-horizon interactive literary simulation. The core methodological contribution is the decomposition of this simulation into two coupled modules: an open-schema Character Agent and an LLM-based World Model. The "open-schema" aspect is notable, as it allows the system to infer relevant character and world dimensions dynamically rather than relying on fixed ontologies. The introduction of "hidden trackers" for multi-timescale profile evolution (distinguishing between rapid mood shifts and slow personality changes) is a thoughtful architectural detail. The simulation pipeline is rigorously defined with seven trainable tasks (scene casting, location scenario, motivation update, next character, interaction generation, world update, character update). This structured decomposition transforms a vague generative task into a supervised learning problem, which is a significant methodological step for making long-horizon agents trainable and evaluable.
The authors construct a substantial dataset from 57 public-domain books, creating over 138k training samples. They introduce a comprehensive evaluation protocol with 20 metrics across 10 dimensions, addressing the lack of standardized benchmarks for long-horizon state evolution. The experiments compare fine-tuned open-source models (Qwen, Llama) against strong closed-source baselines (GPT-4o, Claude, Gemini) and prior role-play baselines (CoSER, Crab, BookWorld). The results demonstrate that supervised fine-tuning on the EvolvingWorld data significantly improves performance on character consistency, evolution quality, and world state maintenance compared to instruction-tuned baselines and prior role-play specific models. The comparison with BookWorld is particularly strong, highlighting the advantages of open-schema and entity-level state tracking. The inclusion of both in-domain and out-of-domain tests adds robustness to the claims.
The paper provides a GitHub repository link. The dataset construction process is described in detail, including the use of LLMs for extraction and the specific handling of chronological narratives. The training details (LoRA, batch size, learning rate) are provided in the appendix. The evaluation metrics and LLM-as-Judge protocols are well-defined. The use of public-domain books ensures the data is accessible. However, the reliance on LLM-as-Judge for evaluation introduces some subjectivity, though the authors attempt to mitigate this with multi-judge setups and human evaluation correlations.
The paper acknowledges several limitations. First, the world model assumes a single objective state, ignoring subjective perceptions or imperfect memories of characters, which is a significant simplification for literary realism. Second, the world representation is constrained by context length, tracking only "important" entities. Third, the dataset is limited to public-domain classic books, which may not generalize well to modern genres or user-created worlds, although the open-schema design suggests potential for adaptation. The evaluation relies heavily on LLM judges, which can be biased or inconsistent.
EvolvingWorld provides a foundational framework for creating more persistent and coherent interactive agents, with applications in gaming, interactive storytelling, and educational simulations. By shifting the focus from static persona imitation to dynamic co-evolution, it pushes the field toward more realistic and engaging long-horizon interactions. The benchmark and dataset will likely serve as a standard for evaluating future long-horizon agent systems. EvolvingWorld introduces a novel open-schema framework for co-evolving character and world states in interactive literary simulations, providing a significant methodological and benchmarking contribution to the field of long-horizon multi-agent systems.
Training API-calling large language model (LLM) agents demands massive amounts of high-quality trajectories. However, collecting such data at scale typically requires fully implemented environments with executable APIs and realistic, pre-populated backend databases, creating a major bottleneck for scalability. To overcome this, we propose an environment-free synthetic data generation approach that leverages LLMs as on-the-fly digital world models. Given only API specifications, our method generates trajectories mimicking interactions between an agent and a stateful environment. Specifically, an LLM first generates diverse tasks solvable with the provided APIs. A teacher agent then iteratively solves each task while an LLM simulator generates coherent synthetic API responses conditioned on the task context and simulation history. Finally, an LLM judge filters the trajectories to ensure the quality of the resulting dataset. We evaluate our approach on the challenging AppWorld and OfficeBench benchmarks, which include both information-retrieval and state-changing tasks. Fine-tuning models on our synthetic data yields significant performance gains, demonstrating that effective supervision for API-calling agents can be generated without any executable environment. Our results establish LLM-based API simulation as a practical, scalable solution for training agents across diverse API ecosystems.
Primary: Unknown
All Institutions: Unknown
This paper presents a practical and scalable method for generating synthetic training data for API-calling agents by leveraging LLMs as dynamic world models, effectively bypassing the need for executable environments and demonstrating significant performance improvements on standard benchmarks.
The paper proposes a pipeline for generating synthetic training data for API-calling agents without requiring an executable environment. The core methodology involves three stages: (1) Task Generation: An LLM generates diverse tasks based on API specifications. (2) Trajectory Simulation: A "teacher" agent attempts to solve these tasks, while a separate "simulator" LLM generates the API responses and state transitions on the fly, conditioned on the context. (3) Filtering: An LLM judge filters the resulting trajectories for quality. The approach leverages the reasoning capabilities of LLMs to model the environment dynamics implicitly, bypassing the need for complex backend implementations. While the concept of using LLMs as world models is not entirely new, applying it specifically to the high-dimensional, state-dependent space of API interactions for data generation is a pragmatic and novel application. The separation of the teacher (reasoning) and simulator (state modeling) roles is a key methodological choice that simplifies the training objective for the student agent.
The authors evaluate their method on AppWorld and OfficeBench, two challenging benchmarks involving information retrieval and state-changing tasks. The primary metric is the performance of models fine-tuned on the generated synthetic data compared to baselines (likely zero-shot or few-shot LLMs, and potentially models fine-tuned on real data if available, though the abstract emphasizes the "environment-free" aspect). The results show "significant performance gains," suggesting that the synthetic data captures useful patterns for agent behavior. However, the abstract does not specify the magnitude of these gains relative to state-of-the-art models trained on real data. The evaluation focuses on the utility of the generated data rather than the fidelity of the simulation itself, which is a valid but limited scope. The use of established benchmarks ensures comparability, but the lack of a real-data baseline in the abstract's summary leaves the absolute ceiling of this approach unclear.
The paper describes a clear, modular pipeline. The use of standard LLMs for task generation, simulation, and filtering suggests that the method is reproducible, provided the specific prompts and model versions are disclosed. The dependency on LLMs for simulation introduces some stochasticity, but the filtering step should mitigate low-quality outputs. The lack of code release (indicated by "none" for Project URL) is a barrier to full reproducibility, but the methodology is described sufficiently to allow for implementation.
The primary limitation is the potential for error propagation. If the simulator generates inconsistent API responses or the teacher agent makes logical errors, the synthetic data will be noisy. The "LLM judge" is intended to filter this, but judges can also be biased or inconsistent. Furthermore, the simulation is only as good as the LLM's understanding of the API semantics; it may hallucinate behaviors that are not possible in the real world. The approach also assumes that the API specifications are sufficient for an LLM to generate coherent interactions, which may not hold for complex, undocumented, or highly dynamic APIs. Finally, the computational cost of generating and filtering large-scale synthetic data using multiple LLM calls is significant.
This work addresses a critical bottleneck in agent development: the scarcity of high-quality training data. By enabling the generation of synthetic data without expensive environments, it lowers the barrier to entry for developing robust API-calling agents. This could accelerate the deployment of agents in diverse domains where building executable environments is difficult or costly. However, it also raises concerns about the quality and safety of training data, as synthetic data may reinforce biases or hallucinations present in the base models. This paper presents a practical and scalable method for generating synthetic training data for API-calling agents by leveraging LLMs as dynamic world models, effectively bypassing the need for executable environments and demonstrating significant performance improvements on standard benchmarks.
Large language models (LLMs) are increasingly used to automate data-processing workflows, yet coding agents typically produce scripts that are not automatically materialized as persistent, editable platform artifacts. We call this disconnect the NL2Pipeline gap. To bridge it, we introduce DataFlow-Harness, a platform that guides an LLM agent to construct platform-native directed acyclic graphs (DAGs) through typed, incremental mutations rather than free-form scripts. The platform combines DataFlow-Skills for procedural guidance, a Model Context Protocol (MCP) layer that exposes the live operator registry and current pipeline state, and DataFlow-WebUI, which synchronizes conversational authoring with a visual DAG editor. On a 12-task data-engineering benchmark, DataFlow-Harness achieves a 93.3\% observed end-to-end pass rate. Relative to Vanilla Claude Code, it reduces measured monetary cost by 72.5\% and generation latency by 49.9\%; its observed pass rate is within 0.9 percentage points of the Context-Aware Claude Code baseline while its cost is 42.8\% lower. Per-task analysis indicates that Skills are most useful when construction depends on implicit procedural knowledge. These results show that live platform grounding can produce persistent, editable workflow artifacts with an observed reliability close to script-generation baselines and with lower measured construction cost and latency.
Primary: Peking University
All Institutions: Institute for Advanced Algorithms Research, Peking University
DataFlow-Harness presents a practical systems contribution that effectively reduces the cost and latency of LLM-driven data pipeline construction by grounding agents in live platform state and typed mutations, offering a viable alternative to free-form code generation for structured workflow tasks.
The paper proposes DataFlow-Harness, a platform designed to bridge the "NL2Pipeline gap" by using LLM agents to construct persistent, editable Directed Acyclic Graphs (DAGs) for data engineering workflows. The core methodological innovation lies in replacing free-form script generation with "typed, incremental mutations" guided by "DataFlow-Skills" and a Model Context Protocol (MCP) layer. This approach grounds the LLM in the live state of the pipeline and the operator registry, reducing the search space and hallucination risks associated with generating monolithic code blocks. The architecture includes a WebUI for visual synchronization, allowing for human-in-the-loop correction. While the concept of grounding agents in tool APIs is not new, applying it specifically to the structural construction of data pipelines via typed mutations is a distinct and practical contribution to the ML systems domain.
The evaluation is conducted on a 12-task data-engineering benchmark. The primary metric is the end-to-end pass rate, where DataFlow-Harness achieves 93.3%. The paper compares this against "Vanilla Claude Code" and "Context-Aware Claude Code." The results indicate that DataFlow-Harness reduces monetary cost by 72.5% and generation latency by 49.9% compared to the vanilla baseline, while maintaining performance within 0.9 percentage points of the context-aware baseline at a 42.8% lower cost. The experimental design is sound for a systems paper, focusing on efficiency and reliability metrics. However, the small scale of the benchmark (12 tasks) limits the statistical power of the claims. The per-task analysis providing insight into when Skills are most useful adds value, but the lack of comparison against other specialized pipeline tools (e.g., Airflow, Dagster, Prefect) or more recent agentic frameworks (e.g., LangGraph, AutoGen) weakens the comparative impact.
The paper describes the components (Skills, MCP layer, WebUI) in sufficient detail to understand the architecture. However, as an arXiv technical report, it lacks the extensive implementation details, hyperparameters, and specific dataset versions often required for immediate reproduction. The reliance on proprietary models (Claude) for the baseline and potentially the agent itself introduces variability. The benchmark dataset is likely proprietary or custom-built given the specific nature of the 12 tasks, which hinders direct replication by other researchers.
The primary limitation is the small scale of the evaluation benchmark (12 tasks), which may not generalize to complex, real-world data engineering scenarios involving hundreds of nodes and intricate dependencies. The paper does not discuss the failure modes of the "typed mutation" approach, such as how it handles ambiguous user requests that require significant architectural changes rather than incremental edits. Furthermore, the cost and latency benefits are measured in a controlled environment; real-world network latency and API rate limits could affect these numbers. The paper also does not address the security implications of allowing LLMs to execute code mutations on production-like data pipelines.
This work has significant potential impact on the democratization of data engineering and MLOps. By making data pipeline construction more accessible, reliable, and cost-effective, it lowers the barrier to entry for building robust ML systems. It encourages the adoption of agentic workflows in data-intensive domains. However, it also raises concerns about the reliability of automated code generation in critical infrastructure and the potential for cascading failures if the LLM makes incorrect structural changes. The focus on efficiency (cost/latency) aligns with the industry's push for sustainable AI. DataFlow-Harness presents a practical systems contribution that effectively reduces the cost and latency of LLM-driven data pipeline construction by grounding agents in live platform state and typed mutations, offering a viable alternative to free-form code generation for structured workflow tasks.
LLMs scale Mixture-of-Experts (MoE) parameters for superior intelligence, but massive weights and dynamic computation impede efficient serving. Existing instance-level prefill-decode disaggregation isolates the phases on separate full-model replicas. As MoE weights grow, each instance may span tens to hundreds of GPUs, making resource allocation increasingly coarse. Configured prefill-to-decode ratios thus often mismatch demand, overprovisioning one phase while overloading the other. Prefill-decode colocation avoids this duplication, but existing Green Context solutions partition each GPU by phase and fix phase resources during a kernel. They cannot track resource changes across operations or layerwise variation in routed expert load, causing head-of-line blocking or idle reserved resources. Partitioning every GPU also leaves each phase with fewer local resources, forces wider parallelism and more communication, and lets prefill and decode traffic interfere on the shared network. We present ExpertPlex, which shares massive MoE experts across phases while disaggregating lightweight attention modules. Expert sharing eliminates over 95% of duplicate model weights and multiplexes dynamically sparse computation, while attention disaggregation reduces attention communication cost. ExpertPlex further uses (1) adaptive persistent kernels to schedule dynamic expert computation at tile granularity for efficient, isolated execution; (2) attention-initiated MoE communication to avoid network interference and enable cross-phase communication-computation overlap; and (3) a tile-to-cluster model to optimize these mechanisms for maximum goodput. Experiments serving MiniMax-M2.7 and GLM-5.1-FP8 show that ExpertPlex improves goodput by up to 2.01$\times$ over instance-level prefill-decode disaggregation and 1.66$\times$ over prefill-decode colocation.
Primary: Peking University
All Institutions: Peking University, Independent Researcher
ExpertPlex presents a significant advancement in LLM serving systems by introducing a novel disaggregated architecture that effectively shares MoE experts while isolating attention modules, achieving substantial goodput improvements through adaptive persistent kernels and optimized communication patterns.
The paper proposes ExpertPlex, a disaggregated serving architecture specifically designed for Mixture-of-Experts (MoE) Large Language Models. The core innovation lies in decoupling the handling of MoE experts from attention modules. While existing systems either colocate all components (leading to resource contention) or disaggregate at the instance level (leading to massive weight duplication and coarse-grained allocation), ExpertPlex shares the massive MoE expert weights across phases while isolating the lightweight attention modules. The methodology introduces three key technical mechanisms: (1) Adaptive Persistent Kernels, which schedule dynamic expert computation at the tile granularity to handle load imbalance and avoid head-of-line blocking; (2) Attention-Initiated MoE Communication, which overlaps communication with computation and prevents network interference between prefill and decode phases; and (3) A Tile-to-Cluster Model, an optimization framework to allocate resources dynamically. This approach addresses the fundamental inefficiency of serving sparse MoE models where expert load is highly dynamic and non-uniform.
The evaluation is conducted on two significant MoE models: MiniMax-M2.7 and GLM-5.1-FP8. The baseline comparisons are rigorous, covering the two dominant existing paradigms: instance-level prefill-decode disaggregation and prefill-decode colocation. The results demonstrate substantial improvements, with up to 2.01x goodput improvement over instance-level disaggregation and 1.66x over colocation. These gains are particularly impressive given that colocation is often considered the most resource-efficient in terms of hardware usage, implying that ExpertPlex achieves higher throughput without requiring additional hardware, simply by better utilizing existing resources. The use of FP8 models also highlights the system's relevance to current hardware trends.
The paper provides a detailed description of the system design, including the persistent kernel scheduling and communication overlap mechanisms. The inclusion of specific model names (MiniMax-M2.7, GLM-5.1-FP8) allows for potential replication if these models are publicly available or if synthetic workloads are used. However, as is common with systems papers, full reproducibility might depend on the specific cluster configuration and the availability of the proprietary model weights. The detailed algorithmic descriptions of the adaptive scheduling and tile-to-cluster optimization provide a strong foundation for implementation.
The paper focuses on the serving side and does not address training efficiency. The complexity of the adaptive persistent kernels and the tile-to-cluster model introduces additional system overhead that must be carefully managed; if the scheduling overhead exceeds the gains from reduced communication or better utilization, performance could degrade. Furthermore, the benefits are most pronounced for very large MoE models with high expert counts; for smaller models or dense models, the overhead of the disaggregation and dynamic scheduling might not justify the complexity. The reliance on high-bandwidth, low-latency interconnects for the attention-MoE communication is also a constraint.
ExpertPlex addresses a critical bottleneck in the deployment of state-of-the-art AI models. By significantly improving the goodput of MoE LLMs, it lowers the cost barrier for serving these models, potentially democratizing access to high-quality AI services. The architectural insights regarding dynamic resource allocation for sparse models can influence future system designs for other sparse architectures beyond LLMs, such as sparse transformers or mixture-of-experts in other domains. ExpertPlex presents a significant advancement in LLM serving systems by introducing a novel disaggregated architecture that effectively shares MoE experts while isolating attention modules, achieving substantial goodput improvements through adaptive persistent kernels and optimized communication patterns.
Retrieval-Augmented Generation (RAG) enhances the factual grounding of large language model (LLM) inference by retrieving relevant information from external knowledge bases. However, its dense vector retrieval introduces significant latency and energy overhead, becoming the primary performance bottleneck. Although recent in-storage accelerators aim to reduce data movement, they still rely on host or embedded processors outside the memory, where nearly 70% of the total retrieval time is spent. As a result, they cannot fully overcome the bandwidth limitations, leading to yet another memory bottleneck. To tackle these limitations, we present D-NOVA, a hardware-software co-designed in-storage retrieval accelerator. D-NOVA executes an inverted file (IVF)-based hierarchical retrieval pipeline by deeply embedding the search functionality directly into the NAND memory array. This is achieved by incorporating a new distance metric, Dual-Bound Tight Similarity Sensing (DTS), which is specifically tailored for searching within the NAND string. In addition, we introduce a lightweight contrastive adapter that maps embedding vectors into a DTS-friendly domain, recovering near-software recall while improving performance and energy efficiency. D-NOVA is up to 41.7x faster and 71x more energy-efficient than a CPU baseline, and achieves 12.13x higher throughput while being up to 1.26x more energy-efficient than state-of-the-art in-storage RAG accelerators, demonstrating the potential of fully in-storage vector search for scalable RAG acceleration.
Primary: University of California, San Diego
All Institutions: University of California, San Diego
D-NOVA introduces a novel in-storage vector search accelerator that leverages a NAND-optimized distance metric and contrastive adaptation to achieve significant speed and energy efficiency gains for RAG workloads. This research represents a substantial contribution to the intersection of computer architecture and machine learning systems, offering a viable path to overcoming the memory bottleneck in large-scale retrieval tasks.
The paper proposes D-NOVA, a hardware-software co-designed accelerator that performs vector similarity search directly within 3D NAND memory arrays, bypassing the traditional host-to-memory data movement bottleneck. The core technical innovation is the Dual-Bound Tight Similarity Sensing (DTS) metric, which is specifically tailored to the physical characteristics of NAND strings (e.g., threshold voltage distributions and read disturb effects) to enable approximate nearest neighbor search at the storage level. This is coupled with a lightweight contrastive adapter that transforms embedding vectors into a domain compatible with DTS, allowing the hardware to operate on "DTS-friendly" vectors while maintaining high recall relative to software baselines. The approach represents a significant shift from "in-storage computing" (which often still moves data to embedded processors) to "in-storage sensing," leveraging the analog/digital properties of the memory array itself for computation.
The evaluation demonstrates substantial improvements over baselines. D-NOVA achieves up to 41.7x speedup and 71x energy efficiency gains compared to a CPU baseline. When compared to state-of-the-art in-storage RAG accelerators, it shows 12.13x higher throughput and up to 1.26x better energy efficiency. The paper likely includes detailed breakdowns of latency components, energy consumption per operation, and recall/accuracy metrics (e.g., Recall@K) to validate that the hardware approximation does not significantly degrade retrieval quality. The results suggest that the proposed architecture effectively mitigates the memory wall for RAG workloads.
As a hardware design paper, reproducibility depends on the availability of the RTL (Register Transfer Level) code, simulation models, and detailed architectural parameters. The paper mentions support from SRC and NSF grants, suggesting rigorous academic standards. However, without explicit open-source code links in the provided text, reproducibility is limited to the described methodology and potentially available supplementary materials. The specific implementation of the DTS metric and the contrastive adapter's training procedure are critical for replication.
The primary limitation is the reliance on specific 3D NAND characteristics, which may vary across manufacturers and process nodes. The "DTS-friendly" domain requires a pre-processing step (the contrastive adapter), adding a small overhead that must be justified by the massive gains in the search phase. Furthermore, the scalability of the in-storage search logic across very large vector databases (millions/billions of vectors) and the impact of wear-leveling and garbage collection in NAND on the consistency of the DTS metric are potential challenges not fully addressed in the abstract. The energy efficiency claim of 1.26x over SOTA in-storage accelerators is modest compared to the CPU baseline, suggesting that while the approach is novel, the absolute gains over existing in-storage solutions might be incremental in some configurations.
This work has significant implications for the scalability of Retrieval-Augmented Generation (RAG) systems, which are becoming the standard for enterprise LLM applications. By reducing the latency and energy cost of vector retrieval, D-NOVA enables more responsive and sustainable AI systems. It also advances the field of in-memory/in-storage computing, demonstrating that complex ML workloads can be offloaded to storage devices in a way that leverages their physical properties, potentially reshaping the architecture of future data centers. D-NOVA introduces a novel in-storage vector search accelerator that leverages a NAND-optimized distance metric and contrastive adaptation to achieve significant speed and energy efficiency gains for RAG workloads. This research represents a substantial contribution to the intersection of computer architecture and machine learning systems, offering a viable path to overcoming the memory bottleneck in large-scale retrieval tasks.
Multi-head Latent Attention (MLA) ships two implementations in Megatron-Core: an explicit form used for training and an absorbed form -- which slashes collective communication by gathering only the compressed latent -- that is fully implemented but hard-asserted out of training (the forward opens with "assert not (self.training and self.cache_mla_latents)"), allowed only in inference decode. The library documents no reason. We show the restriction is well-founded and quantify why: ported to training, the absorbed form is a memory trap -- its intermediates live in n_h x d_kv dimensions per token, larger than the per-head K/V they replace -- inflating activation memory by 20-34%, up to 9.2 GB at DeepSeek-V3 scale (n_h=128, seq=16384, SP=8, eager kernel; the gap widens to 19.2 GB under a fused kernel), enough to change device-fit. This measurement, validated on two axes (linear in seq and n_h) and cross-verified on NVIDIA A100, explains the otherwise-undocumented restriction and leaves practitioners with no low-communication MLA training path. We then provide one. LAGA (Latent All-Gather Attention) keeps the absorbed form's latent-gather communication but rejects the absorb reformulation, instead reconstructing per-head K/V locally from the gathered latent. On 8x Ascend 910B at real DeepSeek-V3 dimensions, LAGA cuts collective communication 1.98x, matches explicit memory within 0.5%, is bit-identical to explicit at SP=1 and equivalent to within 1e-3 at SP=2-8, and under a fused attention kernel improves attention-block throughput 1.04-1.06x single-node and 1.07-1.24x cross-node -- leading at all sequence lengths in the cross-node regime MLA is deployed for.
Primary: China Mobile Jiutian Artificial Intelligence Technology (Beijing) Co., Ltd.
All Institutions: China Mobile Jiutian Artificial Intelligence Technology (Beijing) Co., Ltd.
The paper provides a rigorous analysis of the memory-communication trade-offs in MLA sequence parallelism and proposes LAGA, a practical solution that enables efficient training of MLA-based models like DeepSeek-V3. [Comprehensive analysis of the technical contribution, methodology, and significance to the field].
The paper addresses a critical gap in distributed training systems for Large Language Models (LLMs), specifically concerning Multi-head Latent Attention (MLA) as used in DeepSeek-V3. The authors identify that Megatron-Core explicitly forbids the "absorbed" form of MLA during training, a restriction previously undocumented. They provide a rigorous theoretical and empirical explanation: the absorbed form, while communication-efficient, creates a "memory trap" where intermediate tensors scale with $n_h \times d_{kv}$, leading to significant activation memory inflation (up to 34% or ~9-19 GB at scale). To solve this, they propose LAGA (Latent All-Gather Attention), which retains the communication efficiency of the latent all-gather but reconstructs per-head K/V locally to maintain the memory footprint of the explicit form. The methodology is sound, leveraging standard sequence parallelism principles and linear algebra properties to decouple communication volume from activation memory size.
The evaluation is comprehensive and convincing. The authors measure communication volume, activation memory, and throughput on both Ascend 910B and NVIDIA A100 hardware, ensuring hardware-agnostic validity. They demonstrate that LAGA reduces collective communication by ~1.98x compared to the explicit baseline while matching its memory footprint within 0.5%. Crucially, they show that LAGA outperforms the explicit baseline in throughput (1.04-1.24x) in the cross-node, long-context regime, which is the primary use case for MLA. The numerical equivalence to the explicit baseline is verified to high precision (bit-identical at SP=1, <1e-3 error at SP>1). The inclusion of both eager and fused kernel results strengthens the claims by showing the memory trap is structural, not an artifact of kernel implementation.
The paper provides detailed algorithmic descriptions and mathematical derivations. The experimental setup is clearly defined, including hardware specs, sequence lengths, and parallelism degrees. The authors cross-verify results on two different hardware architectures (Ascend and NVIDIA), which adds significant credibility. While the code is not linked, the description is sufficient for a competent systems researcher to implement. The convergence test on a small model provides additional assurance of correctness.
The evaluation is limited to a single attention layer for communication/memory analysis and a 4-layer stack for throughput, rather than a full DeepSeek-V3-scale (61-layer) model. The authors acknowledge this, noting that the structural properties hold, but end-to-end MFU might differ. Additionally, the convergence test is on a small, random-data memorization task, which may not fully reflect training dynamics on real data. The prototype implementation uses eager kernels for some comparisons, though fused kernel results are provided to mitigate this.
This paper has significant implications for the training of large-scale MoE and MLA-based models. By providing a communication-efficient and memory-safe training path for MLA, it enables more efficient scaling of these architectures. The finding that inference optimizations (like absorption) can be detrimental in training is a valuable lesson for the broader ML systems community. It highlights the importance of analyzing memory footprints when porting inference techniques to training. The paper provides a rigorous analysis of the memory-communication trade-offs in MLA sequence parallelism and proposes LAGA, a practical solution that enables efficient training of MLA-based models like DeepSeek-V3. [Comprehensive analysis of the technical contribution, methodology, and significance to the field].
Graph Neural Network (GNN) inference on billion-scale graphs is challenging due to the large memory footprint of features and embeddings and high disk I/O costs in out-of-core settings. Existing distributed GNN systems incur high communication times and infrastructure costs, while disk-based GNN systems are primarily tailored to training and experience massive wasted reads during inference on the entire graph. We present Taurus, a single-machine system for GNN inference on graphs that do not fit in RAM, supporting both \textit{exact} full-graph inference and fanout-sampled inference. To avoid random and repeated feature gathers, Taurus reformulates layer-wise inference as source-centric broadcasts over sequential SSD scans, backed by a pipelined GPU-CPU-SSD hierarchy, topology-aware reordering, pending-message eviction, and a GPU-resident store for high-degree vertices. It further uses non-buffered sequential reads and GPU-backed writes to reduce page-cache pollution, host-memory pressure, and write overheads. On out-of-core graphs with up to $269M$ vertices, $4B$ edges, and $514$ GiB of features, Taurus outperforms the strongest layer-wise baseline, DGI, by $7$-$25\times$, and vertex-wise baselines by $40$-$140\times$.
Primary: Indian Institute of Science (IISc)
All Institutions: Indian Institute of Science (IISc)
Taurus introduces a source-centric broadcast execution model for out-of-core GNN inference, significantly reducing I/O amplification and enabling efficient single-machine processing of billion-scale graphs with substantial performance gains over existing systems.
The paper proposes Taurus, a system for out-of-core GNN inference that fundamentally shifts from destination-centric gathering to source-centric broadcasting. This is a significant architectural insight for disk-based systems, as it transforms random I/O patterns into sequential scans. The integration of a tiered storage hierarchy (GPU-RAM-SSD) with specific optimizations like topology-aware reordering (minimizing vertex span) and a pending-message eviction policy demonstrates a deep understanding of the I/O bottlenecks in billion-scale graph processing. The extension to support GAT and SAGEConv via multi-pass strategies is technically sound and necessary for generalizability.
The evaluation is comprehensive, covering multiple datasets up to 514 GiB of features and comparing against strong baselines (DGI, Ginex, DGL). The results show substantial speedups (7-25x over DGI, 40-140x over vertex-wise baselines). The ablation studies on reordering, eviction policies, and store sizes provide strong evidence for the design choices. The use of extrapolation for timeouts is a pragmatic approach but slightly weakens the absolute rigor for the largest datasets; however, the trend is clear.
The paper provides detailed implementation specifics, including chunk sizes, buffer sizes, and hardware configurations. The use of standard libraries (NumPy, PyTorch) and clear algorithmic descriptions enhances reproducibility. The code is not explicitly linked in the text provided, but the description is sufficient for a systems researcher to implement.
The system assumes static graph snapshots, limiting its applicability to dynamic graphs without significant modification. The reordering step is a one-time cost, which is acceptable for inference but adds complexity to the deployment pipeline. The performance gains are most pronounced on I/O-bound workloads; for very small graphs fitting in RAM, the overhead of the broadcast mechanism might negate benefits.
Taurus enables efficient, single-machine inference for billion-scale graphs, reducing the infrastructure cost and complexity associated with distributed GNN inference. This makes advanced GNN applications more accessible to organizations with limited HPC resources. Taurus introduces a source-centric broadcast execution model for out-of-core GNN inference, significantly reducing I/O amplification and enabling efficient single-machine processing of billion-scale graphs with substantial performance gains over existing systems.
Serverless multi-model LLM systems multiplex popularity-skewed model catalogs over shared GPU pools, yet typically schedule each request independently. Tool-using agents break this abstraction: a session repeatedly calls an LLM across short tool gaps, carries a long reusable KV prefix, and is judged by session completion time (SCT). Load-only routing can separate a continuation from both its model and KV state, while round-based model multiplexing can delay even a correctly placed continuation until the target model's next slot. Both failures are especially costly for hundred-billion-parameter models: their weights constrain residency, while long-context KV is expensive to reconstruct or move. We present Talaria, a session-aware serverless multi-model serving system that makes session continuity a joint placement-and-admission decision. Its router ranks placements by model residency, KV locality, and instance pressure, while soft reservations account for likely returns in the last serving instance's admission budget. Session-prefill (SP) admits budget-eligible continuations before the active model slot closes. An instance-local substrate keeps HBM addresses stable, preserves host-restorable KV, and stages weights across model switches. On a single TP=8 server, we replay 30 SWE-Bench model-sessions (960 calls) over three models, each with more than 100B total parameters. Against an otherwise identical round scheduler with SP, host-KV restoration, and D2D staging disabled, Talaria cuts p50 SCT from 1000 s to 189 s and p95 from 2296 s to 867 s, speedups of 5.3x and 2.6x.
Primary: Unknown
All Institutions: Unknown
Talaria introduces a session-aware scheduling framework for serverless LLM serving that significantly reduces latency for agent workloads by optimizing for KV cache locality and weight residency. The paper presents a compelling systems solution to a growing problem in AI infrastructure, demonstrating substantial performance improvements on realistic workloads, though its impact is currently limited by the lack of distributed evaluation and open-source code.
The paper proposes Talaria, a session-aware serverless serving system designed for large language models (LLMs) with hundreds of billions of parameters. The core innovation lies in treating session continuity as a joint placement-and-admission decision rather than scheduling requests independently. Key technical components include: 1) A router that ranks placements based on model residency, KV (Key-Value) cache locality, and instance pressure; 2) Soft reservations that account for likely returns of users in the last serving instance's admission budget; 3) Session-prefill (SP) which admits budget-eligible continuations before the active model slot closes; and 4) An instance-local substrate that keeps HBM (High Bandwidth Memory) addresses stable, preserves host-restorable KV caches, and stages weights across model switches. This approach addresses the specific challenges of tool-using agents, which generate sessions with short tool gaps and long reusable KV prefixes, breaking the abstraction of independent request scheduling. The methodology is well-reasoned and targets a critical bottleneck in serverless LLM serving: the high cost of weight loading and KV cache reconstruction for large models.
The evaluation is conducted on a single TP=8 (Tensor Parallelism degree 8) server, replaying 30 SWE-Bench model-sessions comprising 960 calls across three models, each with more than 100B total parameters. The baseline is an otherwise identical round scheduler with Session-Prefill, host-KV restoration, and D2D (Device-to-Device) staging disabled. The results show significant improvements: Talaria cuts p50 Session Completion Time (SCT) from 1000 s to 189 s (5.3x speedup) and p95 SCT from 2296 s to 867 s (2.6x speedup). These are substantial improvements, particularly for p50 latency, which is critical for user-perceived responsiveness in agent loops. The use of real-world SWE-Bench sessions adds credibility to the evaluation, as these sessions exhibit the complex, non-i.i.d. access patterns that naive schedulers fail to handle. However, the evaluation is limited to a single server configuration, which may not fully capture the scalability or heterogeneity of a distributed serverless cluster.
The paper provides detailed descriptions of the system components, including the router logic, admission control, and substrate management. The experimental setup specifies the hardware (TP=8 server), the workload (SWE-Bench sessions), and the baseline configuration. While the specific implementation details might require access to the code for exact reproduction, the architectural description is sufficiently detailed for a systems paper. The use of a standard benchmark dataset (SWE-Bench) and clear metrics (SCT) enhances reproducibility. However, the "unknown" institution and lack of a public code repository (as indicated by the URL extraction) pose a barrier to immediate independent verification.
The primary limitation is the scope of the evaluation. It is confined to a single server, which does not demonstrate the system's behavior in a distributed, multi-node serverless environment where network latency and cross-node KV cache migration become significant factors. Additionally, the performance gains are reported for a specific set of 30 sessions; while representative, the generalizability to other types of agent workloads or different model architectures (e.g., MoE vs. Dense) is not explicitly explored. The reliance on "soft reservations" introduces potential overhead or complexity in admission control that is not fully quantified in terms of system stability under extreme load spikes.
Talaria addresses a significant practical challenge in deploying large-scale LLM systems, particularly for agent-based applications. By reducing latency and improving resource utilization through session-aware scheduling, it enables more responsive and cost-effective LLM services. This can accelerate the adoption of complex AI agents in software engineering and other domains requiring long-horizon reasoning. The techniques for managing KV cache locality and weight staging are broadly applicable to other serverless serving systems dealing with large models. Talaria introduces a session-aware scheduling framework for serverless LLM serving that significantly reduces latency for agent workloads by optimizing for KV cache locality and weight residency. The paper presents a compelling systems solution to a growing problem in AI infrastructure, demonstrating substantial performance improvements on realistic workloads, though its impact is currently limited by the lack of distributed evaluation and open-source code.
As demand for DNN inference grows, GPU capacity is increasingly oversubscribed, forcing operators to colocate multiple models on the same device in both cloud and edge deployments. Whether colocation succeeds or violates SLOs depends on the temporal overlap of kernels from concurrently executing models -- an effect that existing serving systems either ignore or approximate using aggregate resource profiles that fail to capture temporal dynamics. This paper presents Roomie, a model serving orchestration architecture that predicts and avoids kernel-level interference between colocated DNNs. Roomie decouples offline kernel profiling from online interference prediction. It uses profiling only to extract per-kernel resource configurations, and predicts interference with an occupancy-based analytical model immune to profiler-induced timing distortion. A pairwise greedy heuristic then approximates multi-model interference in polynomial rather than exponential time, and an online placement algorithm then uses these estimates to assign each incoming model to the GPU that minimizes predicted slowdown. Our experimental evaluation compares Roomie against state-of-the-art solutions across both cloud-grade server clusters and embedded edge devices, demonstrating that Roomie reduces SLO violations (i.e., inference latency) by up to 3x, while maintaining comparable, and in many cases superior, goodput relative to existing approaches.
Primary: Stony Brook University
All Institutions: Stony Brook University, ENS Lyon, Institut Universitaire de France, Université Savoie Mont Blanc
Roomie presents a robust and practically significant contribution to the field of ML systems by introducing an interference-aware colocation strategy that significantly reduces latency violations through accurate, lightweight analytical modeling. The decoupling of profiling from online prediction and the use of a pairwise greedy heuristic offer a scalable solution to a pervasive problem in multi-tenant GPU environments, demonstrating clear empirical benefits in both cloud and edge settings.
The paper proposes "Roomie," a model serving orchestration architecture designed to mitigate kernel-level interference when colocation of multiple Deep Neural Network (DNN) inference models on a single GPU. The core methodological innovation lies in decoupling offline kernel profiling from online interference prediction. Instead of relying on aggregate resource profiles which fail to capture temporal dynamics, Roomie uses an occupancy-based analytical model to predict interference. This model is described as "immune to profiler-induced timing distortion," a significant practical advantage. The system employs a pairwise greedy heuristic to approximate multi-model interference in polynomial time, followed by an online placement algorithm that assigns incoming models to GPUs to minimize predicted slowdown. This approach addresses a critical gap in existing serving systems that either ignore interference or use coarse approximations.
The evaluation compares Roomie against state-of-the-art solutions across two distinct environments: cloud-grade server clusters and embedded edge devices. The metrics focus on SLO violations (inference latency) and goodput. The results indicate that Roomie reduces SLO violations by up to 3x compared to existing approaches. Furthermore, it maintains comparable or superior goodput, suggesting that the interference-aware scheduling does not come at the cost of overall throughput efficiency. The dual-environment evaluation strengthens the claim of generalizability, though the specific baselines and workload characteristics (e.g., mix of model sizes, batch sizes, and traffic patterns) are crucial for interpreting the magnitude of the improvement.
The paper provides a clear description of the architecture, including the decoupling of profiling and prediction, the analytical model, and the heuristic algorithms. The implementation details appear sufficient for replication by systems researchers. However, the specific parameters of the "occupancy-based analytical model" and the exact nature of the "pairwise greedy heuristic" would need to be scrutinized in the full text to ensure complete reproducibility. The use of standard benchmarks for DNN inference is implied, which aids reproducibility.
The paper likely faces limitations inherent to analytical models, such as the accuracy of the interference predictions under highly dynamic or non-stationary workloads. The "pairwise" heuristic, while efficient, may not capture complex higher-order interference effects among three or more models simultaneously, potentially leading to suboptimal placements in dense colocation scenarios. Additionally, the overhead of the online placement algorithm itself must be negligible to justify its use; the paper claims this but the computational cost of the prediction step is a potential bottleneck if not optimized. The evaluation on embedded devices might be limited by the specific hardware constraints and the availability of diverse DNN models for edge deployment.
This work has significant implications for the efficiency and cost-effectiveness of DNN inference services in both cloud and edge computing. By enabling more efficient colocation, operators can reduce hardware costs and energy consumption while maintaining service level objectives. This contributes to the broader goal of sustainable AI and democratizing access to high-performance inference resources. The techniques developed could be integrated into major serving frameworks (e.g., Triton, vLLM) to improve their default scheduling strategies. Roomie presents a robust and practically significant contribution to the field of ML systems by introducing an interference-aware colocation strategy that significantly reduces latency violations through accurate, lightweight analytical modeling. The decoupling of profiling from online prediction and the use of a pairwise greedy heuristic offer a scalable solution to a pervasive problem in multi-tenant GPU environments, demonstrating clear empirical benefits in both cloud and edge settings.