Your paper timeline
Scroll AI takes the way you would scroll a great paper aggregator: quick signal first, deeper critique when something earns your attention, and challenges when a claim feels off.
1579 papers
Trending mixes fresh papers with community signal.
0
cs.CLcs.AIcs.SD Sangmin Lee, Yejin Jeon, David Ifeoluwa Adelani · Oct 14, 2026

Multilingual speech technologies still fail to reach most of the world's languages because existing corpora are limited to a few hundred well-resourced languages and narrow domains like parliamentary proceedings or Bible readings. ELARSpeech addresses this gap by curating 30,202 hours of speech across 675 underrepresented languages from the Endangered Languages Archive, yielding both labeled and unlabeled subsets with rich acoustic and communicative diversity. It matters because it provides a large-scale, publicly available testbed that reveals existing self-supervised speech models struggle on the true linguistic long tail despite massive pretraining.

Massively multilingual speech modeling has made remarkable progress in recent years, yet existing training resources and benchmarks still underrepresent much of the linguistic long tail. To address this gap, we introduce ELARSpeech, a large-scale multilingual speech resource comprising 30,202 hours of speech across 675 underrepresented languages, curated from the Endangered Languages Archive. Combining human-annotated and unlabeled recordings, the corpus spans diverse recording conditions, domains, and language families. Beyond corpus construction, our experiments show how ELARSpeech supports extending ASR and TTS capabilities to diverse underrepresented languages, with further benefits from pseudo-labeling unlabeled data. At the same time, our speech representation analysis reveals remaining limitations in transferring existing multilingual models to the linguistic long tail. Together, ELARSpeech provides both a resource and a testbed for extending multilingual speech technology further into the linguistic long tail. We publicly release the dataset, all trained ASR and TTS models, and the complete data construction pipeline to facilitate research on long-tail multilingual speech technologies.
0
cs.AI Jiarui Qin, Junjie Huang, Yunjia Xi et al. · Oct 14, 2026

Base models are hard to evaluate on agentic tasks because standard benchmarks assume instruction-following chat interfaces. ASAP adapts existing agent scaffolds to pretrained base models by treating execution as text continuation, using a Markdown+XML format, a short reference trajectory prefix, and minimal failure recovery. The framework yields discriminative end-to-end scores across models and checkpoints, and exposes execution trajectories that enable fine-grained behavioral diagnosis before post-training.

Agentic capabilities are increasingly important for modern LLMs, yet remain difficult to evaluate during pretraining. Existing approaches typically rely on static trajectory-derived tasks or likelihood-based proxies, which are lightweight but provide limited visibility into how base models behave in interactive environments. We introduce ASAP (Agent Scaffold Adaptation for Pretraining Evaluation), a lightweight framework for eliciting and evaluating agentic behavior from pretrained base models on end-to-end tasks. Rather than converting base models into chat-style agents, ASAP preserves the completion interface and adapts existing agent scaffolds through structured trajectory continuation, short reference prefixes, and minimal recovery mechanisms. Across software-engineering and deep-research benchmarks, ASAP yields discriminative end-to-end performance across base models and pretraining checkpoints. Beyond aggregate scores, ASAP exposes model-generated execution trajectories, enabling analysis of exploration, editing, testing, recovery, and task completion across training stages. These trajectories provide a behavioral view of how agent-relevant capabilities change during pretraining and how execution patterns differ after post-training. Our results suggest that end-to-end agent evaluation can complement conventional pretraining benchmarks by providing a practical diagnostic of interactive model behavior.
0
cs.AI Guanhua Zhu, Hanwen Li, Zhi Wei et al. · Oct 14, 2026

STRATA tackles the problem of scalable, self-maintaining memory for test-time self-evolving LLM agents. Instead of a flat, monotonic pool of episode summaries, it organizes experience as a typed three-layer directed graph of atomic skills, task workflows, and meta-frameworks, maintained by five mechanisms including multi-dimensional similarity, adaptive reflection thresholds, community detection, pressure-triggered garbage collection with articulation-point protection, and contrast edges that warn against directionally opposite experiences. The authors show that this structured memory attains the best average accuracy across four interactive benchmarks while simultaneously using the lowest latency, fewest environment steps, and fewer injected memory lines than seven memory-augmented baselines.

Large language model (LLM) agents can self-evolve at test time by accumulating experience: retrieving relevant memories before acting and writing new lessons back afterwards. Yet most are single-level: trajectories, distilled workflows and reasoning items all land in one undifferentiated pool indexed by embedding similarity, with no typed abstraction hierarchy. They never forget or deduplicate, and are prone to negative transfer, where a superficially similar but directionally opposite experience is recalled and its concrete steps are copied verbatim, actively harming the agent. We introduce STRATA, a structured, outcome-grounded, self-maintaining memory that organizes experience into a three-layer graph of atomic skills and code snippets, task workflows and generalized meta-frameworks, connected by typed edges. STRATA maintains itself through five mechanisms sharing one similarity geometry: a multi-dimensional similarity that scores retrieval by operation and target; a typed reflector crystallizing procedures from successes and pitfalls from failures; community detection that induces meta-frameworks; pressure-triggered garbage collection with articulation-point protection; and contrast edges that flag confusable, direction-opposite experiences. Across four interactive benchmarks (AppWorld, WebArena, ALFWorld, ScienceWorld), two frozen backbones and seven baselines, STRATA attains the best average score while simultaneously using the lowest latency and fewest environment steps of any memory-augmented method, and 44% fewer lines of injected memory than the most context-hungry baseline. We isolate two failure modes of prior memories: single-level memory degrades sharply as the task set grows, and single-level concrete memories suffer catastrophic negative transfer, which contrast edges repair, lifting ScienceWorld from 78.7 to 96.7 within the same system.
0
cs.AIcs.DC Anshu Raina, Peyman Razaghi, Yuankai Chen et al. · Oct 14, 2026

Configuring distributed LLM training over hundreds of GPUs involves a combinatorial explosion over tensor, pipeline, expert, context, and data parallelism plus micro-batch size, recomputation, and sharding, where a single byte of activation accounting can separate a legal run from an OOM crash. This paper proposes Primus Projection, a hybrid engine that benchmarks compute kernels on as few as one GPU and analytically reconstructs out-of-scope communication and pipeline schedules at the target scale, coupled with an LLM-driven tuning agent that searches the space in minutes instead of days. The authors validate across dense and MoE models on two AMD GPU generations, reporting projection errors around $5\%$ at up to 1,024 GPUs and a $+27\%$ throughput gain discovered in under 30 minutes of single-node exploration.

Configuring distributed LLM training across hundreds of GPUs requires jointly optimizing tensor, pipeline, expert, context, and data parallelism alongside micro-batch size, recomputation, sharding, and overlap, a combinatorial space where memory legality can hinge on a single byte of activation accounting. Today, teams navigate it through expensive multi-node trial and error, burning GPU-hours on crashes and suboptimal recipes. We present Primus Projection, which closes this loop with two coupled components. First, a hybrid projection engine that measures what it can and simulates what it cannot: GPU microbenchmarks on as few as a single device capture compute kernels and any in-scope communication; a sub-node downscale-measure-upscale workflow analytically restores out-of-scope collectives, FSDP overlap, and the full pipeline schedule at the multi-node target. A pure simulation mode runs entirely on CPU, enabling pre-silicon planning without any GPU. Second, the Primus Tuning Agent treats the projection engine as a fast scoring oracle (seconds per candidate instead of tens of minutes) and uses it to drive an intelligent search over the configuration space. A deterministic seed planner sweeps single axes; an LLM investigation loop proposes cross-axis combinations the planner cannot reach, with an analytic memory pre-filter that rejects infeasible candidates before any GPU time is spent. Validated on Llama 3.1 (dense) and Mixtral 8x22B (MoE) across two GPU generations, all projections stay within ~10% of measured multi-node throughput, and fidelity holds at production scale: 4.7% error on DeepSeek V3 671B at 1,024 GPUs and 1.9% on Qwen3-235B-A22B at 256 GPUs. In a Mixtral 8x22B case study, the Primus Tuning Agent discovers a configuration delivering +27% throughput over the published 4-node BF16 reference at the same scale, in under 30 minutes of single-node exploration.
0
cs.AI Han-Sang Lee, Kyuho Lee, Juneyoung Park et al. · Oct 14, 2026

ixi-sLM tackles the problem of running an AI call agent entirely on a mobile device under constraints that cloud deployments never face: roughly 1 GiB of memory, in-call thermal limits, static-integer NPU execution, Korean STT input riddled with disfluencies, and user expectations set by cloud LLMs. The core idea is to take a 1.2B-parameter Korean sLM and apply two service-specific optimizations—domain-adaptive vocabulary trimming and tokenizer merging to shrink footprint and token counts, followed by task-aware mixed-precision quantization calibrated on real calls—to squeeze the model onto Qualcomm and Apple NPUs. It matters because the authors claim a live production deployment serving several million subscribers at 94% of an unnamed cloud LLM's quality, cutting per-call energy to 23% of a CPU baseline.

Running an AI call agent on-device makes it private, network-independent, and free of per-query cloud cost, but shipping one as a real-world service imposes constraints a cloud deployment never faces: ~1GiB memory budget, in-call latency and thermal limits, static-integer NPU execution, Korean STT input far from sLM pretraining, and cloud-level quality expectations. We bring ixi-sLM, a 1.2B Korean sLM, to mobile NPUs through ON-DEVICE MODELING: domain-adaptive modeling trims the vocabulary by call frequency to shrink the embedding and LM head that take nearly half the model under INT4 transformer weights and refits the tokenizer to call speech (18% fewer tokens on call traffic), while task-aware quantization calibrates on real calls and assigns per-module mixed precision by activation sensitivity. A single domain-adapted model runs ixi-O's two production services, AI Call Summary and AI Call Answering, at 94% of a state-of-the-art cloud LLM's task-weighted quality; our on-device modeling carries that quality onto the NPU with only a marginal drop in overall score, in an 803MiB model (28% of FP16) at 23% of the CPU's per-call energy. The same recipe deploys across Qualcomm and Apple NPUs and serves several million ixi-O subscribers in production.
0
cs.AI Chenxu Wang, Xiaoyu Wen, Han Qi et al. · Oct 14, 2026

LLM agents face an expanded attack surface because malicious content can hide in user queries, tool descriptions, and environment observations. AgentSafeEvo casts agent safety as an attacker-defender co-evolutionary game over multi-turn tool interactions, where the attacker constructs full adversarial tasks and the defender learns to execute tasks safely. A novel learnability-guided task weighting mechanism uses within-task reward variance to shape updates for both players. Experiments on Qwen3-8B show strong safety gains and broad preservation of general capabilities.

Large language model (LLM) agents accomplish complex tasks through multi-turn interactions with external tools. However, malicious content embedded in user queries, tool descriptions, or environment observations can manipulate their decisions and induce unsafe actions. Adversarial co-evolution has emerged as an effective approach to strengthening LLM safety, but existing work primarily focuses on language-level safety or indirect prompt injection in web tasks. In this paper, we introduce AgentSafeEvo, a co-evolutionary reinforcement learning framework for agent safety built on an attacker-defender game spanning diverse tasks and attack types. The attacker learns to construct adversarial agent tasks that expose weaknesses in the defender's tool use, while the defender learns to complete tasks safely under these attacks. We further introduce learnability-guided task weighting, which uses within-task defender-reward variability to adjust each task's contribution to attacker and defender updates. Extensive experiments on agent safety and general capability benchmarks demonstrate that our method improves adversarial robustness while maintaining general agent capabilities.
0
cs.AI Guanhua Zhu, Bo Shen, Lei Zhang et al. · Oct 14, 2026

EvoWeave addresses how interactive agents can reuse past experience without importing entire workflows or discarding step dependencies. It proposes a graph memory where nodes are abstract states and edges are reusable operations annotated with contracts, provenance, and capability references; a task planner guides retrieval and bounded graph search to assemble experience fragments. Experiments across four benchmarks and three LLM backbones show heterogeneous gains and highlight tradeoffs between retrieval precision and runtime overhead.

Different tasks often require interactive agents to perform similar operations at intermediate steps. Retrieving an entire past workflow can introduce irrelevant steps, whereas retrieving isolated operations can discard the dependencies needed to reuse them. We introduce EvoWeave, a framework for experience memory that represents abstract states as nodes and reusable operations as directed edges with input and output contracts, provenance, and capability references. A planner decomposes the current task into a dependency graph; operation retrieval and bounded directed search then assemble relevant experience fragments. An execution agent can inspect these fragments and their referenced capabilities, while reflection separates concrete execution evidence from reusable abstractions. We study the framework across four benchmarks, five evaluation settings, and three language model backbones. Across backbones, AppWorld Normal and Challenge task goal completion average 51.91 and 27.99, respectively, exceeding the baseline without memory by 6.99 and 4.99 percentage points. An AppWorld ablation associates directed connections with an additional improvement of 2.08 points over independent operation cards. The results motivate composition of reusable operations while exposing tradeoffs in retrieval overhead and conditions for valid reuse.
0
cs.PLcs.AI Hang Lin · Oct 14, 2026

Program synthesis and library learning generate useful operations, but the resulting artifacts are often treated merely as derivations or search traces rather than reusable operational objects. This paper introduces FormCraft, a framework that represents both primitive and composed operations as first-class capabilities in a uniform well-formed space $\mathfrak{F}$, separating instance-independent formation and public callability from optional persistence through a verification gate. By retaining formation provenance while exposing composites through the same public interface as primitives, the framework aims to make persistent library growth possible and to eliminate the need to reconstruct historical derivation chains at reuse time, a claim backed by a paired experiment showing orders-of-magnitude reductions in search work.

We introduce FormCraft, a framework for representing acquired operations as first-class capabilities that can be recursively composed, directly invoked, and selectively retained in a persistent library through domain-specific verification. The framework separates capability well-formedness and public callability from later admission to persistent storage while preserving formation provenance and operational identity. We formalize recursive compositional closure over a uniform capability space and show that formed composites can be reused through the same public interface without re-forming their historical derivation. Experiments across continuous, discrete, propositional, and sequence domains demonstrate instance-independent reuse, independent checking, persistent acquisition, and reduced reuse-time search work under first-class exposure.
0
cs.DCcs.AIcs.LG Javad Mirzaei, Jeebak Mitra · Oct 14, 2026

Choosing a parallelism configuration for distributed LLM inference is challenging because the prefill and decode phases impose conflicting demands on time-to-first-token (TTFT) and inter-token latency (ITL). This paper develops a systematic framework that defines parallelism operating regions via TTFT-ITL Pareto frontiers and formulates SLO-aware selection using goodput $G_p(w,T_s)=\lambda_p(w)F_p(T_s|w)$. The core finding is a workload-dependent transition: tensor-parallel (TP) configurations excel for decode-heavy workloads and relaxed latency requirements, while pipeline-parallel (PP) configurations dominate for prefill-heavy workloads, stringent TTFT targets, and long contexts. The work matters because it moves parallelism selection from a static deployment choice to a workload- and SLO-dependent operating decision.

Large Language Model (LLM) serving systems must balance latency and throughput while efficiently utilizing distributed GPU resources. This challenge arises because inference consists of two fundamentally different phases: prefill, which determines time-to-first-token (TTFT), and decode, which determines inter-token latency (ITL). The use of tensor parallelism (TP), pipeline parallelism (PP), and hybrid configurations exposes different trade-offs between these latency dimensions, making the optimal parallelism configuration highly dependent on workload characteristics, latency requirements, and context length. Moreover, despite the widespread adoption of distributed inference, there is still limited understanding of how parallelism configurations should be selected under varying workload conditions and service-level objectives (SLO). In this paper, we develop a systematic framework for characterizing LLM inference parallelism via throughput-latency trade-offs, SLO-aware serving, and long-context scalability. We introduce the notion of parallelism operating regions by constructing TTFT-ITL feasible sets and Pareto frontiers across different workload compositions, thereby revealing a systematic transition from TP-dominant to PP-dominant configurations as workloads become increasingly prefill-heavy. We further formulate SLO-aware parallelism selection using goodput, showing that stringent TTFT requirements favor PP-dominated configurations, whereas relaxed latency constraints progressively shift the optimality toward TP-dominated configurations with higher serving capacity. Finally, we demonstrate that increasing context length fundamentally changes the relative advantages of parallelism configurations, with PP-dominant configurations exhibiting more favorable scalability and SLO attainment in the long-context regime.
0
cs.AI Tianle Chen, Pushkar Singh, Ketan Todi et al. · Oct 14, 2026

Long-horizon language agents frequently re-issue identical tool calls and receive redundant observations, a failure mode the authors call a loop. The paper shows that compressing the agent's history to fit a context window dramatically increases these loops, which in turn strongly predict task failure. DeLoop solves this by mining preference pairs directly from the agent's own rollouts—treating the looping action as a rejected example and the first later non-looping action as a chosen one—and training with direct preference optimization without any external rewards, gold answers, or LLM judges.

Language-model agents that run long tasks often redo work they have already done: they re-issue a tool call they made earlier and get back exactly the same observation, a step that adds no new information. We identify this failure as a loop. Loops appear natively in Qwen, Llama, and Gemini agents and become far more common once the agent's history is compressed to fit its context window. To reduce these loops, we propose DeLoop, a self-supervised training method. DeLoop builds on a simple observation: the agent's own rollout can provide the supervision needed to learn from its loops. We use a looping action as a negative example and the first later non-looping action in the same rollout as a positive example. DeLoop learns from these pairs through direct preference optimization and does not require task rewards, gold answers, or LLM judges. On CodeGym under compression, DeLoop reduces the share of Qwen3-8B tasks containing loops from 57.3% to 6.1%. It also uses about one third as many steps per task, with similar task success. On Qwen3-32B, DeLoop reduces loops and steps while raising task success from 37.7% to 44.8%.
0
cs.CLcs.AI SungHo Kim, Eojin Jeon, SangKeun Lee · Oct 14, 2026

KoAGE investigates whether large language models can know, learn from context, and coin Korean neologisms. The authors introduce NeoTrace, an automated pipeline that collects and dates 4,271 neologisms across six genres, and propose a cutoff-aware benchmark that separates lexical recall from contextual inference and generation. By comparing model outputs with attested human coinages under original materials and simulated community settings, the paper offers a temporally grounded view of how models adapt to evolving vocabulary.

Korean neologisms arise through diverse mechanisms, a demanding test of language models beyond lexical memorization. To enable systematic evaluation, we introduce NeoTrace, an automated, rerunnable framework that collects and dates neologisms across genres. Its 4,271 entries support KoAGE, a cutoff-aware benchmark with three acquisition and two generation tasks---the latter, to our knowledge, the first to compare model coinages with attested neologisms under their original materials and community context. Across 21 models, lexical recall diverges from contextual inference: in a five-model temporal analysis, models define only 13-30% of cutoff-year words, yet can infer meaning from one usage. However, structural understanding remains limited: even correct definitions barely improve formation analysis of pre-cutoff neologisms. Given word-building materials, single models often follow human formation mechanisms, whereas multi-agent coinage favors abbreviation and depends on interaction framing. KoAGE thus separates what models know, learn from use, and coin.
0
cs.CLcs.AI Minsu Oh, Seunghui Jwa, Chanjun Park et al. · Oct 14, 2026

This paper exposes a critical flaw in how compressed memory is evaluated for large language models: standard ablation tests like zeroing memory vectors do not prove that stored document content improves predictions. The authors distinguish three empirically separable questions—whether a model depends on memory after training, whether training with memory outperforms training without it, and whether gains actually require document content—and argue that evaluation claims must be matched to specific controlled comparisons. Across nine memory systems and multiple QA benchmarks, they show these comparisons frequently lead to different conclusions, calling for stricter evidentiary standards in context-compression research.

Does a language model answer better because its compressed memory contains useful document information? Replacing memory vectors with zeros can lower a trained model's score without showing that it outperforms a model trained without memory. We combine zeroing with separately trained models that cannot access stored text or receive the same constant input for every document. Across nine systems, some models rely on memory yet perform worse than the trained alternative. For example, in experiments that predict states in generated stories, zeroing memory worsens a model's prediction loss, yet a model trained without memory achieves lower loss than the original model with intact memory. On TriviaQA, giving xRAG memory from another question's passage raises F1, which measures word overlap with accepted answers, from 19.38 without a document to 24.78. Its effect on how often outputs contain an accepted answer is statistically uncertain. The question's retrieved passage scores higher still (29.88 F1). Thus a gain over no document alone does not establish that the gain requires the question's passage. Evaluations must therefore specify the comparison model, absolute performance, and generation and scoring conditions.
0
cs.LGcs.AI Min-Young Yu · Oct 14, 2026

Policy-Verified Self-Training asks whether a runtime policy gate's discarded verdicts can be recycled as training signals for the same agent. The paper proposes PVST: an agent rolls out trajectories, a deterministic gate compiled from written policy judges compliance, and the verdicts become acceptance filters and preference labels. On AgentDojo prompt-injection benchmarks, post-training Qwen3-8B with these verifier-derived rewards cuts violating trajectories from 37.2% to 10.3% and successful attacks to 0.5% without any stronger teacher model, human preference labels, or attack-specific supervision. The result suggests that compiled policy checkers can serve not only as runtime constraints but as a scalable, auditable source of self-training supervision.

Runtime policy verifiers can prevent agents from executing disallowed actions, but their decisions are typically used only for enforcement and discarded afterward. We ask whether these decisions can instead become verifiable policy rewards for training the agents they guard. We introduce Policy-Verified Self-Training (PVST), a post-training paradigm in which an agent generates its own interaction trajectories and an executable policy verifier, here a deterministic gate compiled from a written policy, evaluates whether each action complies. Compliant trajectories are reinforced, and violations become negatives for preference optimization; beyond the gate and the benchmark's task-success signal, PVST needs no stronger teacher model, no human preference labels and no attack-specific supervision, although rollouts are collected in the benchmark's attacked environment. On held-out AgentDojo tasks under prompt injection, policy-verified preference training of Qwen3-8B reduces violating trajectories from 37.2% to 10.3 $\pm$ 0.9% (three seeds) and successful attacks from 12.4% to 0.5% at equal or higher pooled task utility, although utility falls on travel, compared with 22.0% when negatives are selected by an attack oracle and 31.9 $\pm$ 0.9% with negatives that contain no violation. The learned behavior holds under an attack template never used in training (37.7% to 11.0%) and on a suite excluded from training (34.8% to 16.7%), and the retained verifier's intervention rate falls from 39.2% to 8.8% (seed 0). Our analysis identifies two conditions under which the verdict is most informative: success must not already imply compliance, and guarded actions must appear in both permitted and forbidden contexts.
0
cs.CLcs.AI Thomas Zeng, Zelei Cheng, Mingyang Zhou et al. · Oct 14, 2026

LLM agents frequently fail in multi-turn settings by violating policies, using tools incorrectly, or acting prematurely. This paper proposes Critique-Augmented Agentic Fine-Tuning (CAFT), which rolls out a student agent, has an expert label each wrong turn with both a textual critique and a corrected action, and then fine-tunes the student to generate that critique and correction while keeping the original mistake in context. The central finding is that these natural-language explanations provide learning signal beyond action-only supervision, improving task success across four models and two benchmarks.

Large language models (LLMs) are increasingly used for multi-turn agentic tasks that require interactions with users and environments over extended sequences of actions. A common approach to improving LLM agents is to use more capable expert models to provide training supervision, either by behavior cloning the expert's trajectories or by using the expert to correct the actions in trajectories generated by the weaker student model. However, expert LLMs can provide richer supervision than actions alone: they can directly generate textual critique that explain why specific actions are incorrect. We study whether training on such feedback benefits LLM agents and propose Critique-Augmented Agentic Fine-Tuning (CAFT), a framework that elicits textual expert feedback on student-generated trajectories. For each incorrect action, the expert yields both a corrected action and a textual critique explaining the student's mistake--which we then use as the training target for fine-tuning. Across four student models from the Nemotron 3 and Gemma 4 families on the agentic domains $\tau^2$-Bench Airline+Retail and WebShop, adding critiques to action-level supervision improves performance by 8% on average over action-only distillation. Additionally, CAFT checkpoints can also provide a better warm start for reinforcement learning than expert-trajectory distillation. Our results demonstrate that textual critiques can strengthen supervision for multi-turn LLM agents.
0
cs.AIcs.CLcs.RO Minghao Guo, Qingyue Jiao, Xiujin Liu et al. · Oct 14, 2026

Multimodal agents need persistent memory to act coherently over long horizons, yet forming and managing memory across heterogeneous, high-dimensional observations—video, audio, 3D geometry, and GUIs—has lacked a unifying analytical lens. This survey introduces a two-axis lifecycle framework that classifies how experience is represented (source, textual, structured, latent, or parametric) and how memory states and policies evolve ($T1$ Static, $T2$ Dynamic, or $T3$ Self-Evolving). By analyzing 297 architectures, the authors identify key trade-offs between fidelity and efficiency and expose the striking scarcity of systems that evolve their own memory policies at deployment time.

Multimodal models and agents have emerged to enable AI systems to learn from and interact with the real world more like humans by integrating information across multiple modalities. However, enabling multimodal agents to continually acquire useful information from complex, heterogeneous multimodal data remains a significant challenge as they move toward long-horizon tasks and lifelong settings. Addressing this challenge requires effective memory mechanisms that can maintain continuity across sessions, adapt to changing users and environments, and refine memory-management policies through accumulated experience. We introduce a two-axis analytical framework for multimodal agent memory structured around two key questions: how multimodal information is formed and represented (Axis I, Formation and Representation), and how its management adapts with accumulated experience (Axis II, Memory Management). Axis I, Formation and Representation, characterizes what information is retained and how it is encoded (e.g., modality-specific embeddings, textual and structured records, latent and parametric representations) to support subsequent reasoning and action. Axis II, Memory Management, distinguishes three tiers: T1 Static Memory reuses fixed memory; T2 Dynamic Memory updates memory through a stable policy; and T3 Self-Evolving Memory updates memory through an evolving policy. Based on this framework, we synthesize recurring design patterns and derive principles for balancing source fidelity with abstraction, maintaining temporal validity and provenance, grounding memory use in recoverable evidence, and evolving memory policies over time. Furthermore, we discuss the challenges and potential future directions for the memory mechanism of multimodal agents.
0
cs.AI Tianzhuo Yang, Shaoheng Yan, Lin Lu et al. · Oct 14, 2026

DangerLens asks whether two language models with identically safe refusal behavior can still differ in how much hazardous knowledge remains internally accessible. The authors train paired Qwen1.5 checkpoints—one directly safety-aligned, the other first exposed to harmful data then aligned to the same standard—and introduce a vocabulary-space probe that uses a Jacobian lens and blinded semantic scoring to count harmful goals and operational means inside hidden states. The work matters because current safety audits rely on surface behavior alone, leaving latent dangerous representations undetected before downstream fine-tuning or attacks.

Safety alignment teaches language models to refuse harmful requests, yet the internal accessibility of hazardous concepts can retain traces of earlier training. Can checkpoints with equally safe behavior differ in what remains accessible behind their refusals? In this work, we investigate this question through paired training histories and a direct audit of intermediate representations. We introduce DANGERLENS, a probe that maps hidden states into vocabulary space and uses blinded semantic judgments to distinguish harmful goals and operational means from hazard recognition and safety control. Experiments on three Qwen1.5 scales show that checkpoints with prior harmful exposure generally retain greater hazardous concept accessibility after the same safety alignment, with the strongest separation in intermediate and later layers. The same harmful update also produces different behavioral trajectories from closely matched starting points. Human relevance validation and readout ablations reinforce the measured accessibility contrast. Our findings show that training history remains visible inside behaviorally matched models and motivate internal accessibility audits alongside output safety evaluations.
0
cs.CLcs.AIcs.LG Taro Yano, Yoichi Ishibashi, Masafumi Oyamada · Oct 14, 2026

Best-of-N sampling improves LLM output quality by generating multiple candidates and selecting the highest reward, yet its scaling behavior under imperfect reward models is poorly understood. This paper recasts BoN as extreme-value competition between the upper tails of correct and incorrect reward distributions, yielding phase transitions that explain both monotonic gains and reward hacking. Using extreme value theory, the authors derive finite-sample scaling laws showing polynomial rather than exponential convergence, and propose a lightweight tail-tension criterion for label-free early stopping. The work matters because it replaces vague intuitions about reward hacking with precise, testable distributional conditions and a practical inference-time safeguard.

Best-of-N sampling is a simple inference-time scaling strategy for large language models, yet its behavior under incomplete reward models remains poorly understood. We study Best-of-N as a competition between the extreme reward tails of correct and incorrect responses. This view shows that success depends not only on the probability of sampling a correct response, but also on whether correct responses dominate incorrect ones in the upper tail. Using extreme value theory, we characterize three asymptotic regimes: correct-tail-dominant, incorrect-tail-dominant, and critical explaining both monotonic gains and reward-hacking-induced degradation. We further derive finite-sample scaling laws for representative reward distributions, showing that, under Gaussian rewards, incorrect responses with sufficiently large variance can dominate selection even when their mean reward is lower. Unlike oracle selection, convergence with an incomplete selector can be polynomial rather than exponential. Finally, we propose a lightweight tail-tension criterion to estimate when additional sampling may become harmful. Experiments on synthetic data and real reward model scores are consistent with the theoretically predicted regimes, scaling laws, and diagnostic behavior, suggesting that tail competition provides a unified lens on Best-of-N sampling for verifiable problems.
0
cs.AIcs.CLcs.LG Weilun Xu (EPFL), Zipeng Sun (McGill University, Mila) · Oct 14, 2026

Activation steering is used to steer language models toward named behaviors, but standard baselines cannot tell whether a vector controls a specific concept or a neighboring one. This paper introduces the competing-target test, which compares a steering vector with the matched vector for a competing target and bounds their difference with an equivalence test. In three open-weight models, the authors show that vectors for Kantian deontology and act utilitarianism are largely interchangeable---they move both framework scores alike---whereas explicit prompting separates them, and the same construction does separate optimistic and pessimistic tones.

Activation steering adds a vector to a model's hidden states to control a named behaviour. A gain on that behaviour, however, does not show that the vector controls it directly: it may act through a component shared with neighbouring behaviours, which unsteered and random baselines cannot separate. We introduce the competing-target test: a vector is compared with the vector built the same way for a competing target, and an equivalence test states when their difference is below a useful margin. We apply it in open-weight models to vectors for Kantian deontology, which judges an act by the rule it follows, and act utilitarianism, which judges it by the welfare it produces. On held-out situations, prompting a framework raises its score and lowers the other's, whereas vectors for either framework move both scores alike, and none reaches the margin. The two vectors share most of their direction, a request to apply some framework; the same construction separates an optimistic from a pessimistic tone, whose vectors share much less. What a vector shares with its competitors therefore sets what it controls: steering a perspective can deliver a mixture, and measuring a disposition can measure its neighbours, unless tested against the competing target.
0
cs.LGcs.AImath.ST Katy Blumer, Da-Cheng Juan, Jon Kleinberg et al. · Oct 14, 2026

This paper studies the infinite-generation limit of autoregressive transformers. Rather than fixing sequence length, the authors let generation time tend to infinity and ask whether the model's empirical state converges. Their core result is that, for a broad class of architectures, the stochastic generation process tracks a deterministic ODE on a slow time scale, and every fixed transformer has a finite temperature threshold above which it converges to a unique limit. However, no uniform temperature works for all models; for any finite temperature, some transformer can fail to converge, even with just one layer and three tokens.

In this paper we study the behavior of transformer networks generating text over long periods of time. We show that even a three-token, single-layer attention-only transformer can fail to converge. We then study a rich class of transformers with arbitrary finite depth, layer normalization, MLPs, RoPE encodings, and an arbitrary mix of local and global layers. Every transformer in this class has a softmax temperature threshold above which its empirical cache distribution converges to a unique limit, independent of initial conditions. We show further that, while each transformer has a temperature threshold, the supremum of this set is infinite, so there is no global minimal temperature that forces all transformers to converge.
0
cs.AIcs.MA Sajid Siraj, Maria Barbati · Oct 14, 2026

AI agents chain many LLM calls to complete tasks, yet models are usually compared per call. This paper argues the correct functional unit is the successfully completed task, because failed attempts waste energy, cost and time. It derives crossover task lengths that predict when a smaller model stops being greener, cheaper or faster, and shows with a 15-model pilot that the greenest choice shifts from 1-3B models for short tasks to 8-27B models for long ones.

AI agents use large language models (LLMs) to plan and act over multiple steps, yet models are usually compared per call rather than per completed task. This paper asks: which model should an agent use to complete tasks reliably while minimising energy, cost and time? We show that per-call comparisons can be misleading for agentic AI. Because a task succeeds only if all required steps succeed, small differences in per-step reliability can produce large differences in overall task success. Failed attempts also consume resources. We therefore evaluate models using energy, cost and time per successfully completed task, treating the completed task as the functional unit. On this basis, we develop a decision model for choosing LLMs in agentic workflows. The model applies to tasks with binary or graded outcomes and to settings with or without retries. We show that each resource has a crossover task length at which a smaller, less reliable model ceases to be the greener, cheaper or faster option. These crossovers divide tasks into three regimes: for short tasks smaller models are preferred, for long tasks larger models are preferred, and only between these extremes do preferences among objectives matter. We embed these results in a two-stage framework that separates efficiency from preference. A Pareto screen first removes models that are never competitive; a weighted decision is required only when a genuine trade-off remains. A pilot study of 15 open-weight models from five developers, ranging from 0.6B to 27B parameters, on two multi-step agent tasks with measured GPU energy supports the predicted structure. The model with the lowest energy per completed task changes with task length and task type, and observed crossover points generally match those predicted from per-step measurements. These findings provide a practical framework for right-sizing language models in agentic AI.