From Passive Video to Editable Experience: Physically Grounded Experience Synthesis for Embodied Intelligence (via arXiv cs.AI)

Failed to generate deep-dive analysis.

The development of large-scale foundation models for particle physics has historically been constrained by the financial and computational uncertainty of scaling. To address this, Jan-Lucas Uslu, Benjamin Nachman, and Christopher Ré introduced a framework for predicting the performance of jet-physics transformers prior to resource expenditure, published on arXiv. While scaling laws have previously been fitted to jet datasets, they failed to forecast the performance of architectures outside their fitting range. This research establishes that a joint model-and-data scaling law, parameterized using only small-scale models spanning three orders of magnitude of training compute, can successfully project the loss of models trained with over one hundred times more compute to within a one percent margin of error.

This capability is highly valuable for machine learning engineers and experimental high-energy physicists who must optimize massive compute budgets. The authors demonstrate a direct, systematic link between pretraining loss and downstream physics performance. Across two standard jet-tagging benchmarks, lower pretraining loss reliably yields lower fine-tuning loss and superior background rejection. This means that a specific compute budget can be mathematically mapped to expected experimental physics utility before initiating any large-scale training run.

Technically, the resulting frontier model achieves competitive parity with existing state-of-the-art physics-aware foundation models on standard metrics like accuracy, AUC, and quark/gluon rejection. The physics-aware models retain only a marginal advantage in the high-purity tail of top tagging. By demonstrating that generic transformers can scale predictably and perform comparably to hand-crafted, domain-specific architectures, this work shifts the paradigm of physical science foundation models toward predictable, compute-optimal scaling trajectories. Note that this analysis is based on the paper’s published abstract.

Evaluating large language model (LLM) agents in search-and-retrieval tasks is frequently bottlenecked by a lack of standardization in the underlying search environment. Factors such as the specific Wikipedia snapshot, preprocessing pipelines, chunking strategies, and retrieval backends are often under-specified, leading to irreproducible benchmarks and unfair model comparisons where environmental differences are mistaken for differences in model capability. To resolve this issue, Guanming Xiong and Penghui Zhang introduced SimpleWikiSearch in a technical report published on arXiv (cs.AI/cs.IR). SimpleWikiSearch is a clean, fully offline, and runnable evaluation environment designed to standardize the agentic search harness. Rather than introducing a new agent algorithm, this work establishes a controlled reference setup that decouples agent reasoning performance from environmental variance.

The framework is built around a fully transparent and reproducible data and retrieval pipeline. Starting from a raw English Wikipedia dump, the environment handles corpus cleaning and chunking before constructing both keyword (BM25) and dense retrieval indexes. The interface exposed to the LLM agent is deliberately minimalist, restricting the tool interaction layer to three primary schema contracts: search, open_url, and submit_answer. This constrained schema prevents prompt-engineering variations from confounding the evaluation of the agent's core reasoning and retrieval capabilities. Furthermore, the creators evaluated baseline performance across six question-answering datasets using open-source LLMs and curated a "random-300" subset specifically designed to lower API costs when benchmarking closed-source commercial models.

This standardized harness is built for AI researchers and software engineers developing retrieval-augmented generation (RAG) pipelines and autonomous search agents. By establishing a rigid, offline benchmark, SimpleWikiSearch enables practitioners to isolate and evaluate the search strategies and reasoning capacities of different LLMs under identical conditions. Going forward, this work provides the community with a reliable baseline environment that could lead to more rigorous, comparable agent leaderboards and lower the barrier to entry for analyzing complex, multi-step agentic search behaviors. Please note that this analysis is based on the published abstract and metadata of the technical report.

The development of robust defenses against prompt injection attacks remains a critical bottleneck in deploying large language models safely. To address this, Eric Wallace and a team of co-authors published a paper on arXiv introducing GPT-Red, an automated red-teaming agent trained at scale to discover novel prompt injection vulnerabilities. Designed for AI safety researchers and machine learning security engineers, this work shifts security testing from manual, human-driven probing to automated, system-wide vulnerability discovery, facilitating the systematic hardening of production models.

The core of GPT-Red's methodology relies on a scalable self-play reinforcement learning algorithm. In this framework, the red-teaming agent is optimized by attempting to bypass the security guardrails of a diverse, simultaneously trained population of defender agents. The researchers scaled this environment using compute resources on par with their largest reinforcement learning post-training runs, making it the single largest LLM safety training run documented. Empirically, GPT-Red outperformed human red-teamers, successfully compromised models up to GPT-5.5, and demonstrated strong generalization capabilities across held-out environments, defender models, and evaluation harnesses. The highly creative attacks generated by the system were then leveraged to adversarially train GPT-5.6, resulting in a model with state-of-the-art robustness against prompt injections.

This paradigm establishes a scalable foundation for automated AI alignment and defensive security. Going forward, this architecture enables a continuous, self-improving security flywheel: as target models become more robust, they demand and subsequently train more sophisticated red-teaming agents, which in turn generate the adversarial data needed to secure the next generation of frontier models. This co-evolutionary cycle could fundamentally change how safety is integrated into the LLM lifecycle, shifting the industry away from reactive patch-work defenses toward proactive, automated co-development. Please note that this analysis is based on the published abstract and metadata of the research paper.

Try Again, Don't Look Back: Blind Resampling Outperforms Self-Repair in Small Code Models (via arXiv cs.AI)

Failed to generate deep-dive analysis.

Ads Dawson and an unnamed co-author from an unspecified institution, publishing on arXiv in computer science under the AI and Cryptography and Security categories, have introduced StealthBench. This work addresses a critical gap in the evaluation of autonomous offensive-security agents: their operational stealth. While current benchmarks often focus on task completion, they fail to assess whether an agent operates covertly, a fundamental requirement for sophisticated security operations and advanced persistent threats. StealthBench provides a standardized framework to measure this crucial aspect, aiming to bridge the chasm between theoretical capabilities and practical, unnoticed execution.

The core contribution is a benchmark designed to quantify operational security (OPSEC) performance in autonomous agents. It achieves this by presenting 14 Dockerized scenarios derived from real bug-bounty and red-teaming engagements. Within these scenarios, agents are tasked with discovering and exploiting vulnerabilities. However, success is not solely defined by exploitation; the agent's actions are scrutinized for stealth failures. These failures include egregious mistakes like embedding credentials in public repositories or deleting production resources, behaviors antithetical to professional tradecraft. The evaluation mechanism employs a three-model large language model (LLM) judge panel to assess agent trajectories, aggregating results via majority vote. Key metrics include "safe success rate" (task completion and stealthy operation), "Stealth@Solve" (tradecraft quality among successful attempts), and "reckless solve rate" (task completion with compromised stealth).

The findings underscore a significant deficiency in current autonomous agent development, revealing systematic OPSEC failures across various model families, with no evaluated agent exceeding a 54% safe success rate. This work is intended for AI researchers developing offensive-security agents, cybersecurity professionals deploying such tools, and offensive security practitioners interested in the capabilities and limitations of autonomous systems.

StealthBench enables the development of agents that not only identify vulnerabilities but do so with the discretion of skilled human operators. This could profoundly influence the field by shifting the focus of agent evaluation from mere efficacy to responsible and covert execution. The public release of the benchmark, evaluation harness, and dataset promises to accelerate research into stealth-aware AI and to inform the development of automated monitoring systems for autonomous offensive security deployments, ultimately leading to more sophisticated and less detectable AI-driven security tools. This analysis is based on the abstract provided for the research paper.

In reinforcement learning fine-tuning for large language models, balancing target task optimization with policy drift remains a primary challenge. Standard approaches rely on Kullback-Leibler (KL) regularized objectives, but setting the regularization coefficient currently relies on computationally expensive hyperparameter sweeps or heuristics. To resolve this, Keegan Harris, Brian W. Lee, Ian Waudby-Smith, Philip Amortila, Nika Haghtalab, and Michael I. Jordan introduced a game-theoretic framework in their paper "Post-Training at the Edge of Detectability: A Game-Theoretic Approach to Fine-Tuning" (published on arXiv, cs.AI). The authors reformulate the fine-tuning trade-off through a sequential game played between an agent attempting to maximize reward and an external monitor verifying policy drift.

The core of this work lies in two primary technical insights. First, the authors prove that the equilibrium policy of this sequential game is mathematically equivalent to the solution of a KL-regularized RL problem. Crucially, the resulting optimal regularization parameter represents the maximum reward achievable per unit of statistical distinguishability, grounding the parameter in clear statistical terms. Second, by applying classical concepts from concave-convex fractional programming, the authors derive a principled method to learn this equilibrium coefficient. This reduction to a standard KL-regularized RL objective ensures that the framework can be directly integrated into existing fine-tuning pipelines without requiring bespoke optimization infrastructure.

For machine learning engineers, trust and safety researchers, and model auditors, this work provides a rigorous alternative to manual parameter tuning. In practical experiments using Qwen3-8B and Llama-3.2-1B, the methodology achieved competitive reward-retention trade-offs in continual learning setups. Beyond optimizing training efficiency, this game-theoretic formulation establishes a novel paradigm for model auditing. It enables downstream users to statistically verify whether API providers are silently updating or drifting from specified open-source reference models. This opens a promising pathway for verifiable AI deployments and robust post-training standards. Note that this analysis is based on the published abstract of the paper.

The introduction of the HiFloat4 (HiF4) format and the Rollout Residual Quantization (Rollout-ResQ) mechanism represents the first successful end-to-end FP4 reinforcement learning (RL) post-training framework where both rollout and training policies, including their forward and backward passes, run entirely at 4-bit precision. Developed by Hei Yi Mak, Shadan Golestan, Hoang Le, and a collaborative team of researchers, and published on arXiv in July 2026, this work directly addresses the massive computational and memory barriers of RL post-training for large language models. By moving the entire pipeline to 4-bit precision, this methodology is designed for machine learning systems engineers and researchers seeking to drastically reduce the infrastructure footprint of alignment algorithms without sacrificing downstream model capability.

The researchers' systematic diagnosis reveals that the primary failure mode in FP4 RL is not training-side quantization error, but rather rollout activation quantization. Outliers in the activation distribution stretch the dynamic range, causing a cascade of underflow errors where critical activation values round to zero. Crucially, the authors show that simply upgrading the training policy to higher precision while leaving the rollout policy in FP4 actually worsens performance due to a severe rollout-training distribution mismatch. To resolve this, the paper introduces Rollout-ResQ, a sparse, hardware-friendly residual correction term added to the FP4 rollout matrix multiplication. Rollout-ResQ mitigates outlier-driven underflow with minimal computational overhead. This is paired with the HiF4 format, which utilizes a three-level hierarchical scaling scheme to maximize representational resolution within a strict 4-bit budget.

Empirical evaluations on Qwen2.5-3B and Qwen2.5-Math-7B demonstrate that the combination of HiF4 and Rollout-ResQ narrows the accuracy gap to 16-bit brain floating-point (BF16) from 4.9% to a mere 1.1%. In comparison, applying the same method to the industry-standard MXFP4 format only closed the gap to 5.3%, highlighting the superiority of HiF4's hierarchical scaling. This work establishes a viable path toward end-to-end 4-bit RL post-training, potentially democratizing complex alignment procedures by allowing them to run on memory-constrained hardware. This analysis is based on the published abstract of the research paper.

Monolithic deployment designs for text-to-image (T2I) workflows on serverless platforms present significant resource efficiency and operational barriers. Because T2I pipelines typically consist of multiple distinct models, packaging them as a single, opaque GPU function inflates cold-start scaling overheads, demands manual low-level GPU coordination from users, and prevents fine-grained resource sharing in multi-tenant environments. ServerlessT2I, a serverless-native serving system introduced by Xiaoxiao Jiang and colleagues in a July 2026 arXiv paper, addresses this bottleneck by decomposing complex T2I workflows into loosely coupled, independently managed, and scheduled model functions. This system is primarily designed for cloud infrastructure engineers, machine learning platform developers, and distributed systems researchers seeking to optimize high-density, multi-tenant generative AI serving.

The architecture of ServerlessT2I relies on three core technical mechanisms. First, it enables declarative workflow composition paired with per-model scaling, allowing individual models within a T2I pipeline to scale up or down independently based on their specific utilization rates. Second, to mitigate the latency overhead of model loading and inter-function data transfer, the system introduces an in-memory data plane. This data plane harvests idle "slack" GPU memory—which remains unused during highly compute-bound T2I inference phases—to store intermediate state and facilitate transparent, GPU-resident communication. Third, ServerlessT2I incorporates a fair-share scheduler tailored for multi-tenant environments to balance throughput and latency across competing workloads.

Evaluated against production traces, ServerlessT2I demonstrates substantial resource efficiency gains, sustaining up to double the request rate of conventional T2I workflow serving systems under a fixed GPU budget. Alternatively, for a predefined request rate, it reduces overall GPU resource consumption by up to three times while continuously satisfying service level objectives (SLOs).

By transitioning from monolithic GPU function scaling to granular, model-level serverless orchestration, this work establishes a more sustainable blueprint for serving heterogeneous generative AI pipelines. It demonstrates how co-designing the scheduling layer with GPU memory characteristics can drastically reduce the cost of serverless deep learning. Note that this analysis is based on the published abstract and metadata of the research paper.

The research paper "Borrowed Strength: Best-of-N Search over a Code EncodingBreaks Self-Check Jailbreak Defenses," authored by Haoyu Zhang, Shibo Zheng, Xiangchen Guan, Zhuoxi Wang, Zijian Xiao, Mohammad Zandsalimy, and Shanu Sushmita, and published on arXiv (cs.AI/cs.CR), exposes a critical vulnerability in state-of-the-art self-check LLM defenses. Self-check mechanisms like SAGE, which command up to a 99% defense success rate by prompting the target model to evaluate its own inputs, are shown to be highly vulnerable to composed attack strategies. This work is essential for AI safety researchers, security engineers, and red-teamers designing robust alignment guardrails, as it demonstrates that defenses relying on the "borrowed strength" of the target model can be systematically dismantled by combining individually weak exploit techniques.

The core of the methodology lies in the joint composition of two previously low-yield attacks: a structured code-completion encoding and a Best-of-N search. While neither attack exceeds a 4.7% jailbreak success rate individually, their composition yields bypass rates between 15% and 67% across various open-source target models, maintaining efficacy on a 70B parameter model. This composition succeeds because self-check defenses do not natively detect adversarial intent; instead, they rely on the underlying model's capacity to recognize and refuse the prompt. The researchers show that target models convert self-check requests into explicit refusals between 32% and 97% of the time, creating a predictable variance in defense coverage.

Furthermore, the paper highlights a fundamental architectural asymmetry in LLM defense design. Against transform defenses, code encoding maintains most of its original reach, whereas against gate defenses, character-based search is more effective. This behavior is explained by the number of independent probes an attack delivers to a defense's decision boundary. Finally, the researchers identify and repair a critical validity defect in evaluation pipelines: under greedy decoding, deterministic attacks lack any Best-of-N variation channel, a flaw they address with a simple one-line diagnostic. This analysis is based on the paper's published abstract, which summarizes findings validated across 310,000 human-verified generations. Going forward, this work forces a reassessment of self-checking paradigms, proving that defense evaluations must account for composed multi-stage attacks rather than isolated threat models.

Real-world software vulnerabilities frequently span multiple functions, yet conventional learning-based detectors struggle because they analyze functions in isolation. To bridge this gap, Yikun Li and co-authors developed VulAgentRL, an agentic reinforcement learning framework designed to detect interprocedural vulnerabilities by actively gathering evidence across functions. Published on arXiv, this work is designed for software security researchers, program analysis engineers, and AI practitioners looking to scale precise vulnerability detection to complex, repository-level codebases.

The primary contribution of VulAgentRL is its novel dual-purpose utilization of a Code Property Graph (CPG), which serves as both an environmental interface and a precise verification oracle. In agentic reinforcement learning, agents often suffer from sparse or exploitable reward functions where a model can guess a vulnerability verdict correctly without performing any actual investigation. VulAgentRL solves this by using the CPG to ground the reward mechanism. During inference, the agent queries the CPG for callers, callees, and dataflow pathways. During training, the framework verifies the exact evidence paths cited by the agent. Because each node in the CPG contains a persistent integer identifier, verification is executed via exact graph matching rather than unreliable textual matching. This ensures that reinforcement learning rewards are only granted when the agent's final verdict is supported by verifiable structural evidence.

To overcome the challenges of bootstrapping agentic tool-use, the authors introduce a warm-start mechanism. Because reinforcement learning policies struggle to discover complex tool-use behaviors through random exploration, the authors initialize the policy by distilling traces from teacher investigations. This initialization proved essential for enabling the agent to learn effective CPG querying strategies.

In evaluations using a rigorous repository-level split to prevent data leakage, VulAgentRL outperformed state-of-the-art baselines and frontier large language models on strict pairwise-correct metrics while requiring fewer tool calls. Its performance advantages persisted under class imbalance and on out-of-distribution datasets. By shifting agent verification from ambiguous natural language reasoning to deterministic graph-based validation, this work establishes a new paradigm for building self-verifying, tool-using agents in automated software engineering. Note that this analysis is based on the published abstract of the paper.

Francesco Tosoni of the Wikimedia Foundation presents MediaWiki Code2Code Search, a novel neural retrieval system designed to overcome the lexical gap in discovering open-source software entities within large codebases. This work addresses the inherent limitations of traditional keyword-based search, which struggles to capture the semantic intent behind user queries, and the computational expense of deep learning models. The core contribution is a system that enables semantic discovery of code components like functions, types, and templates, by indexing over 1.29 million structural entities from more than 2,500 MediaWiki repositories.

This research is particularly relevant for software engineers and researchers working with complex, open-source ecosystems like MediaWiki, where finding relevant code snippets based on functional purpose rather than exact syntax is crucial for development, maintenance, and comprehension. The system's ability to bridge the semantic chasm makes it a valuable tool for both experienced developers and newcomers navigating unfamiliar code.

Key technical innovations include a split-build architecture that separates computationally intensive offline indexing from a CPU-only serving layer, ensuring low-latency query responses suitable for production environments like Wikimedia Toolforge. Furthermore, the utilization of a FAISS IVF-PQ index achieves a remarkable 96.6% reduction in index size compared to a flat baseline, while maintaining a median query latency of 1.85 seconds and adhering to strict memory constraints. Evaluation on a 27-query benchmark demonstrates significant improvements over the BM25 baseline, particularly in scenarios with name-obfuscated code, where lexical methods falter. The system is open-sourced under the Apache 2.0 license and offers a RESTful API.

Looking ahead, MediaWiki Code2Code Search paves the way for more intelligent and context-aware code search tools across the broader open-source landscape. Its success in the MediaWiki ecosystem suggests a potential paradigm shift towards neural retrieval for semantic code discovery, influencing the design of future IDEs, code documentation platforms, and collaborative development tools by enabling more intuitive and precise access to vast code repositories. This abstract is based on the provided arXiv submission details.

Lehan Wang and a team of nine researchers from various institutions (details not fully specified in the abstract, but common in large collaborative efforts) have introduced SecRespond, a novel benchmark for evaluating the capabilities of AI agents, particularly Large Language Models (LLMs), in post-compromise incident response scenarios. This work addresses a critical gap in current cybersecurity benchmarks, which predominantly focus on pre-compromise environments, leaving the complex realities of an active intrusion largely unassessed for AI agents. SecRespond is designed for security researchers, AI developers, and incident response professionals who aim to understand and improve the application of AI in cybersecurity operations.

The core contribution lies in the development of a realistic evaluation framework that simulates a compromised cloud host. Agents are provided with forensic disk snapshots, security alerts, and vulnerability scan results, and are tasked with generating detailed forensic reports identifying intrusions, assessing baseline and vulnerability risks, and proposing remediation plans. The benchmark is instantiated across ten diverse cyber ranges, encompassing four entry-point types, twenty-one MITRE ATT&CK techniques, and five operating systems, providing robust environmental variability. Key findings from the evaluation of twenty-three leading LLMs using the OpenCode agent harness reveal that while current AI agents can effectively process explicit alerts, they exhibit significant limitations in proactive threat hunting within disk artifacts and in generating comprehensive, verified remediation strategies. No tested model achieved complete detection and remediation across any single test range, highlighting a fundamental challenge in deploying AI for real-world incident response.

This research enables future advancements by providing a standardized, challenging evaluation platform. It will drive the development of more sophisticated AI agents capable of deeper investigative analysis and more robust response planning. The insights gained from SecRespond are expected to influence the trajectory of AI research in cybersecurity, pushing the field towards agents that can effectively operate within dynamic, post-compromise environments, thereby enhancing overall cyber resilience and defense capabilities. This paper's content is based on the provided abstract only.

This work introduces Think Short, Defer Smart (TSDS), a framework designed to optimize the deployment of Large Language Model (LLM) agents on edge devices. The core contribution is a novel method for managing the reasoning budget of these agents while ensuring reliability. It addresses the challenge of LLM agents performing complex, multi-step tasks, such as advanced question answering, code generation, and controlling physical systems, on resource-constrained edge hardware. The problem TSDS solves is the inherent trade-off between the computational cost of LLM reasoning and the need for accurate, safe decision-making. By intelligently deferring tasks that exceed the local model's capabilities to more powerful cloud-based models, TSDS aims to reduce latency and resource consumption on the edge. This research, authored by Amirmohammad Farzaneh and Osvaldo Simeone, was published on arXiv under the cs.AI and stat.ML categories.

TSDS is intended for software engineers and researchers working on AI systems, particularly those developing or deploying LLM-powered agents on edge devices. The benefits accrue to developers seeking to create responsive and efficient AI applications in environments with limited connectivity or processing power, as well as end-users who experience faster and more reliable interactions with edge AI. Two critical technical ideas underpin TSDS. First, a lightweight "convergence probe" is integrated to halt on-device reasoning once an intended action has sufficiently stabilized, preventing unnecessary computation. Second, a "perplexity-based deferral rule" dynamically assesses the uncertainty of the local LLM's output and escalates actions to a cloud-side model only when local confidence is too low for safe execution. These mechanisms are jointly calibrated using a "multi-objective Learn-Then-Test (LTT) procedure" that optimizes for both expected episode reward and cloud-call rate, providing finite-sample guarantees.

The results demonstrate significant reductions in per-episode thinking compute, ranging from 43% to 73% across several benchmark tasks including arithmetic reasoning, multi-hop question answering, code generation, and embodied planning, while maintaining certified performance and cloud-call rate guarantees. This work enables the practical deployment of sophisticated LLM agents on edge devices, paving the way for more pervasive and responsive AI. Its influence may lead to a paradigm shift in how edge AI is designed, favoring intelligent deferral strategies that balance local processing power with cloud capabilities, thereby advancing the field towards more efficient and robust AI systems. The content provided is an abstract only.

SymmGrid, introduced by Gabe Everett and colleagues from an undisclosed institution and published on arXiv, addresses the critical bottleneck of slow wall-clock training times in on-robot deep reinforcement learning. This work proposes a novel trajectory-level augmentation framework designed to significantly accelerate learning by leveraging parallelized symmetries within Markov Decision Processes (MDPs). The core contribution lies in modeling robot learning as an MDP with an underlying symmetry tree, where admissible invariant transformations can be applied to state-action pairs. This process generates a geometric grid structure, allowing for the generation of diverse and consistent experiences that populate the replay buffer, thereby speeding up convergence and improving final policy performance.

The primary problem SymmGrid solves is the prohibitive training duration for deploying reinforcement learning policies directly on physical robots. Traditional methods often require extensive data collection and simulation, which can be time-consuming and may not perfectly transfer to the real world. SymmGrid aims to fill this gap by enabling "super-scaling" of training data through exploiting inherent symmetries, making on-robot learning more practical and efficient. The intended audience for this work comprises researchers and engineers in robotics and AI, particularly those focused on real-world robot manipulation and embodied learning.

Two pivotal technical ideas underpin SymmGrid. Firstly, the framework models the MDP under a "symmetry tree," enabling the identification of parallelized invariant transformations that map one state-action pair to another while preserving their fundamental equivalence in terms of optimal policy. This allows for the systematic generation of a large number of synthetic, yet valid, trajectories from a smaller set of real-world observations. Secondly, the approach explicitly handles both egocentric and exocentric visual inputs alongside proprioceptive data. Crucially, proprioceptive information is warped using homographies to align with the spatial transformations applied to the visual scenes, ensuring consistency across different views and sensor modalities.

The implications of SymmGrid are significant. It enables substantially faster training convergence, with reported speed-ups ranging from 1.37x to 2.17x compared to state-of-the-art methods on contact-rich manipulation tasks such as peg insertions and cable routing. Furthermore, it leads to improvements in evaluation success rates and a reduction in the time required to reach optimal performance, sometimes down to minutes. This work pushes the field closer to achieving sub-10-minute on-robot learning for complex manipulation tasks, a critical milestone for enabling adaptable and rapidly deployable robotic systems. The concept of exploiting symmetries for data augmentation in reinforcement learning, particularly in the context of embodied agents, is likely to influence future research directions, potentially leading to more sample-efficient and scalable learning algorithms for real-world robotics. The content provided is an abstract only.

This work introduces DLAM, a novel Distributional Latent-Action model designed to bridge the gap between abundant action-free visual data and scarce robot-labeled action data for Vision-Language-Action (VLA) models. Developed by researchers including Zuojin Tang, Feifan Luo, and others from potentially academic or industrial research labs, and submitted to arXiv under the cs.AI and cs.RO categories, DLAM aims to enable more robust robot learning by learning temporal dynamics from observational data.

The primary problem DLAM addresses is the inherent limitation of existing latent action models that, while capable of extracting priors from action-free videos, often generate latent codes that lack the temporal structure necessary for joint generation with robot actions. Existing structured approaches, though incorporating temporal constraints, rely on deterministic transition points. This determinism can lead to error propagation and compounding when these inferred transitions are recursively composed, hindering long-term planning and prediction. DLAM tackles this by representing each temporal transition as a diagonal Gaussian distribution rather than a single point estimate.

Key to DLAM's success are two core technical ideas. Firstly, the mean of the transition Gaussian is grounded in observed visual change through reconstruction conditioned on a reference frame, ensuring the latent action is semantically tied to the visual environment. Secondly, DLAM imposes temporal constraints through normalized composition and reversal over equal-gap triplets. Normalized composition ensures that the composition of sequential latent actions adheres to certain structural properties, while reversal, which negates the mean and preserves variance, provides a mechanism for consistency checking. A novel aspect is the use of variance composition with a lightweight shared-correlation coefficient to model dependencies between adjacent transitions sharing an intermediate frame, allowing for more accurate representation of temporal uncertainty.

This research enables the development of VLA models that can learn more effectively from readily available, unlabelled video data. By inferring temporally consistent latent dynamics, DLAM can improve the performance of downstream reinforcement learning policies. The paper demonstrates improved direct and cumulative reconstruction on held-out videos and superior policy performance on benchmarks like MetaWorld MT50, LIBERO, and real-world manipulation tasks, under controlled transfer protocols. The findings suggest that DLAM's distributional approach to latent actions, particularly its constraints on mean and variance, offers significant advantages over deterministic methods and has the potential to significantly influence the field by enabling more sample-efficient and generalizable robot learning. This abstract-only information is based on the provided text.

Shaden Alshammari, Kevin Wen, Abrar Zainal, Mark Hamilton, Navid Safaei, Sultan Albarakati, William T. Freeman, and Antonio Torralba from various institutions have introduced MathNet, a substantial multimodal benchmark designed to evaluate the mathematical reasoning and retrieval capabilities of generative and embedding-based AI models. This work addresses a significant gap in current benchmarks, which often suffer from limited scale, linguistic diversity, and task variety, thereby hindering comprehensive assessment of AI's prowess in complex mathematical problem-solving. MathNet comprises over 30,000 Olympiad-level math problems and solutions sourced from 47 countries and 17 languages, spanning two decades of competitions, making it a globally representative and linguistically rich resource.

The core technical contribution of MathNet lies in its multimodal nature and the three distinct evaluation tasks it supports. Firstly, the "Problem Solving" task challenges models to generate correct solutions to mathematical problems. Secondly, "Math-Aware Retrieval" focuses on evaluating embedding-based systems by testing their ability to identify mathematically equivalent or structurally similar problem pairs, curated by human experts. This is a crucial advancement as it moves beyond simple keyword matching to semantic mathematical understanding. Thirdly, "Retrieval-Augmented Problem Solving" combines these two aspects, assessing how effective retrieval can enhance a model's problem-solving performance. Experimental results presented in the paper, submitted to ICLR 2026, highlight the current limitations of even state-of-the-art large language models like Gemini-3.1-Pro and GPT-5 on this benchmark. The retrieval component also reveals challenges for embedding models in discerning mathematical equivalence. Crucially, the work demonstrates that retrieval-augmented generation can yield significant performance gains (up to 12%) when retrieval quality is high, suggesting a promising direction for future research.

MathNet is intended for AI researchers and engineers working on advanced reasoning, natural language understanding, and retrieval systems, particularly those focusing on scientific and mathematical domains. The benchmark is poised to accelerate progress by providing a standardized and challenging evaluation framework. It will enable the development of more robust AI systems capable of not only solving mathematical problems but also understanding the nuanced relationships between different mathematical formulations. This work is expected to influence the field by driving research into more sophisticated multimodal reasoning architectures and more effective methods for semantic retrieval in specialized knowledge domains. The authors have made both the dataset and benchmark publicly available. The provided content is an abstract.

Ratchet introduces a novel approach to managing the lifecycle of skills within frozen Large Language Model (LLM) agents, aiming to overcome the limitations observed in prior self-evolving systems like Voyager. The core contribution is a single-agent loop designed for autonomous skill authoring, retrieval, curation, and retirement, with a focus on "hygiene" to ensure knowledge quality and prevent performance degradation. This work addresses the significant gap where, despite LLMs being capable of authoring skills, the actual utility of these LLM-generated skills is minimal compared to human-curated ones, primarily due to poor lifecycle management. The research, authored by Xing Zhang and collaborators from undisclosed institutions, was published on arXiv.

The intended audience is software engineers and researchers working with LLM agents and autonomous systems. Ratchet benefits developers seeking to imbue LLMs with persistent, improving capabilities without constant retraining, and researchers investigating the long-term viability and evolution of AI agents.

Key technical ideas include four candidate hygiene mechanisms: outcome-driven retirement, which removes underperforming skills based on their impact; a bounded active-cap, limiting the number of skills in use to prevent library bloat; meta-skill authoring guidance, where the LLM is prompted to generate skills that are easily discoverable and reusable; and pattern canonicalization, a mechanism for deduplicating similar skills, though ablations suggest this is subsumed by meta-skill guidance. A crucial result is the demonstration that Ratchet significantly lifts held-out pass@1 performance on MBPP+ hard-100 from a baseline of $0.258 \pm 0.047$ to a rolling mean of $0.584$ over 100 rounds, a substantial gain that also transfers to an agentic solver on SWE-bench Verified. Importantly, a non-divergence proposition proves that bounded cap and retirement thresholds prevent expected performance from drifting significantly below the no-skill floor.

This work enables the creation of LLM agents that can continuously learn and adapt their skill sets in a robust and non-degrading manner, moving beyond static knowledge bases. It suggests that the focus for self-evolving agents should shift from pure skill generation to sophisticated lifecycle management. Ratchet's minimal, hygiene-focused recipe has the potential to influence the field by providing a framework for building more capable and reliable long-term AI agents. The paper content is an abstract only.

This work introduces Agent-UCT, a novel tree search algorithm designed to optimize complex agentic workflows, particularly those in retrieval-augmented generation (RAG) pipelines. The core contribution lies in its cost-aware approach, addressing the challenge of navigating large, combinatorial search spaces of discrete component choices under strict evaluation budgets. Existing methods often struggle with this by failing to exploit the inherent compositional structure of these workflows, leading to inefficient resource allocation and repeated computations. Agent-UCT extends the standard Upper Confidence Bounds applied to Trees (UCT) algorithm by incorporating a "reuse-aware" regularization term. This term is derived from a bipartite prefix reuse graph, incentivizing the search to favor branches that build upon previously materialized configuration prefixes. This mechanism effectively reduces redundant execution while ensuring robust exploration of the search space. The research, authored by Yang Li and a team of ten co-authors from various institutions including those implicitly involved in the development of LongRAG, LightRAG, and Self-RAG, was submitted to arXiv under the Computer Science (AI) category. The intended audience comprises software engineers and researchers working with complex AI systems, especially those deploying or developing RAG pipelines, who face resource constraints and seek to maximize performance within limited evaluation budgets. The most important technical ideas are: 1) Agent-UCT's novel regularization term that explicitly biases exploration towards reusable workflow prefixes, directly tackling redundant computation; 2) the RAGSpace framework, which unifies diverse RAG components into a structured, multi-dimensional configuration space for systematic exploration and recombination; and 3) the Workflow Test Bench (WTB) providing deterministic replay, content-addressable caching, and transactional consistency, crucial for ensuring that intermediate states are materialized only once and efficiently reused across the search. This integrated framework enables cost-aware, reproducible, and compositionally efficient optimization of agentic workflows. Going forward, Agent-UCT offers a significant advancement for efficiently discovering high-performing configurations in complex, budget-constrained AI systems. Its success in reducing search cost and improving wall-clock speed suggests a broad applicability to other domains involving hierarchical or compositional search problems, potentially influencing the development of more resource-efficient and performant AI agents. The provided text is an abstract only.

The work presented in "MemAgent: Reshaping Long-Context LLM with Multi-Conv RL-based Memory Agent," authored by researchers including Hongli Yu, Tinghong Chen, and Wei-Ying Ma from institutions affiliated with the ICLR 2026 conference, addresses the fundamental challenge of processing extremely long documents without performance degradation. The core contribution is MemAgent, a novel workflow that enables large language models (LLMs) to handle sequences of virtually unlimited length by processing text in segments and employing an efficient, overwrite-based memory update strategy. This approach fundamentally reshapes how LLMs interact with context, moving beyond current limitations of fixed context windows and the complexities of extrapolation methods that often result in performance decay.

This research matters because current LLMs, despite advancements in attention mechanisms and memory modules, struggle to efficiently and accurately process documents that exceed their training context lengths. The gap it fills is the development of a robust, end-to-end trainable system that achieves near-linear complexity in handling arbitrarily long texts while maintaining high performance. The intended audience is primarily software engineers and researchers working on LLM development, natural language processing, and large-scale text analysis. Those who benefit include practitioners building applications requiring deep comprehension of extensive documents, such as legal case analysis, scientific literature review, and complex narrative understanding.

Two critical technical ideas underpin MemAgent. First, the introduction of an "agent workflow" that orchestrates text segmentation and memory management is key. This agent reads the document sequentially, processing it in manageable chunks. Second, a sophisticated "overwrite strategy" for memory updates is employed. Instead of trying to retain all past information, the agent selectively updates its memory based on relevance and task objectives, preventing quadratic complexity and memory bloat. The paper also highlights the extension of the DAPO algorithm to facilitate training via "independent-context multi-conversation generation," allowing for more robust learning across varied conversational scenarios within the long-context setting. A significant result is MemAgent's demonstrated ability to extrapolate from an 8K context window trained on 32K text to a 3.5 million token question-answering task with less than a 5% performance loss, and achieving over 95% on a 512K RULER test.

Going forward, MemAgent enables the creation of LLMs that can truly engage with and reason over entire books, vast codebases, or extensive historical archives as if they were part of a single, coherent context. This could significantly influence the field by democratizing access to powerful long-context understanding, fostering new research into agent-based LLM architectures, and driving the development of more capable AI systems for complex, real-world information processing tasks. The presented work is an abstract.