Papers for

ai platform developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Code mode cuts tool use cost and speeds agents without extra decision layer

Beyond Plain MCP: Do Decision Models and Code Mode Make Tool Use Cheaper and Faster?

Abstract: Model Context Protocol (MCP) gateways manage tool catalogs for language model agents using two primary paradigms: code mode where agents write scripts against tool stubs and decision layers which are cheap routers that preselect tool subsets. Using a controlled harness across 12 servers, up to 1,958 distractor tools, and three open-weight agents including Qwen, Gemma, and Nemotron, we present a preregistered evaluation on a sealed test split to determine when each approach succeeds. Code mode substantially outperforms plain MCP, cutting token usage by 70 to 90 percent while significantly boosting utility. Declaring return-shape hints in code mode stubs is a first-order variable, swinging success by up to 39.5 points for lower-performing agents, an effect larger than adding a router. The central hypothesis that a decision layer in front of code mode beats code mode alone is not confirmed, showing minor, statistically non-significant improvements for weaker agents and a slight cost for the strongest. We publicly release our harness, a finetuned 4B tool selection model, and all evaluation traces to support robust community experimentation on local AI privacy and agent architectures.

Sat 14 NovSoftware EngineeringArtificial IntelligenceComputation and Language
The gist
Managing many tools for AI agents can be expensive and slow. The authors tested ways to make tool use cheaper and faster, comparing a simple method with one where agents write small scripts (code mode) and where a quick decision step picks tools. They found writing scripts saves lots of computing effort and improves results, especially when scripts include return format hints. Adding a decision step before script use did not help overall. The authors share their tools to help others test and build better AI helpers.
Open → 2611.19123v1

Prism reduces tool permissions for AI agents while keeping tasks effective

PRISM: Causal Counterfactual Minimization of Agent Tool Privileges via Information Bottleneck Role Induction

Abstract: This paper shifts the object of role engineering from human users to large language model (LLM) agents, and proposes PRISM to address the over-authorization that arises when an agent obtains full tool privileges through the Model Context Protocol (MCP). PRISM formulates whether a tool is necessary for a task as an intervenable causal proposition, and applies structured interventions in a sandbox to learn a counterfactual necessity model. It then compresses trajectories into discrete latent variables through an information bottleneck, and determines the number of roles from the knee of the rate-distortion curve. Finally, it formalizes pruning as a bilevel Stackelberg game, in which a generative flow network samples diverse near-optimal solutions. On three public benchmarks, AgentDojo, $τ$-bench and ToolEmu, PRISM compresses the number of authorized tools per role by 78.3%, attains a task success rate of 78.2%, reaches a counterfactual necessity accuracy of 88.7%, and lowers the blast radius to 15.9%.

Sun 8 NovCryptography and SecurityArtificial IntelligenceMachine Learning
The gist
Large language model agents often get more access to tools than they really need, which can be risky. The authors created PRISM, a method that figures out exactly which tools each agent needs for a task by testing what happens if the tools are removed. PRISM then groups tasks and tools into roles, cutting down unnecessary permissions a lot without hurting success rates. This approach also helps reduce the chances that an agent can cause big problems by limiting its access.
Open → 2611.11539v1

Stable training method improves large language model fine-tuning accuracy

BRAT: Bounded Residual-Aligned Training for Stable Multi-Pass LLM Post-Training

Abstract: Reinforcement learning for large language model post-training often reuses each batch of sampled rollouts for several gradient passes to amortize the cost of generation. Under such multi-pass reuse, existing objectives fail in different ways: unclipped updates collapse as the policy drifts away from the sampling policy, adding a negative baseline avoids collapse but reinforces every sampled response, and PPO-style ratio clipping cuts off gradients abruptly. We first ask why reuse is fragile. Measuring how well an update estimated from a small rollout group aligns with the KL-regularized target on held-out rollouts of the same prompts, we find that this alignment drops by nearly an order of magnitude from in-sample to held-out rollouts across three base models, suggesting that repeated passes largely overfit the sampled group. Motivated by this finding, we propose Bounded Residual-Aligned Training (BRAT), motivated by a proximal update toward a bounded reweighting of the sampling policy. BRAT assigns each token a gradient weight that decreases linearly with its probability ratio and vanishes at a trust-region boundary, and normalizes group-centered rewards by their maximum magnitude, keeping advantages zero-mean and bounded without extra hyperparameters. With four reuse passes, BRAT avoids training collapse, limits policy drift, and achieves higher average accuracy with lower seed variance on most benchmarks.

Sat 7 NovMachine Learning
The gist
Training large language models using reinforcement learning can be tricky because reusing the same training samples causes the model to overfit and behave unpredictably. The authors found that repeated training on the same samples reduces the quality of updates and leads to unstable results. To fix this, they created a new method called BRAT that adjusts training steps carefully to avoid drifting too far from the original samples and controls the feedback signals. Their approach achieves more stable training and better accuracy on tests, even when using multiple passes of the same data.
Open → 2611.10873v1

AI truth finding improves when accounting for shared errors among agents

Where Is the Truth When AI Agents Disagree? Dependence-Aware Belief Propagation for Unsupervised Truth Discovery (Extended Version)

Abstract: LLM agents often give conflicting answers to the same question, and many deployed agents are variants of one base model, so their errors are correlated. We study truth discovery among such agents: inferring the true answer and each agent's reliability without labels. Classical truth-discovery and crowdsourcing estimators reward an agreeing bloc and can fall below majority vote. We propose BP-TD, which adds per-agent decorrelation weights to mean-field variational inference on a one-coin Dawid-Skene model, so that agents sharing a base model count together as about one vote. Its first iteration is exactly a weighted vote; later iterations estimate agent reliability. With 13 local agents on MMLU, BP-TD beats majority vote without any labels (0.716 vs. 0.624 on 160 questions; 0.707 vs. 0.674 on 10,000) and ranks agents by their true accuracy, which classical estimators invert. The gain depends on the pool: over 2,852 sub-pools of four benchmarks, decorrelation helps when the largest correlated bloc is weaker than the other agents and hurts when it is the strongest, and we found no label-free statistic that tells the two cases apart. Labels change the picture quickly: with 20 labelled questions, selecting the single best agent is more accurate than every aggregator we tested on MMLU, ARC and TruthfulQA.

Tue 3 NovArtificial IntelligenceComputation and LanguageDatabases
The gist
When many AI programs answer the same question, they often disagree and sometimes make similar mistakes if based on the same underlying model. The authors study how to figure out the true answer and which AI agents are more reliable without access to correct labels. They introduce a method called BP-TD that adjusts for groups of similar agents so they don't unfairly sway the consensus. Tested on a benchmark with many questions, BP-TD outperformed simple majority voting and better ranked the agents by accuracy.
Open → 2611.04805v1

Agents often harmed before reading inputs pose new security risk

Step-Zero Attack: Agent Safety Before Observability

Abstract: Existing attacks and defenses for coding agents act once content enters the model context: injected text persuades the model, and guards inspect what the model reads. Yet to judge whether processing an unknown archive, network response, or image is safe, an agent often must process it first, and that step can do harm before any content reaches the model. We call this first processing Step Zero, and harm done by it a Step-Zero attack. Across seven harnesses and six models, each agent received only a path or URL to a crafted input, paired with a benign twin showing the same visible fields. Step Zero is where most agents are already unsafe: 32/42 harness-model pairs overran a 4 MiB disk budget, 26/42 before the model saw any member, and four of the six models did so in every round (84/84), so the damage precedes any model-side defense. Every twin stayed within budget, so the attacker's bytes alone cause the harm. On network and image inputs the risk moves to what the agent writes: agents stored the body under the name the input declared, letting the input decide what is written, and their checks faded once cues were removed. Model-free tests trace the harm to the processing primitive, so we defend it there: a gate that counts the bytes each call produces held every routed extraction within budget while agents completed 25/28 tasks. Vendors should pair such gates with safety-alignment training that teaches agents to inspect an input before processing it.

Sun 1 NovCryptography and SecurityArtificial IntelligenceSoftware Engineering
The gist
Many AI coding agents can get tricked or damaged not by what they read, but by how they first process files or data before analyzing them. The authors call this early risk "Step Zero," which happens before the AI even looks at the actual content. Their tests showed that agents often overused storage or wrote unwanted files just from this initial step, without any bad content reaching the AI itself. They suggest adding controls that limit how much data these early steps can produce and training agents to check safety before processing anything.
Open → 2611.01953v1

Topological method improves layer choice for steering large language models

TopoSteer: Topological Layer Selection for Activation Steering in LLMs

Abstract: Activation steering controls large language models at inference time by adding a vector to their internal representations. Most work asks how to build that vector, and far less attention has gone to where to add it, even though steering at a poorly chosen layer can be worse than not steering at all. Prior selectors choose a layer without ever steering the model to test it: they score how separable the target behavior is at that layer, and how consistently the individual examples point along the steering direction. We argue that what matters is not the separability of the two activation clouds, nor the alignment of individual displacements with their mean, but the extent of the cloud of per-example displacements that mean-difference steering averages. We propose a topology-based layer selection method, called TopoSteer, which scores a layer by the total H_0 persistence of its displacement cloud, computed as the length of the cloud's Euclidean minimum spanning tree. We show that the score focuses on the displacement cloud's relative geometry, while class separation affects it only through standardization. We also provide a theoretical explanation for our method by proving that, as example-level variation increases, TopoSteer and discriminability move in opposite directions, so the two criteria can rank layers in opposite ways. Across multiple language models and steering tasks, TopoSteer provides a principled alternative to discriminability- and separability-based layer selection and yields more effective steering without requiring held-out validation.

Sun 1 NovComputation and LanguageMachine Learning
The gist
Steering large language models means changing their behavior by adding a small tweak to their internal workings at a certain layer. The tricky part is figuring out which layer to tweak for the best effect. The authors found that previous methods picked layers based on separability but missed how the overall shape of changes matters. They propose TopoSteer, a way to pick the layer based on the topological shape of changes, making steering work better without extra testing.
Open → 2611.01493v1

Web model safety needs more than just plausible future prediction

Beyond Plausible Prediction: Safety Sufficiency in Web World Models

Abstract: Web world models increasingly predict the consequences of candidate actions before agents act, yet a plausible predicted future does not necessarily support the correct safety decision. In a matched human evaluation of 3,000 predictions from ten frozen open models, 86.1% are judged semantically plausible. However, several models exhibit highly asymmetric authorisation behaviour, combining low false-safe execution with poor recall of clarifiable ASK cases and a strong preference for BLOCK. This motivates safety sufficiency: whether a predictive interface preserves and exposes the policy-decisive information required to distinguish actions that may be EXECUTED, require clarification through ASK, or should be BLOCKED. We introduce SafeWebWorld, a benchmark for evaluating safety sufficiency across five web-safety domains through action-conditioned futures, policy-decisive evidence, and policy-conditioned decisions. Under a controlled Security-Aligned Supervised Fine-Tuning protocol, evidence preservation can improve substantially while authorisation-sensitive decisions deteriorate. To determine whether this deterioration reflects loss of authorisation-sensitive score structure or a failure of the decision readout, we introduce Latent Authorisation Recovery (LAR). Frozen-score recalibration reveals substantial but backbone-dependent recovery, while paired recovery provides only a modest additional gain. Yet within-family and matched-authorisation evaluations remain poor, showing that aggregate recoverability does not imply robust fine-grained authorisation behaviour. Overall, plausible prediction, evidence preservation, and aggregate recovery are each insufficient on their own to establish robust authorisation.

Thu 29 OctArtificial Intelligence
The gist
Web world models try to guess what will happen after an action, but guessing a believable future isn’t enough to keep decisions safe. The authors found that many models often block actions unnecessarily or fail to ask for clarification when they should. They created SafeWebWorld, a way to test if web models keep important safety info visible for correct decisions. Their tests showed that improving predictions doesn’t always improve safety decisions, meaning models need better ways to handle safety rules. Overall, just making plausible predictions doesn’t ensure safe and correct web actions.
Open → 2610.40798v1

TextSeal2 improves watermarking for large language model outputs

TextSeal2: Distortion-Free LLM Watermarking with Copula Mixing and Memoryless Races

Abstract: We present TextSeal2, a distortion-free watermark for large language models that keeps its signal under speculative decoding: tokens that replace rejected drafts remain watermarked with the same keys, and the acceptance rate is unchanged. It also preserves output diversity and adds no measurable inference latency. Its predecessor, TextSeal, restores diversity in the Gumbel-max scheme by routing each token to one of two keys via a coin flip. This is suboptimal because the detector averages the scores from both keys without knowing which key was used. TextSeal2 instead merges two or more keys into a single virtual key and couples it to fresh noise through AutoMark's Gaussian copula. Any number of keys, including publicly shared keys, can be merged this way without diluting detection. Under speculative decoding, TextSeal2 verifies keyed drafts with one more exponential race, run on the leftovers of the draft races. By memorylessness, this race reproduces block verification, so the output follows the target model exactly. We evaluate TextSeal2 on three LLMs. At equal output token diversity, TextSeal2 detects 8 to 22 percentage points more 100-token answers than TextSeal at a false-positive rate of $10^{-3}$, and is comparable to textGrain while requiring no post-logits optimization. Under speculative decoding, it detects 18 and 22 percentage points more 200-token answers than TextSeal and textGrain, respectively, at the same acceptance rate.

Thu 29 OctCryptography and SecurityArtificial IntelligenceComputation and Language
The gist
The paper presents TextSeal2, a method to embed hidden signals (watermarks) in the text generated by large language models without changing the quality or style of the output. This new method keeps the signals intact even when the text is checked or modified during decoding, unlike previous methods that mixed two signals and reduced accuracy. TextSeal2 combines keys in a clever way using mathematical tools called copulas to improve detection while preserving diversity and speed. The authors show it works better on several large models, detecting watermarked text with higher accuracy and no extra delays.
Open → 2610.40613v1

Large language models reduce unnecessary refusals while keeping safety intact

Revisiting Over-refusal in Safety-aligned Large Language Models: A Representation and Optimization Perspective

Abstract: Over-refusal is a critical side effect of safety alignment in large language models (LLMs), causing harmless but superficially risky queries to be mistakenly rejected. Despite the effectiveness of existing mitigation methods, why safety-aligned LLMs may still reject harmless queries under correct safety supervision remains insufficiently understood. To address this gap, we analyze over-refusal through the lens of representation and optimization. We make two observations: 1) the representations of harmful and over-refusal samples are visually distinguishable at certain intermediate layers but increasingly overlap in deeper layers; and 2) harmful-sample gradients exhibit high intra-class similarity and concentrate in a low-rank subspace. Moreover, they are more strongly aligned with refusal-target gradients than with correct helpful-target gradients on over-refusal prompts. This imbalanced gradient coupling can bias over-refusal samples toward refusal, while the reduced apparent representational separation in deeper layers may make it more difficult for the model to maintain a clear boundary between harmful and over-refusal samples. To this end, we propose GOAL (Gradient Orthogonalization with contrAstive Learning), a safety-alignment framework for mitigating over-refusal. Specifically, GOAL consists of two components: 1) to prevent imbalanced gradient coupling from biasing the optimization of over-refusal samples toward refusal, we orthogonalize over-refusal gradients against the low-rank refusal subspace extracted from harmful gradients; and 2) to explicitly enhance the separation between harmful and over-refusal representations, we introduce a contrastive learning objective. Extensive experiments across multiple models and benchmarks demonstrate that GOAL effectively mitigates over-refusal while preserving safety performance and general capabilities.

Thu 29 OctArtificial Intelligence
The gist
Large language models sometimes refuse to answer harmless questions because they look similar to harmful ones. The authors studied why this happens by looking at how the model represents and learns from these questions. They found that as the model processes information deeper, it struggles to clearly separate harmless from harmful questions, leading to too many refusals. To fix this, they created a new method called GOAL that helps the model better recognize harmless questions and reduces unnecessary refusals without sacrificing safety.
Open → 2610.39802v1

LLM agents improve recommendation systems mainly by tuning settings

AutoRSE: Evaluating LLM Agents as Recommendation Engineers for Self-Evolving Recommender Systems

Abstract: Recommender Systems Engineer Agents (RSE-Agents), which use LLM-based agents to autonomously improve recommendation algorithms, are emerging as a promising paradigm. However, their capabilities and limitations remain poorly understood due to the lack of a unified, standardized evaluation framework and systematic trajectory-level analysis. To address this gap, we introduce AutoRSE, an evaluation framework spanning six representative industrial-grade recommendation tasks, and conduct a large-scale empirical study of three frontier LLMs across three widely used agent harnesses. Our results show that RSE-Agents consistently enhance the performance of backbones on five of the six tasks, with an average relative improvement of 16.1%, indicating that they can already autonomously improve recommendation performance. However, trajectory-level analysis also reveals that current RSE-Agents function primarily as engineering optimizers rather than algorithmic improvers: their gains are largely driven by hyperparameter tuning, training strategies, and model ensembling, while genuine algorithmic innovations are rare. Since the largest gains in recommender systems often stem from algorithmic advances, this behavior underscores a fundamental limitation of current RSE-Agents. To probe this limitation, we perform idea-injection experiments and show that agents equipped with innovative ideas from frontier research or human experts achieve substantially larger improvements than those relying on self-generated ideas. These results suggest that idea generation is a central bottleneck of current RSE-Agents, highlights a key direction for the future recommendation system research. Our implementation is publicly available on GitHub: https://github.com/Ray-Tiann/AutoRSE.

Tue 27 OctInformation Retrieval
The gist
Improving recommendation algorithms automatically is a big challenge. The authors study AI agents that use large language models (LLMs) to do this by themselves. They find these agents help a lot by optimizing things like training settings and combining models, but they rarely come up with new algorithm ideas on their own. When given new ideas from experts, these agents perform even better, showing that generating creative ideas is still a hard problem for them.
Open → 2610.37228v1

Direct preference optimization produces sparse updates in language model training

On the Sparsity of Direct Preference Optimization: Weight Disentanglement in the NTK Regime

Abstract: Direct Preference Optimization (DPO) has been widely adopted for aligning language models with human preferences. Recent empirical work has revealed that DPO induces remarkably sparse parameter updates, yet no theoretical explanation for this phenomenon has been offered. We analyze DPO's optimization dynamics under a neural tangent kernel linearization and show that the logistic structure of the DPO loss gives rise to an implicit maximum-margin bias. Building on this observation, we introduce the concept of dual sparsity: the DPO update direction is a sparse linear combination (data-level sparsity, driven by support vectors) of sparse gradient feature vectors (parameter-level sparsity, arising from gradient cancellation between preferred and dispreferred responses). We formalize this structure in our main theorem, bound the number of support pairs by a margin-dependent spectral quantity, and present a framework relating dual sparsity to weight disentanglement---a condition favorable for model merging. Experiments on GPT-2 Small and Medium and on 7--9B instruction-tuned models (Llama-3-8B, Mistral-7B, Gemma-2-9B) with the Anthropic HH-RLHF and UltraFeedback datasets confirm both sources of sparsity, and experiments on GPT-2 show that DPO reduces cross-task interference by up to $35{\times}$ compared to supervised fine-tuning.

Tue 27 OctMachine Learning
The gist
Training language models to follow human preferences often changes many model settings, but some methods surprisingly update only a few parts at a time. The authors studied Direct Preference Optimization (DPO) and found that it naturally focuses updates on a small set of important examples and parameters. This helps keep model changes more organized and reduces conflicts when training on multiple tasks. Their work explains why DPO behaves this way and shows it can help models balance different skills better.
Open → 2610.37085v1

AI agent workflows improve PyTorch deployment on device accelerators

AIPC: Evidence-Guided Agent Workflows for PyTorch Project Deployment

Abstract: Deploying and optimizing a PyTorch inference project on a dedicated accelerator, especially an on-device NPU, requires more than using a framework device API as with CUDA. The project must be converted into hardware-runtime artifacts and adapted to the target toolchain and application interface. Differences in model formats, quantization flows, operator support, and toolchain interfaces create cross-layer problems spanning PyTorch/ONNX models, toolchains, runtimes, and device execution. LLM Agents can invoke tools to address such problems, but may drift because of insufficient domain knowledge, large configuration and repair spaces, or poor path selection. We propose AIPC (AI Porting & Conversion), an Agent method for deploying PyTorch inference projects. AIPC combines structured Skills with toolchain, runtime, and profiling evidence to drive cross-layer diagnosis and repair, organizing model adaptation, artifact building, on-target execution, accuracy repair, and performance optimization into one deployment flow. We evaluate AIPC on the on-device NPU path of Qualcomm QAIRT across vision, speech, LLM, and diffusion models. In two optimization cases, 6/7 Skill-arm Whisper-Small runs meet predefined accuracy and latency criteria versus 0/6 control runs, while YOLO-Worldv2 achieves a 2.791x end-to-end speedup versus 1.599x for the control. Under a pre-fixed deployment contract, Skill, tool permissions, and check conditions, some runs achieve zero in-run human intervention (0-HITL). We also examine Qwen3.8-27B as a locally deployable model for driving an Agent workflow.

Mon 26 OctSoftware EngineeringArtificial IntelligenceMachine Learning
The gist
Deploying AI models on specialized hardware like on-device NPUs is complicated because models must be converted and adjusted for different hardware and software layers. The authors propose AIPC, a system that guides AI agents with detailed information and skills to help fix and optimize these models automatically. Their approach organizes the whole deployment process including adapting models, building runtime files, running tests, and tuning speed and accuracy. Tests on various AI models showed that AIPC improved accuracy, speed, and reduced human involvement during deployment. They also explored using a large language model to help automate deployment workflows locally.
Open → 2610.34890v1

Data optimization techniques enhance large language model training and usage

Data Optimization for LLMs: A Survey

Abstract: Large language models (LLMs) have attracted great attention in both academic and industrial communities in recent years. Numerous survey studies have covered various aspects of LLMs, such as learning strategies, applications, alignment, explainability, and evaluation. However, little headway has been made in reviewing data-related aspects for LLMs, despite data being recognized as a key factor contributing to the emergence of the LLMs era. A wide range of data optimization algorithms and techniques are employed in LLMs' training and application processes. These techniques often originate from diverse deep learning domains, with their theoretical inspirations and heuristic motivations appearing unrelated to each other. This study aims to develop a comprehensive framework for LLMs' data optimization techniques to enhance data utilization and efficiency. We first discuss data challenges in LLMs' training and inference. Second, we summarize data perception dimensions for evaluating LLMs' data properties. These dimensions primarily include quality, difficulty, diversity, and redundancy, laying a foundation for subsequent optimization. Third, existing optimization techniques are reviewed and categorized into four groups: data selection, augmentation, reweighting, and others. Fourth, we analyze interconnections between these categories. Finally, we identify key challenges and future directions for LLMs' data optimization compared with conventional deep learning approaches.

Sat 24 OctArtificial Intelligence
The gist
Large language models (LLMs) need huge amounts of data to work well, but not all data is equally useful or easy to use. This paper reviews many ways to improve LLMs by selecting better data, adding useful variations, giving different importance to data, and other tricks. The authors organize and explain these techniques, pointing out their strengths and connections. They also highlight the challenges and suggest directions for making LLM training and use more efficient with smarter data handling.
Open → 2610.33405v1

Ai skill combinations expose new security risks in agent workflows

Detecting Insecure Compositions of Clean Agent Skills via Capability-Flow Graph Analysis

Abstract: AI agents increasingly extend their capabilities by invoking third-party skills, where each skill encapsulates instructions, scripts, and resources for agents to execute on demand. This paper reveals that deploying many benign skills together introduces compositional security risks: multiple individually clean skills can compose into safety-violation chains, because the agent passes an upstream skill's output to a downstream skill's input across invocations. The risk arises not from any single skill, but from the agent's runtime orchestration, and thus cannot be captured by existing malicious skill detection methods. To this end, we develop KnotScryer to detect insecure skill compositions by treating skills as typed capability flows. In particular, we abstract each skill into a capability summary, and construct the Skill Capability-Flow Graph (SCFG), where edges denote cross-skill information flow. Moreover, we design a search policy that tracks protected or untrusted data along handoff edges to locate paths reaching insecure operations. Finally, a two-layer verification method replays the insecure information flow for reachability analysis and applies a task-anchored LLM chain audit to confirm the semantic plausibility of the identified violation chains. We deploy KnotScryer to analyze 13,598 clean skills from ClawHub, and validate the detected chains across three agent frameworks and three LLMs. KnotScryer identifies 612 insecure compositions, which are consistently exploited across agent frameworks. Meanwhile, under GLM-5.1, it outperforms tag-match and graph-only baselines by improving the exploitation rate from 16.5%-18.2% to 85.6%, while reducing the search space by 85.3%. Furthermore, 13.7% of the detected chains consist entirely of skills labeled safe by a single-skill scanner, showing that KnotScryer effectively identifies insecure compositions that per-skill auditing cannot.

Fri 23 OctCryptography and Security
The gist
Artificial intelligence agents often work by using small programs called skills. Each skill on its own is safe, but when these skills pass information between each other, they can unintentionally create security problems. The authors developed a tool called KnotScryer that maps how information flows between these skills to find unsafe chains before they cause harm. This approach finds problems that previous methods, which only look at individual skills, would miss.
Open → 2610.32155v1

Message-passing method improves language model quantization accuracy

MPQ: A Message-Passing View of Post-Training Quantization

Abstract: Post-training quantization (PTQ) is a key technique for efficiently deploying large language models, as it compresses weights into low-bit representations without retraining. Existing PTQ solvers, including GPTQ, LDLQ, and block coordinate descent, commit each weight block to a single codeword before its neighbors are considered, leaving near-optimal alternatives unexplored. In this work, we cast row-wise PTQ as posterior inference over discrete codebooks, in which existing solvers correspond to a zero-temperature, hard-decision limit retaining only the top codeword per block. We propose Message-Passing Quantization (MPQ), which preserves soft posterior information across blocks during inference and commits to hard codewords only at the output stage. MPQ first uses vector approximate message passing to compute approximate blockwise posteriors, then refines a hard-decision initialization by exact block coordinate descent. Across 2-bit lattice and 3- and 4-bit scalar quantization on dense language models from Llama, Qwen, and Mistral families, MPQ improves perplexity and zero-shot accuracy over strong hard-decision baselines, and composes favorably with preprocessing techniques such as activation-aware scaling and incoherence processing. Our implementation is available at https://github.com/poseidonchan/MPQ.

Fri 23 OctArtificial IntelligenceMachine Learning
The gist
Computer programs called large language models need a lot of memory, so they are often compressed by turning their details into simpler numbers, which can lower memory needs. Existing compression methods make strict choices for parts of the model without considering nearby parts enough, which might miss better options. The authors introduce a new method called Message-Passing Quantization (MPQ) that keeps track of many possible choices together before picking the best one at the end. This approach reduces errors better than older methods in tests with models like Llama, Qwen, and Mistral.
Open → 2610.32127v1

Reliable recovery methods improve AI tool use in changing conditions

Permission to Retry: A Study of Authorization and Recovery in AI Agent Workflows

Abstract: A durable agent can resume a consequential action while its authority changes and the action's external outcome remains uncertain. We study execution-time reliability of tool-using AI agents, isolating recovery decisions from language-model behavior. Checkpoint state, permission to dispatch, evidence of an external effect and permission to reconcile are distinct obligations. We present a finite conformance study that checks these obligations through histories scored against a provider effect ledger hidden from the recovering application. A prospectively frozen campaign executes 336 histories on native LangGraph and Temporal hosts, crossing 14 schedules, three provider contracts and four matched application policies. All 168 paired host cells have identical checked outcomes. Per host, retained-ledger reconciliation passes all 42 histories: 21 checked completions, 15 denials and six unknown outcomes with reservations retained. Cached retry, revalidation before retry and stable-key retry pass 30, 36 and 31 histories respectively. A separate 16-case component study of InfinityOS, an enterprise AI platform developed by Arya.ai, exercises exported authority, worker, recovery and settlement code over repository fakes. The results isolate the roles of current authority, provider contracts and retained observations in recovery, with safety, completion and unresolved obligations reported separately for the declared application profile.

Thu 22 OctArtificial IntelligenceSoftware Engineering
The gist
Sometimes AI programs need to pause and try again when doing complex tasks, especially if their permission to act changes or the results are unclear. The authors studied how AI agents keep track of permissions, actions, and outcomes to decide if and when they should retry tasks. They tested different ways to check these decisions and found that keeping track of past attempts and external effects helps AI agents recover safely and reliably. The study used both experiments with AI workflow systems and code from a real AI platform to understand the role of permissions and observations in recovery.
Open → 2610.31916v1

Data voids let bad actors trick web searching AI models

Data-Void Exploits in Web-Searching LLMs

Abstract: Web-searching Large Language Models (LLMs) have changed how users seek online information: instead of sifting through ranked lists of links, users read synthesized answers. This shift creates a new LLM vulnerability: a data-void exploit. Disinformers publish their narratives in search spaces where relevant and reliable content is scarce, i.e. data voids, then rely on the LLM's web-search to retrieve and then use, cite, or list those pages in its responses to data-void seeking prompts. Unlike classical search, where users see ranking cues and competing results, LLMs can obscure when an answer relies on sparse, unverified, or adversarial sources. We study this threat by varying the user's prompt tone - skeptical, excited, or neutral - and LLM choice - ChatGPT, Gemini, or Sonar Pro - as well as three attacker controls. The attacker can use one of five known strategies to construct and fill a data void with their narrative, host their content at varying levels of visibility from well-established, indexed domains to less established ones, and include generative-optimization engine features thought to boost citing by web-searching LLMs. We find that data-void exploits can succeed with only a single attacker controlled page. Across all conditions, attacker-content appears in LLM responses 31% of the time. User controls offer limited protection: while skeptical prompts slightly reduce success and slightly increase flagging or warnings in LLM responses, we find no evidence of large effects of prompt tone or model choice on success rates, although smaller effects cannot be ruled out. Overall, our results establish data voids as a practical inference-time attack surface for manipulating web-searching LLMs through strategically placed web content and highlight the urgent need for defenses against such exploits.

Wed 21 OctCryptography and SecurityHuman-Computer InteractionInformation Retrieval
The gist
Web-searching language models now give direct answers instead of links, which can hide when information is scarce or unreliable. The researchers found that bad actors can exploit these ‘data voids’ by publishing misleading content in areas where truthful information is rare. The language models then use this content in their answers without clear warnings, making it easier to spread false narratives. The researchers tested different models, prompts, and attacker strategies, finding such attacks succeed about one-third of the time. They highlight the need for better defenses to protect users from this kind of manipulation.
Open → 2610.30365v1

Privacy controls adapt to autonomous ai agents on the web

Privacy Preference Controls for Agentic Systems

Abstract: In response to vast and widespread online tracking, regulators and technologists alike have worked to develop laws and tools that allow people to express their privacy preferences. These measures seek to offer users greater control over the sale and sharing of personal information, putting agency in their hands to protect their privacy. However, the web is undergoing a seismic shift, away from strictly \textit{user-driven} behavior towards \textit{agentic behavior}, where AI agents take autonomous actions on behalf of users. In this study, we ask: What should privacy preference controls look like in the agentic web and agentic systems more generally? To answer this question, we develop a taxonomy of enforceable privacy preferences for agentic systems. Our taxonomy is informed both by laws and empirical studies of existing privacy tools as well as an audit of 30 leading AI assistants and agent platforms. To explore how our taxonomy can be implemented, we design and develop eight open-source prototypes that mirror real-world agentic applications and demonstrate how major aspects of our taxonomy can be structurally integrated in agentic protocols, such as the Model Control Protocol and Agent2Agent protocol. Ultimately, our study seeks to provide the groundwork for ensuring end-user privacy and autonomy is not lost in the newly arriving agentic world.

Wed 21 OctComputers and SocietyHuman-Computer Interaction
The gist
Online tracking is widespread, and people want tools to control their privacy. This paper looks at how privacy controls should work when AI agents act for users automatically, instead of users making every decision. The authors create a list of privacy preferences that can be enforced with these AI agents. They test their ideas by building example systems that show how these controls can fit into real agent technologies. This work helps ensure people can keep their privacy even as AI takes more actions on their behalf.
Open → 2610.29929v1

Concept word effects on language model learning differ by part of speech

Every Part Has Its Role: Part-of-Speech Effects in LLM Post-Training

Abstract: Large language models are typically trained with next-token prediction (NTP), which rewards predicting specific tokens rather than explicitly accounting for the semantic similarities between different words or expressions. Prior work has addressed this limitation by augmenting training data with minimally varying sentences that replace a target word with conceptually related alternatives, e.g., "The tired coach ran home" $\rightarrow$ {"The tired trainer ran home", "The tired instructor ran home", ...}. Such concept augmentation improves performance, but it remains unclear whether its effectiveness depends on where in the sentence the concept is expressed. We reproduce and extend prior work $\textit{beyond nouns}$ to verbs and adjectives, asking whether the part of speech (POS) carrying the concept signal affects perplexity and downstream performance. We find different patterns across evaluation settings: concept augmentation improves perplexity most consistently on news, independent of the POS used, whereas verbs provide the most reliable downstream gains. Despite these behavioral differences, representational analyses using CKA and linear probing show that the conditions yielding the largest downstream gains are not necessarily those that most alter the model's internal representations. Together, these results suggest that the effectiveness of concept augmentation depends on where and how conceptual information is introduced during training.

Wed 21 OctComputation and LanguageArtificial Intelligence
The gist
Large language models usually learn by predicting the next word exactly, which doesn't always recognize that similar words can mean almost the same thing. The authors studied how adding similar words for nouns, verbs, and adjectives during training affects the model’s accuracy and usefulness. They found that changing concepts in verbs improved the model’s task performance most, while overall accuracy improved on news text regardless of word type. Interestingly, the best results on tasks didn’t always mean the model’s internal thinking changed the most, suggesting that where and how you add related words matters a lot.
Open → 2610.29843v1

GaP-MoE improves expert diversity in sparse models with gradient projection

GaP-MoE : Explicit Expert Specialization in Mixture-of-Experts via Orthogonal Gradient Accumulation and Projection

Abstract: Sparse Mixture-of-Experts (SMoE) models improve scalability by routing input tokens to only a subset of expert networks, but they often suffer from representation collapse, in which multiple experts converge toward similar functions and lose their intended diversity. Prior work has addressed this limitation either by improving router architectures or by introducing auxiliary loss terms that implicitly penalize similarity among experts. However, router-based approaches remain vulnerable to routing collapses, and loss-based approaches can conflict with the task's original objective during optimization. In this work, we propose GaP-MoE (Gradient Accumulation and Projection in MoE), which induces expert specialization by directly manipulating expert output gradients rather than modifying the loss function. At each training step, GaP-MoE stochastically selects one of the $TopK$ routed experts as a leader based on normalized routing scores, and projects the gradients of the remaining follower experts onto the orthogonal complement of the subspace spanned by the leader's recent gradients. This removes directional overlap between expert gradients without altering the task loss, allowing specialization to emerge as a direct consequence of the optimization dynamics rather than an externally imposed constraint. We evaluate GaP-MoE in both fine-tuning settings (BERT-based, on GLUE) and from-scratch pretraining settings (GPT-2-based, on WikiText-103, enwik8, and text8), and further confirm its compatibility as a drop-in module for existing SMoE architectures. Experimental results show that GaP-MoE achieves performance comparable to or better than standard SMoE.

Wed 21 OctMachine Learning
The gist
Sparse Mixture-of-Experts (SMoE) models split work among different 'experts' to handle tasks efficiently, but these experts often end up doing similar things, which limits the model's power. The authors propose GaP-MoE, a method that encourages each expert to specialize by adjusting their learning signals so they don't overlap, without changing the main training goal. They tested this on language models and found that it helps maintain expert diversity and can improve or match existing methods. This approach works as a simple addition to current SMoE techniques.
Open → 2610.29355v1

Language models retain skills better when new knowledge is recast as old skills

Combating Catastrophic Forgetting in Continual Domain Adaptation via Knowledge Recasting

Abstract: Adapting language models to new domains during post-training risks degrading previously acquired capabilities, a phenomenon commonly known as catastrophic forgetting. Existing mitigation methods largely treat forgetting as a consequence of excessive model drift. They therefore constrain updates by preserving old outputs, replaying old data, or regularizing changes to parameters and representations so that the updated model remains close to its previous state. We take a different view: Rather than pulling the updated model back toward its old state, we translate the new domain into the model's pre-existing knowledge space, making unfamiliar knowledge learnable through familiar procedures. Therefore, we propose Skill Schema Transport (SST), a post-training framework that transports new knowledge into the model's existing skill space. SST abstracts each example type into a skill schema, preserving its essential operations, dependencies, and verification steps while removing domain-specific surface forms. By recasting new examples as instances of reusable procedures, SST turns knowledge update from trajectory memorization into procedural reuse. In continual domain adaptation settings, SST consistently reduces forgetting while improving generalization to related tasks. Across two 3B instruction-tuned backbones, SST improves average final performance on streamed domains by 2.53 to 5.75 points over sequential post-training. It also lowers max-drop forgetting in all evaluated settings, with the largest reduction from 42.41 to 7.10 points on the Qwen-3B MATH stream, while substantially recovering the OOD degradation induced by sequential updates.

Tue 20 OctMachine Learning
The gist
Language models often forget what they learned before when trained on new topics, a problem called catastrophic forgetting. This paper's authors propose a new method that doesn't try to keep the model from changing but instead translates new knowledge into familiar skills the model already knows. Their approach, called Skill Schema Transport, breaks down new examples into reusable procedures, helping the model learn without losing past abilities. Tests show this method reduces forgetting and improves performance on related tasks.
Open → 2610.28892v1

Scientific language models improved for clearer research conversations

CollabSciReM: Aligning Language Models for Scientific Conversations via Science-Aware Reward Decomposition

Abstract: Large Language Models (LLMs) are increasingly used as research collaborators for hypothesis refinement, methodological planning, and technical analysis across multi-turn interactions. In this setting, a useful assistant must be accurate, methodologically justified, logically consistent, and token-efficient. Current alignment approaches rarely achieve all of these together. Instruction-tuned models gain conversational quality through verbosity, and we show that science-agnostic general collaborative rewards compress responses at the expense of scientific rigor. We propose CollabSciReM, a goal-conditioned reward framework that decomposes the session-level reward into conversational quality, scientific rigor, and structural efficiency. We also introduce SciQuality, a pairwise evaluation of multi-turn research conversations grounded in 300 held-out scientific papers and scored on six dimensions: methodological soundness, justification, logical consistency, factual correctness, novelty, and responsiveness. Fine-tuned on 8.62K synthetic research conversations, CollabSciReM is preferred on SciQuality over a science-agnostic reward baseline trained on the same data for all four Llama and Qwen models, including a 65.3% win rate at matched response length. For the 7B and 8B models, CollabSciReM outperforms the science-agnostic reward baseline on the primary metric in 8 of 10 single- and multi-turn benchmark settings. In a blind study, domain experts rated CollabSciReM significantly higher on novelty than the general-reward variant and reported fewer hallucinated responses than both the general-reward variant and the base model.

Tue 20 OctComputation and LanguageArtificial Intelligence
The gist
Language models can help scientists talk through research ideas, but they often give answers that are too long or not precise enough. The authors created CollabSciReM, a way to train these models to give clearer, more accurate, and efficient scientific responses. They tested it with models like Llama and Qwen and found that CollabSciReM’s answers were preferred for being more novel and less prone to mistakes. This approach breaks down what makes a good scientific conversation into parts like accuracy, logic, and length to improve the model’s performance.
Open → 2610.27901v1

Arctic-SWE improves long-horizon AI training with model and system design

Arctic-SWE: Revisiting the Long Horizon Agent Training by Modeling-System Co-Design

Abstract: Long-horizon agent training, including software engineering, is advancing rapidly, but the recipe and infrastructure needed for a strong reinforcement-learning baseline remain difficult to reproduce. This makes gains from new algorithms or data hard to distinguish from improvements to an under-tuned baseline. We present Arctic-SWE, a fully asynchronous RL framework that establishes such a baseline through model-system co-design, using overfitting on a small task pool as the testbed. This testbed exposes failures that early reward gains conceal and guides the integration of established components: gated reward, importance-weight control, aligned training and inference engines, and consistent state across policy updates. No single component is new, yet together they form the missing foundation. On raw R2E-Gym data, without new algorithms or data work, Arctic-SWE trains Qwen3.5-4B to 62.0% pass@1 on SWE-bench Verified. This is comparable to concurrent FrogNano (61.5%), which relies on online task synthesis, after about one-sixth as many training rollouts. Building on this foundation, we further filter and refine R2E-Gym, SWE-rebench V2, and Scale-SWE. With this curated subset, the 4B model improves from 47.4%/25.0%/37.9% to 65.0%/38.3%/59.7% on SWE-bench Verified/Pro-v1/Pro-v2, and the recipe also improves Qwen3.5-9B from 56.2%/31.9%/48.8% to 65.7%/39.6%/70.2% on Verified/Pro-v1/Pro-v2. Controlled comparisons show that both curation and test strengthening improve held-out performance, although stronger tests reduce apparent training-task mastery. Arctic-SWE provides a documented starting point for studying better algorithms, data and environments for asynchronous agent RL.

Sat 17 OctMachine LearningArtificial IntelligenceComputation and Language
The gist
Training AI agents to perform tasks over long periods is hard to do well and hard to measure. The authors created Arctic-SWE, a system that combines known techniques in new ways to form a strong starting point for AI training, making it easier to test and improve new methods. They tested it by training large language models on coding tasks and showed it matches or beats other systems using less training effort. They also improved the training data and tests to better measure real progress. Their work helps others build better AI systems by providing a solid, reproducible baseline.
Open → 2610.24914v1

SWE-Bench Pro V2 offers tougher and cleaner coding tasks for AI agents

SWE-Bench Pro V2: A Cleaner, Harder-to-Game Coding Benchmark

Abstract: SWE-Bench Pro is a widely used benchmark of long-horizon software engineering tasks for coding agents. As agents improve, they reach task issues earlier agents never touched and interact with the evaluation environment in ways the original harness did not anticipate. We present SWE-Bench Pro V2, a revised public split built to keep the benchmark accurate as capabilities advance. Agentic audits, expert adjudication and blind re-implementation repaired or retired 480 of the 731 tasks: 23 contracted engineers spent 404 hours, each working in a language they write professionally, and every revised instruction was verified by a second engineer solving the task from the text alone. A hardened protocol restricts network access to the model endpoint and re-grades every patch in a clean container, so agents cannot retrieve upstream fixes or get credit for changes outside their patch. On the 642 V2 tasks frontier agents resolve up to 99.4% while other systems stay clearly separated, and a 51-task Hard split spreads systems from 52.9% to 98.0%. We release the benchmark and distill lessons for maintaining agent benchmarks over time.

Fri 16 OctSoftware EngineeringArtificial Intelligence
The gist
Coding AI agents need tests to see how well they solve complicated programming tasks. The previous version of SWE-Bench Pro had problems because some tasks became too easy or could be tricked by clever cheating. The authors fixed or removed many tasks, checked every instruction carefully, and created rules to stop agents from gaming the system. Their updated version keeps tests fair and challenging as AI agents get better.
Open → 2610.24206v1

Safety monitor failures can hide evidence from llm decisions

Monitor-Validity Failures: LLM Safety Evidence Paths at Evolving Framework Boundaries

Abstract: Modern LLM applications rely on runtime monitors that inspect tool calls, traces, streams, detector outputs, and verifier inputs. This creates an interface-reliability problem: a framework path may remain operational while policy-relevant evidence never reaches its decision point. In one representative case, a regex detector returned a positive match, but the framework stranded the result before the block decision. This differs from jailbreaks and detector errors because the evidence is already recognized yet disconnected from enforcement. We study this repair-boundary signature with canary contracts: parent/fixed confirmation units that place a known payload only on the changed evidence surface and record monitor visibility together with the downstream decision for action-boundary cases. Applying the protocol to public framework repairs, we confirm 18 evidence-path failures across 11 LLM or agent safety project groups and four implementation ecosystems. Nine are established-boundary repairs, eight are new-surface policy-coverage gaps, and one is a boundary-only evidence case. Fourteen reach E1 enforcement boundaries: seven native action outcomes, six configured enforcement boundaries, and one synthetic-consumer consequence. The remaining cases affect verifier, safety-prompt, or observability channels. The cases form carrier, adapter, authority, and surface families and show how ordinary application behavior can remain intact while a safety-specific evidence path misses its decision. Exact revisions, deterministic outcomes, negative controls, and a frozen prospective audit document the confirmation rule. Monitor assumptions therefore need regression tests at the schemas, streams, tools, and adapters that frameworks evolve.

Fri 16 OctArtificial IntelligenceCryptography and SecuritySoftware Engineering
The gist
Large language models (LLMs) use safety monitors to check and control risky outputs during operation. This paper shows that sometimes the monitors detect a problem, but the warning does not reach the part of the system that decides what to do, meaning unsafe outputs can slip through. The authors found many examples of this issue in real LLM safety frameworks by testing with special test cases that highlight these hidden evidence paths. Their work reveals that safety checks need regular testing and updates as systems evolve to ensure all warnings lead to the right actions.
Open → 2610.23362v1

Switching optimizers during training does not harm large language model performance

The Ephemeral Cost of Switching Optimizers Across LLM Training Stages

Abstract: Recent work suggests that switching optimizers between pretraining and subsequent training stages incurs a performance cost, but systematic investigation of this phenomenon is lacking. We study the mismatch between AdamW and Muon optimizers by pretraining 1.2B Llama-3 models from scratch while varying the proportion of updates taken with each optimizer, and similarly interpolating between the two optimizers during continued pretraining and supervised fine-tuning (SFT). Surprisingly, we find little evidence of a meaningful optimizer mismatch penalty: final performance is largely explained by the independent effects of the pretraining and post-training optimizers, with downstream performance generally improving as the proportion of Muon updates during SFT increases. Although matching the pretraining optimizer can reduce forgetting during SFT, this does not translate into improved final benchmark performance. We further evaluate AdamW and Muon for task-general SFT of open-weight models, across the Llama and Qwen families up to 14B parameters, where Muon remains competitive with AdamW, despite these models having been pretrained with AdamW. Together, our results suggest that the choice of optimizer for post-training can be made largely independently of the optimizer used during pretraining.

Thu 15 OctMachine Learning
The gist
Changing the method used to train large language models partway through does not cause lasting harm to how well the models perform. The authors trained and fine-tuned big language models using two different optimizer methods called AdamW and Muon, sometimes switching between them. They found the final results mainly depend on which optimizer is used during each phase separately, with little penalty for switching. Although staying with the same optimizer during fine-tuning reduced some forgetting, it did not improve overall results. This means developers have flexibility in choosing optimizers for different training stages without hurting model quality.
Open → 2610.22650v1

Federated skill updates improve language model agents without sharing data

FedSkillGit: Federated Skill Evolution via Version Control

Abstract: Large language model agents can improve their capabilities by evolving reusable natural-language skills from execution experience. In real-world deployments, this experience is distributed across data owners who cannot pool their raw data, which motivates federated skill evolution. The natural first design lets each client evolve the whole skill document and upload the result for server-side aggregation. That design is poorly matched to skill evolution for three reasons. An evolved document can still carry client-specific content distilled from private traces, repeated transmission of a nearly unchanged document spends communication on knowledge that the population already holds and the contribution of a single client is buried in a document that the server cannot meaningfully attribute. We propose FedSkillGit, a federated skill evolution framework that replaces full-document updates with commits. Each participating client submits a bounded set of patches over named rules together with its local experience, which summarizes what the round taught it, and the pair passes a two-stage privacy filter before it leaves the client. The server deduplicates the submitted patches and the local experience of all participants, updates a global experience document that only the optimizers read, and merges the surviving patches into a candidate skill. The candidate is distributed to the clients, which score it on their own validation sets and report the results, and it is published only when the reported scores improve on the current version. Experiments on three datasets and three language model families show that FedSkillGit outperforms state-of-the-art baselines by up to 22% and approaches centralized evolution without sharing raw client data.

Thu 15 OctArtificial Intelligence
The gist
When many people or groups want to improve language models by sharing what they've learned, they usually have to share their original data, which might be private. The authors found a way to let each group send small changes, or 'patches,' to a shared skill set instead of whole documents. This method reduces unnecessary data transfer, keeps private information safe, and helps build better shared skills faster. Their approach works better than previous methods and almost matches the results of sharing all data centrally, without actually sharing that data.
Open → 2610.21348v1

CoTranslator improves math reasoning training with efficient answer-based translation

CoTranslator: Reverse to Forward Chain-of-Thought Translator for Reasoning Distillation

Abstract: Reasoning distillation requires chain-of-thought (CoT) data with correct answers, but obtaining such data efficiently remains challenging. Forward CoT generation (FCG) followed by rejection sampling (RS) produces verified, question-only responses, yet may require many teacher calls for difficult problems. Reverse CoT generation (RCG) is cheaper because it conditions on the known answer, but access to this answer can lead to post-hoc rationalization and a mismatch with the student's answer-free inference setting. We propose CoTranslator, which learns to translate reverse CoT responses toward the distribution of verified forward responses. Trained on a small set of paired reverse and rejection-sampled forward responses, it supports large-scale generation and verification of student training data. Across six student models evaluated on six mathematics benchmarks, CoTranslator improves average accuracy over semantic suppression by up to $5.82$ percentage points. For two 4B students, it retains $95.0\%$ of rejection sampling's average accuracy while using $35.9\%$ of its estimated compute. Without retraining, the same translator transfers to a new mathematics dataset, a different teacher, and STEM problems, improving average STEM accuracy by $4.88$ and $4.31$ percentage points for 4B and 8B students, respectively. These results show that CoTranslator offers an efficient and transferable approach to reasoning distillation.

Wed 14 OctComputation and LanguageArtificial IntelligenceMachine Learning
The gist
Getting computers to explain their math reasoning step-by-step is hard and slow using traditional methods. The authors show a new way called CoTranslator that teaches computers to turn reasoning that starts from the answer backward into a forward explanation, similar to how people solve problems. This approach requires fewer expensive checks and works well across different math and science tasks. It helps smaller models learn to reason better without needing a lot more computing power.
Open → 2610.20828v1

Llm agents improve tool choice using functional and contextual checks

From Relevance to Validity: Zero-Shot Tool Selection via Functional and Contextual Validation

Abstract: Large language model (LLM) agents increasingly face tasks from unseen domains and execution contexts, making zero-shot tool selection essential for identifying tools that can satisfy task requirements. Existing dominant methods mainly rely on relevance ranking, but semantic matching alone cannot ensure that a tool is functionally compatible or remains applicable in a new context. We preliminarily identify a \emph{transfer-validity gap}, where semantically relevant tools may still fail to satisfy functional or contextual requirements after transfer. To address this gap, we propose \methodname{}, a progressive validation framework that complements semantic relevance with endpoint-grounded functional compatibility and task-conditioned contextual evidence. Across cross-domain and cross-dataset transfer, \methodname{} consistently improves capability ranking, with larger gains under functional or contextual ambiguity. Ablation results further confirm the complementary contributions of functional and contextual validation.

Wed 14 OctArtificial Intelligence
The gist
Choosing the right tool for a task is hard for AI systems when they face new problems they haven't seen before. The authors point out that just picking a tool based on how relevant it seems by meaning doesn’t always work, because the tool might not really fit functionally or in the new situation. They introduce a new method that checks if a tool actually works for the job and fits the context, improving how well the AI picks tools. This method works better especially when it’s unclear which tool is best based on meaning alone.
Open → 2610.20388v1

Scoring format strongly affects language model data filtering quality

The Format is the Filter: Scoring Format Fixes What an LLM Judge Can Express

Abstract: When an LLM judge filters instruction-tuning data, its scoring format (binary verdict, 1--5 rating, 0--100 score, or comparison) is rarely justified or ablated. Holding the candidate pool, judge prompt, decoding and selection budget fixed, we score 15,406 UltraFeedback candidates under five formats with three judges, curate, fine-tune 66 models, and evaluate them with four judges. A 0--100 scale is worth only 7--12 equally used levels, two to three times a 1--5 scale rather than twenty, and a binary verdict leaves the top score tied in 77--78\% of prompts, so most selections are made at random. These properties are set by the format almost independently of the judge. Kendall's $τ_b$ hides them: it ranks binary best while $τ_a$ and top-1 agreement rank it last, because it discounts the ties a selector must break at random. Both comparative formats inherit a slot bias whose sign differs across judges. Downstream, curated data beat random selection under every evaluation judge, robust to length and markdown adjustment, but no ordering among formats is detectable. We propose four quantities that judge-based curation pipelines should report.

Mon 12 OctArtificial IntelligenceComputation and LanguageSoftware Engineering
The gist
When using AI judges to pick the best training examples for language models, the way scores are given makes a big difference. The researchers found that using a score from 0 to 100 does not actually use all those levels effectively, and a simple yes/no result often leads to many ties that have to be broken randomly. These properties depend more on the scoring format than the specific AI judge. Although curated data consistently beats random choice, the exact scoring style used doesn’t clearly matter for final performance. The authors suggest new metrics to better understand how AI judges pick training data.
Open → 2610.17158v1

Efficient fusion of large language models and graph neural networks

DeKoR: Decomposed Knowledge Routing for Efficient GNN--LLM Fusion

Abstract: Large Language Models (LLMs) have shown strong potential for text-attributed graph learning by leveraging rich pre-trained knowledge and language understanding capabilities. Combining LLMs with Graph Neural Networks (GNNs) offers a promising paradigm for expanding the modeling capabilities of graph learning. However, LLMs and GNNs follow distinct learning paradigms, leading to a pronounced mismatch between their knowledge spaces. Such discrepancies make effective knowledge fusion nontrivial. Moreover, existing methods often incur substantial additional computation for only limited performance gains. To address these challenges, we propose DeKoR, an efficient framework for GNN and LLM knowledge fusion. To enable efficient knowledge transfer, DeKoR decomposes LLM knowledge into complementary local and global views and uses the LLM as an offline teacher to distill them into lightweight experts. To enable selective knowledge fusion, an adaptive router learns how much each node should rely on each expert. Extensive experiments on multiple benchmarks demonstrate that DeKoR outperforms existing baselines on both node and subgraph classification, achieving superior effectiveness and efficiency.

Sat 10 OctMachine Learning
The gist
Combining large language models (LLMs) with graph neural networks (GNNs) can improve how computers understand and classify data linked in graphs, like social networks or molecules. But these two types of models learn very differently, making it hard to blend their knowledge effectively without slowing things down. The authors created DeKoR, a method that breaks down the knowledge from LLMs and transfers it efficiently into smaller parts, then selectively uses this information for each data point. Their approach works better and faster than previous methods in tests.
Open → 2610.14710v1

Watermarking technique strengthens federated learning against misuse

Watermarking for Byzantine Robust LLM Training

Abstract: LLM watermarking has emerged as a promising approach for detecting downstream model misuse in centralized settings, but extending it to federated learning (FL) presents unique challenges. In particular, FL systems often rely on strong robust aggregators to defend against poisoning attacks. We empirically show that a malicious server can exploit these same aggregators as effective watermark-removal mechanisms during training, causing representative existing LLM watermarking methods to fail detection in the final model. To address this limitation, we formalize the problem as a constrained optimization task and propose CamoMark, an aggregator-agnostic watermarking scheme for embedding robust watermarks in FL. CamoMark optimizes watermarked updates to become inliers, maintaining bounded deviation from the distribution of clean updates, while preserving sufficient watermark signal for reliable detection. Evaluated on Qwen fine-tuned on the Alpaca dataset, CamoMark achieves a detection confidence of $p$-value $= 1.82\times10^{-2}$ using only 3.3% watermarked data. The watermark also remains robust to a range of post-training removal attacks, including continued fine-tuning on clean data, pruning, and model distillation. At higher watermark ratios, detection confidence improves substantially, reaching $p$-value $= 5.11\times10^{-11}$ at a 13.3% watermark ratio.

Fri 9 OctCryptography and Security
The gist
Watermarking is a way to mark AI models to catch misuse, but it’s tricky to do in federated learning, where multiple users train a model together and need strong defenses against attacks. The authors show that usual defenses can also remove watermarks, making it hard to detect misuse. They propose a new method called CamoMark that hides watermark signals carefully so they can’t be removed by these defenses. Their approach works well on a popular language model and stays effective even if the model is later altered or cleaned.
Open → 2610.14289v1

Self evolving agents improve themselves by updating models and tools together

Evo$^2$: Evolving the Evolver through Weight-Harness Co-Evolution

Abstract: Self-evolving agents are increasingly used to improve language model systems without human intervention through either weight updates or harness improvements. Existing approaches typically pursue these directions separately: some methods update model weights using self-generated experience, while others rewrite the harness that defines how an agent uses prompts, tools, context, and execution feedback. However, these approaches overlook the relationship between model weights and the agent harness. To connect these processes and ensure effective and smooth agent self-evolving, we propose Evo$^2$, a framework for weight-harness co-evolution. For harness updates, we design a unified dual-role pipeline that a single policy serves as both a Proposer, which writes harness edits, and a Reflector, which diagnoses their effects and guides revision. For weight updates, harness modifications and their execution outcomes guide the training of both the Proposer and the Reflector. We further develop EvoTIDE, a training pipeline that recovers usable trajectories through edit extraction and prefix continuation, then combines SFT with interleaved GRPO across the two roles. Extensive experiments across three coding benchmarks demonstrate that Evo$^2$ significantly outperforms existing self-evolution methods. It achieves 82.1% on Polyglot and 48.3% on SWE-bench Verified, compared with 62.6% and 41.0% for the strongest baseline, respectively. We also show that the evolved harnesses transfer to different tasks without further evolution and rank first in cross-benchmark evaluations. Our dual-role harness improvement framework is also able to extend to self-evolution with proprietary models, improving a GPT-5-mini agent's performance from 24.4% to 48.3%. These results demonstrate the applicability of the framework Evo$^2$ across domains and its broad transferability across models and tasks.

Fri 9 OctComputation and Language
The gist
Improving AI agents can involve changing their underlying models or the tools they use, but usually these happen separately. This paper introduces a method called Evo² that updates both the AI's model and its tools together in a coordinated way. The approach uses one policy that suggests and reviews changes, learning from both the edits made and their results. Their experiments show this method works better than previous ones on coding tasks and even helps when trying new tasks or different AI models.
Open → 2610.13025v1

Ai evaluation simulation shows impact of private benchmarks on satisfaction

The AI Evaluation Ecosystem

Abstract: AI evaluation shapes the decisions of model providers, users, funders, and regulators. We argue that designing valid benchmarks requires contextualizing design choices in the dynamics of this ecosystem of actors. We develop a simulation architecture that combines rule-based market dynamics with LLM-driven strategic actors, building on advances in Generative Agent-Based Modeling (GABM). We model benchmarks, consumer needs, and provider capabilities as vectors over a six-dimensional capability space (reasoning, coding, knowledge, safety, communication, agentic), with structural information partitions across actors. As a case study, we apply this stylized simulation to explore benchmark holdout design. We find that moving from public benchmarks to private holdout benchmarks shrinks the gap between benchmark scores and user satisfaction on most benchmarks but widens it on a few, depending on where holdout weights shift scoring credit. We stress-test our findings at both the instrument and case-study level, drawing on the V&V framework of Sargent (2013) and GABM-specific evidence criteria. Beyond holdout design, our simulation is a hypothesis-generating sandbox for studying how evaluator and policy choices, in turn, reshape the ecosystem.

Wed 7 OctArtificial IntelligenceComputers and Society
The gist
Evaluating AI models shapes many important decisions for developers, users, and regulators. The paper presents a simulation that models how different evaluation methods affect the relationship between scores on AI tests and actual user satisfaction. By representing AI capabilities and needs in six key areas, the study tests what happens when benchmarks go from public to private. The authors find that private benchmarks can reduce mismatches between scores and satisfaction on most tests, but may worsen them on some. Their simulation tool can help explore how evaluation choices impact the wider AI ecosystem.
Open → 2610.09296v1

Model merging works better when exploring beyond task weight combinations

A Broader Look at Model Merging: Rethinking Implicit Regularization Induced by Task Arithmetic

Abstract: Model merging aims to build a multi-task model cheaply by combining the weights of individual task-specific models. To perform well across multiple tasks, most existing merging methods use an additional dataset to find the coefficients for the best linear combination of task-specific weight updates. However, we identify an implicit regularization in this standard practice: searching over coefficients restricts the candidate models to a subspace spanned by task-specific weight updates. In this work, we investigate whether this regularization is actually useful. Surprisingly, empirical results show that optimizing merged-model weights without this regularization significantly boosts the performance of common merging methods across multiple architectures, domains, and even in an extremely data-limited scenario where only one instance is available per class. Moreover, directly optimizing the pretrained model weights even outperforms some existing merging methods. Analysis shows that better multi-task weights exist outside the subspace and can be found using multiple methods. We study different strategies for using the additional dataset, discussing their practical use and implications for model merging. Overall, this work calls for revisiting the existing model-merging pipeline, motivating a broader exploration of the weight space and a reconsideration of the implicit regularization induced by task arithmetic.

Tue 6 OctMachine LearningComputation and LanguageComputer Vision and Pattern Recognition
The gist
Combining multiple task-specific AI models into one multi-task model is usually done by mixing their changes in a specific limited way. The authors found that this usual mixing method actually restricts the combined model, which can hurt performance. By allowing the combined model’s weights to be adjusted more freely, they improved performance across different setups and even with very little extra data. This suggests that better combined models exist outside the standard method’s limits and encourages rethinking how we merge models.
Open → 2610.07990v1

Visualerase improves safety by fully removing unwanted image concepts

VisualErase: Dual-Branch Visual Trajectory Redirection for Robust Concept Erasure in Text-to-Image Diffusion Models

Abstract: Concept erasure is essential for the safe deployment of text-to-image diffusion models, as they may reproduce harmful, copyrighted, or privacy-sensitive content learned from unconstrained large-scale data. Existing methods typically erase unwanted concepts while preserving general generation capability by redirecting target-related text-to-image mappings. However, recent studies show that erased models may still retain visual generative trajectories of target concepts, leaving them vulnerable to adversarial recovery attacks and revealing a fundamental gap between redirecting text-to-image mappings and truly removing visual knowledge. To bridge this gap, we propose VisualErase, a new paradigm that redirects concept-bearing visual generative trajectories toward explicitly defined concept-removed outcomes. To enable this redirection, we use structure-preserving image editing to construct content-aligned, concept-removed counterparts for source images, providing explicit visual endpoints that retain non-target content. We then derive a denoising target from each source-to-counterpart pair and use a dual-branch redirection loss to align both text-conditioned and unconditional predictions with this target, since conditional supervision alone does not explicitly constrain generation without textual guidance. To mitigate the adverse effects of concept erasure on non-target generation, we jointly optimize the redirection loss with a counterpart retention loss that matches denoising predictions from the frozen pretrained model. Across style, celebrity, and nudity erasure, VisualErase limits the maximum attack success rate over seven attacks to 0%, 8%, and 0.1%, respectively, while retaining general generation quality. These results highlight the importance of visual trajectory redirection for robust concept erasure beyond text-to-image mappings alone.

Sun 4 OctComputer Vision and Pattern Recognition
The gist
Text-to-image generators can unintentionally recreate harmful or private images they learned from lots of data. Existing methods try to block these unwanted images by changing how the model connects words to pictures, but some hidden image details can still be found and recovered. The authors propose VisualErase, a new way that redirects the model’s image-making process to land on edited pictures where the unwanted parts are removed but everything else stays the same. This approach better blocks attacks trying to recover erased content while keeping the model good at making other images.
Open → 2610.05000v1

Agent harnesses pruned to cut token costs without losing power

SHarP: Saliency-based Pruning of Agent Harnesses

Abstract: Agent harnesses are systems that coordinate model calls, tool use, and task execution to help large language models complete complex tasks. To meet task requirements and address failures, these systems are often iteratively refined by amending and patching their instructions, tools, and workflows, continuously increasing harness complexity. It is therefore unclear whether some resulting harness modules are redundant, introducing substantial token overhead with little, if any, performance gain. Inspired by neural network pruning, in this paper, we study harness pruning as a means of striking a better balance between task performance and token cost. We propose SHarP (Saliency-based Harness Pruning), a simple yet effective pruning strategy based on the saliency of each harness module with respect to performance and efficiency. Specifically, we first identify tools, instructions, and supporting mechanisms as components that can be individually disabled. We then estimate the saliency of each module by ablating it and assessing its task performance and token cost relative to the full set of single-module ablations. Modules with the smallest contribution to performance or largest computational overhead are subsequently pruned. Our evaluation across various harnesses on held-out validation sets reveals a surprising finding: most harnesses that we studied are highly redundant and can maintain comparable performance and efficiency even after a substantial portion of their modules are pruned. Our pruning approach and empirical findings provide new perspectives on agent harness design and optimization.

Sat 3 OctArtificial Intelligence
The gist
Agent harnesses are like toolkits that help large language models handle complicated jobs by combining instructions and tools. The group behind this paper found that many parts of these toolkits are unnecessary and only make the system slower and more costly to run. They created a way to measure how important each part is and safely remove the less useful ones. This pruning leads to simpler toolkits that work just as well but use fewer resources. Their findings suggest many agent harnesses can be made leaner without hurting performance.
Open → 2610.04178v1

Experimental setup details can reverse ranking of stale-data training methods

Probe the Harness: Setup Checks for Stale-Data RL Comparisons in Language Models

Abstract: Methods for training language models on stale samples are judged by comparisons against importance-corrected baselines. We show that details of the experimental harness can reverse the observed ranking of methods, and we introduce PTH (Probe The Harness), a set of checks that makes the harness visible. Our case is a comparison between SAN, a behaviour-free method, and truncated importance sampling (TIS) on verl and in a single-GPU trainer, in which SAN first finished ahead in both stacks. Four details of the harness changed this comparison: the PPO ratio was taken against the learner's own recomputed probabilities, the data seed did not reach the TIS arm, the replay queue reused its first batch for 33 updates, and two loss normalisers differed from their description. In each case the logged quantity looked consistent with a working setup, while the quantity that defines the comparison went unchecked. With the harness checked, TIS matches SAN on verl, and in the trainer TIS learns steadily while SAN keeps a margin. We contribute the signature of each detail and its effect on the comparison, reference results for TIS and uncorrected GRPO under sampler lag, and the PTH checklist.

Fri 2 OctMachine LearningComputation and Language
The gist
Training language models using old data can be tricky to compare properly. The authors show that small hidden details in the testing setup can switch which training method looks better. They created a checklist called PTH to reveal these hidden setup details and make comparisons clearer. Using PTH, they found one technique called TIS performs as well or better than SAN when setup issues are fixed.
Open → 2610.02911v1

How enrichment methods affect reinforcement learning with sparse rewards

Understanding Enrichment in Reinforcement Learning

Abstract: When rewards are sparse, reinforcement learning with verifiable rewards (RLVR) often uses hints or intermediate guidance to generate more successful rollouts. This enrichment biases policy-gradient updates unless corrected via importance weights, but existing methods omit correction or truncate importance weights in order to avoid the high variance of correction. It thus remains unclear what exactly is gained or lost in RLVR by correcting enriched rollouts. We show, mathematically, that omitted or truncated correction implicitly reweights the defined reward, and we decompose the resulting gradient error into scale, rotation, and variance to explain their distinct effects on learning. To make correction practical, we develop a novel sequential Monte Carlo (SMC) weight correction mechanism that, under stability and particle-order assumptions, tempers the exponential compounding of standard correction variance over the length of a sample to an additive accumulation. We then apply our analysis of enrichment to interpreting the results of a fine-tune of Qwen3-1.7B on a sparse band of OpenMathReasoning, establishing a concrete mechanism of how enrichment, both corrected and uncorrected, helps avoid collapse in sparse domains. Our main contribution is to understand, in general, how enrichment and correction can affect training, as opposed to claiming that either mode of operation is superior to unenriched RL.

Fri 2 OctMachine Learning
The gist
Reinforcement learning can struggle when rewards are rare, so sometimes extra hints or guidance are added to help the learning process. The authors show that if these hints are not properly adjusted during training, the learning updates can become biased in hidden ways. They provide a detailed breakdown of the errors this causes and propose a new weighting method to make corrections more stable over long sequences. Their work clarifies how these hinting methods impact learning performance, without claiming one approach is always better than the other.
Open → 2610.02846v1

Multimodal language models improve perception with spatial self-distillation

Where-OPD: Spatially Guided On-Policy Self-Distillation of MLLMs with Synthetic Scenes

Abstract: On-policy self-distillation has recently emerged as an effective approach for improving language-model reasoning by supervising students with a frozen or EMA version of themselves that receives privileged information. Its application to multimodal large language models (MLLMs), however, remains largely unexplored. Recent approaches use privileged visual information, such as image crops corresponding to a question, to improve fine-grained perception, but their gains are confined to tasks that benefit from such visual zooming and require either human-annotated grounding data or external teacher models. We introduce a different form of on-policy self-distillation for MLLMs that provides the teacher with textual, spatially grounded guidance identifying the visual elements relevant to a query. We use procedurally generated scenes with automatically available object identities and spatial coordinates, enabling scalable and annotation-free post-training. The teacher uses this spatial guidance to locate and integrate evidence from multiple relevant image regions, while the student learns to reproduce the resulting behavior from the image and question alone. Our approach consistently improves performance on counting, document and chart understanding benchmarks across multiple models. Importantly, although post-training uses only synthetic scenes, the resulting improvements transfer to real-world perception benchmarks, yielding a 3.23-point gain in average performance across CVBench, V*, ZoomBench, BLINK, HR-Bench, and MME-RealWorld. These results show that spatially grounded privileged information can induce broader perceptual capabilities through on-policy self-distillation, enabling substantial synthetic-to-real transfer beyond the task and data distribution used for post-training. Project page: https://github.com/sirkosophia/Where-OPD

Thu 1 OctComputer Vision and Pattern RecognitionArtificial IntelligenceComputation and Language
The gist
Multimodal large language models combine images and text to answer questions, but their visual understanding can be limited. This paper shows a way to teach these models better by giving a teacher model extra hints about where important parts are in an image using synthetic scenes. The student model learns to find relevant details on its own without needing extra hints later. This approach helps the models do better on tasks like counting objects or reading charts, even on real-world images, despite training with made-up scenes.
Open → 2610.02117v1

Llm agents vulnerable to attacker skill chains causing harmful actions

Chaining Skills to Hijack LLM Agents

Abstract: LLM agents use skills to improve performance on specialized tasks. To complete a user request, an agent may invoke several skills in sequence, allowing information produced under one skill to guide the next. Because skills may come from open-source repositories, this handoff can also carry attacker-controlled claims into later decisions. In this paper, we introduce APEX, which constructs and refines adversarial skill chains tailored to a user task and an attacker-selected action. The key insight is that an agent-written record of genuine task progress can carry a false claim of user approval across skills: an upstream skill induces the agent to create the record, and a downstream skill uses it to direct the attacker-selected action. Across four targeted-action families and six models on SkillsBench, the chains induce the selected action in 512 of 690 attempts (74.2%). On GPT-5.4, the full chain succeeds in 84.3% of attempts, compared with 17.4% when the workflow is merged into one skill. We further evaluate a prompting defense that asks the agent to check skill-produced files against the original request. On GPT-5.4, it lowers targeted-action success from 84.3% to 59.1%, while the verifier test-pass rate across 72 benign native-skill tasks falls from 86.7% to 56.3%. These results highlight the need for defenses that prevent attacker-directed actions while preserving legitimate task performance.

Thu 1 OctCryptography and SecurityArtificial Intelligence
The gist
LLM agents complete tasks by using different skills in a chain. The authors show that attackers can trick these agents by linking skills that pass false approvals, making the agent do harmful actions without the user's real consent. They created APEX, a way to build such attack chains, and tested it on many models with high success. They also tried a defense to have the agent check if skill outputs matched the user's request, which reduced but did not eliminate attacks, and sometimes hurt normal task success.
Open → 2610.01564v1

Language-model search improves by skipping repeated reasoning errors

CORE: Conflict-Oriented Reasoning Elimination for Verifiable Language-Model Search

Abstract: Test-time reasoning systems often respond to failure by restarting or revising the latest step, even when an earlier decision caused the error. We introduce CORE, a search controller that requests a certified conflict core from a verifier, backjumps to the latest decision in that core, and caches the conflict to avoid repeating it. Under sound verification, finite branching and depth, and exhaustive proposals, the uncapped search is complete and never prunes a valid solution. On 2,000 planted graph-coloring instances with matched proposals and an exact verifier, CORE reduces median verifier calls by 39.8% at 30 variables and 35.0% at 36 variables relative to chronological repair; caching further improves on backjumping alone. Across five reasoning tasks, CORE achieves 75.9% mean success with Qwen2.5-7B-Instruct and 84.2% with Qwen3-8B, compared with 72.5% and 81.8% for Tree of Thoughts. It also uses fewer verifier calls and generated tokens on both backbones. These results show the value of using certified failure explanations to direct language-model search.

Wed 30 SeptComputation and Language
The gist
When language models try to solve problems step-by-step, they often restart from the last step when they fail, missing earlier mistakes that caused the issue. The authors introduce CORE, a method that identifies the key earlier decisions that led to failure and jumps back directly to fix those, avoiding wasted effort. This approach also remembers these problem areas to prevent repeated mistakes. Experiments show that CORE makes the search process more efficient and increases success rates compared to prior methods.
Open → 2609.39069v1

Cache compression improves large language model memory use and accuracy

KV-Kaizen: Learning Context-Adaptive Cache Compression Choices

Abstract: As the context size of text processed with an LLM grows, the size of KV caches can outstrip the memory allocated for the original model weights. This impacts LLM throughput negatively, since decoding is memory-bound and decode cost grows with cache size. Recent work alleviates this bottleneck by discarding the least relevant tokens. Eviction introduces a tension, since a one-off decision to discard content may prove detrimental later. Instead, we focus on alternative choices that can lead to cache compression without evicting tokens. We achieve this by learning a selector that is able to produce, based on context, a per-layer cache configuration towards an overall compression budget. The selector operates along three axes: sharing one cache across layers (depth), caching at fewer bits (precision), or truncating the low-rank latent cache representations (rank). We call the resulting method KV-Kaizen, for the many small per-layer choices it compounds. We observe that these interventions taken independently and uniformly over all layers limit achievable compression because they degrade accuracy. Crucially, composing them locally and adaptively to the context can instead preserve accuracy while achieving large memory savings. At inference, the selector runs once, before pre-fill. In evaluations on instruction following and reasoning tasks, our selectors reach the Pareto frontier of accuracy against cache size, against learning-free and post-hoc baselines. On long-context tasks, KV-Kaizen improves on eviction and can be composed with it, reaching a 32x smaller decode-time cache on a 14B model while preserving accuracy. A 4x cache size reduction incurs no accuracy degradation from 7B parameters up, and a compressed model is more accurate than a smaller uncompressed one with the same cache size. Together, these findings support pre-training large models and compressing them only afterwards.

Tue 29 SeptArtificial Intelligence
The gist
Large language models (LLMs) keep track of recent words using memory called KV caches, which grow big and slow down the model. The authors found a way to shrink this memory without throwing away any stored words by choosing the best compression method for each part of the model based on the current text. Their method, called KV-Kaizen, mixes three ways to reduce memory without hurting the model’s accuracy. This approach works better than just removing old words and can make big models run faster while keeping their performance.
Open → 2609.37988v1

Asynchronous reinforcement learning tuned for faster large language model training

Where Does Staleness Accumulate? Pool Aware Effective Staleness Control for Asynchronous RL in LLM Post-Training

Abstract: Fully asynchronous reinforcement learning (RL) improves resource utilization in large language model post-training by overlapping rollout generation with policy optimization, but it also introduces policy lag as trajectories are generated and queued while the trainer continues to update. We study how this lag accumulates over a trajectory's lifetime and how it can be controlled without sacrificing the wall-clock benefits of asynchronous execution. We decompose trajectory staleness into Generation Staleness, accumulated before rollout completion, and Waiting Staleness, accumulated after a completed trajectory enters the pool. Motivated by this decomposition, we introduce PACE (Pool-Aware Control of Effective Staleness). PACE converts excess pool occupancy into an adaptive rejection budget and ranks completed trajectories using an effective-staleness score that combines Waiting Staleness with prefix-aware Generation Staleness. This avoids penalizing long or interrupted rollouts solely because they span multiple policy versions. In single-turn mathematical reasoning, PACE improves the six-benchmark average validation accuracy by 18.7\% over unfiltered asynchronous RL at the same wall-clock budget and matches synchronous RL performance with 47.1\% less GPU time. PACE also improves validation performance in multi-turn tool-integrated reasoning, outperforming both synchronous and unfiltered asynchronous RL. Further experiments with the mixture-of-experts model and an alternative RL algorithm support its applicability across model architectures and training algorithms.

Tue 29 SeptArtificial Intelligence
The gist
Training large AI language models efficiently is tricky because different parts of the training happen at different speeds. The authors studied how delays, or 'staleness,' build up during this process and created a method called PACE to carefully manage it without slowing things down. PACE sorts training data based on how outdated it is and selectively uses it to keep training effective. This approach improved accuracy and reduced GPU usage compared to older methods.
Open → 2609.36830v1

Reward rate policy gradient improves efficiency in machine learning agents

Reward-rate Policy Gradient for Efficient Machine Learning Engineering Agents

Abstract: Traditional reinforcement learning (RL) techniques focus on maximizing expected cumulative reward, where each action assumes to take a constant unit of time. However, this assumption does not hold for agentic RL tasks such as machine learning engineering (MLE) agents, where actions involve data loading, feature engineering, and model training that take variable durations. Efficiency matters in modern agentic RL where actions are costly. To address this limitation, we adapt from continuous-time RL and Semi-Markov Decision Process (SMDP) formulation and propose Reward-rate Policy Gradient (RPG), where we focus on optimizing the reward rate -- the long-term reward per unit of time. RPG estimates the reward rate from off-policy samples, then charges each action for the time it consumes at that rate. We first conduct theoretical analysis in the bandit setting to establish that RPG approximates the optimal reward rate and empirically demonstrate it outperforms baselines while avoiding enumeration over the policy space, a known issue for an existing method. We then further apply RPG on a small language model (Qwen3.5-4B) with self-improvement loops and empirically show it obtains higher rewards within a fixed time budget than vanilla RL on MLE-Bench and NanoGPT, with a 19.2% and 85.7% margin, respectively. Our method provides a practical solution for optimizing performance under wait time considerations in modern agentic RL tasks, where actions interact with external environments and cost time.

Mon 28 SeptMachine LearningArtificial Intelligence
The gist
Many machine learning agents take different amounts of time to do tasks like loading data or training models, but traditional methods assume every step takes the same time. The authors proposed a new approach that focuses on the reward earned per unit of time, making the agent more efficient. Their method estimates how well actions perform considering the time they take and adjusts the agent’s decisions accordingly. They tested it on small language models and found it performs better within fixed time limits compared to usual methods.
Open → 2609.36393v1

Iterative merging improves combining multiple teacher models into one

No Pain, More Gain: Iterative Merging for Effective Multi-Teacher On-Policy Distillation

Abstract: Multi-teacher on-policy distillation (MOPD) combines independently developed domain teachers into a single student by distilling their predictions on student-generated samples. We study a setting where teachers share a reference model but undergo different post-training procedures, and find that MOPD can struggle to recover some teacher capabilities. Because distillation occurs on student-generated prefixes, the student initialization can strongly affect subsequent recovery. However, initial benchmark performance is not a reliable predictor of a good MOPD initialization. For example, merge initialization can start below SFT warm-up yet finish higher after MOPD. We further find that effective merging depends on both the relative teacher contributions and the overall merge scale, with some strong configurations lying outside the simplex of convex parameter averaging. Thus, selecting a good merge initialization requires evaluating not only its immediate performance but also the learning it enables under MOPD, making one-shot coefficient search difficult. We propose Iterative Merging for MOPD (IM-MOPD), which starts from a uniform merge and progressively adds task-vector increments for under-recovered domains during distillation. In a 5-domain setting, IM-MOPD achieves higher average normalized recovery than MOPD with either uniform merge initialization or SFT warm-up, showing that effective teacher contributions can be determined progressively during training.

Mon 28 SeptMachine LearningArtificial Intelligence
The gist
When combining different expert models into a single one, starting from certain initial combinations is important but hard to predict. The authors found that simply averaging or warming up the student model isn't enough to capture all teachers’ strengths. They propose a method that gradually adds the unique contributions of each teacher during training. This approach leads to better overall performance across different tasks.
Open → 2609.34745v1

Language model routing improves by using semantic probabilities

SeLMRoute: Probabilistic Semantic Evidence for Large Language Model Routing

Abstract: Large language model (LLM) routing aims to select the most suitable model for each incoming query. Most existing routers learn this decision directly from query embeddings, model representations, preference data, or clusters of similar examples. Such approaches can be effective, yet the representation used for routing rarely states what a query actually requires. We introduce SeLMRoute, a routing framework that separates the extraction of candidate-independent semantic evidence from the learning of candidate performance and the application of deployment objectives. A decision model first evaluates a set of interpretable questions about the query, such as its reasoning requirements and use of external knowledge, with each judgment retained as a probability distribution. The resulting probabilistic semantic state is used by a lightweight supervised router to estimate candidate model performance. Routing objectives are applied after performance estimation, which allows the same semantic state to support performance-oriented and cost-aware decisions. On the LLMRouterBench (15 datasets, 20 candidate models, 11,481 queries), SeLMRoute achieves an average accuracy of $72.08\% \pm 0.45$, while grouped five-fold out-of-fold evaluation reaches $72.64\%$, compared with $69.23\%$ for the strongest fixed candidate. The representation achieves the highest mean performance among the evaluated semantic, dense, lexical, and domain-level representations. In a separate 13-model performance-cost setting, SeLMRoute improves performance in all five grouped splits, with a mean PerfGain of $2.66\%$. Our code is available at https://github.com/Indigma-Innovations/SeLMRoute.

Mon 28 SeptArtificial IntelligenceComputation and LanguageMachine Learning
The gist
Choosing the right language model for a question is tricky because most methods don't clearly explain what the question needs. The authors introduce SeLMRoute, which first breaks down questions into simple, understandable parts and estimates these parts as probabilities. Then, a light model guesses how well different large language models might answer based on these parts. This approach helps pick better language models for questions and works well across many tests.
Open → 2609.34736v1

Language model internal states reveal harmful action patterns better than guard models

Agent Safety From Within: Detecting Harmful Trajectories from LLM Internal States

Abstract: Language model agents can now perform sophisticated sequences of actions via tools and harnesses, which has increased the scope of the damage they can cause. Guard models, however, are mainly built for content moderation and thus are not well-suited to detecting this agentic risk. To address this, we proceed by first conducting a representational analysis, then use the resulting insights to build a solution. In our analysis, we focus on two types of trajectory-level agentic harms: harmful content, which is expressed directly, and unsafe tool use, which depends on whether an action is consistent with the interaction that produced it. We investigate how open-source guard models represent these two types of harm and find that they are linearly readable inside the model, even though guard models predict no better than chance on pairs that differ only in the called tool's schema. The two harm types also follow nearly orthogonal internal directions, and neither reliably serves as a proxy for the other. These results motivate reading trajectory safety directly from internal states. We introduce TACIT, a readout of a frozen backbone's internal states that decodes no tokens. Trained on six trajectory-safety benchmarks, a linear probe raises mean macro-F1 from 62.3 for the strongest open guard to 80.7, and refined readouts reach 86.2. With each benchmark held out of training entirely, the refined readouts still lead the strongest guard (65.7 vs. 61.1). With the same backbone, training data and test split, the frozen readout is on par with full safety fine-tuning, and it improves the fine-tuned model further when applied on top. The probe trains about one millionth as many parameters as full fine-tuning in about a sixth of the time, and TACIT has the lowest latency of the guards we evaluate.

Sun 27 SeptArtificial Intelligence
The gist
Large language models can take multiple steps using tools but might perform unsafe or harmful actions during this process. The authors studied whether harmful behavior can be detected from inside the model’s own internal data rather than relying on external safety checks. They found harmful actions hidden in the model’s internal states in ways previous guard methods missed. This led to building a system called TACIT that reads the model’s internal signals to detect unsafe behaviors more accurately and efficiently than prior methods.
Open → 2609.33039v1

Fine-tuning language models to balance learning and generalization

SoFT: Soft Targets for Generalizable LLM Fine-Tuning

Abstract: Distillation enables student language models to acquire new capabilities from expert teachers. However, integrating knowledge from multi-teacher, multi-domain demonstrations into a single student remains challenging. We study supervised fine-tuning (SFT) in this setting, where students must acquire diverse capabilities while maintaining generalization beyond the training tasks. Our experiments reveal varying trade-offs between in-distribution learning and out-of-distribution generalization across SFT methods, motivating more explicit control over this balance. To this end, we propose soft-target fine-tuning (SoFT) to balance learning from teacher demonstrations with retaining the Base model's existing capabilities. SoFT sets a minimum target probability for each demonstrated token while making the smallest KL change to the Base distribution. The resulting objective couples learning from demonstrations with adaptively weighted regularization toward the Base model. We further use domain-specific gradient budgets to control this balance and determine a probability threshold for each trajectory. Experiments on mixed-domain reasoning and agentic tasks show that SoFT achieves the best overall performance among the compared methods, with improvements in both in-distribution capability acquisition and out-of-distribution generalization.

Sat 26 SeptMachine LearningArtificial Intelligence
The gist
Training smaller language models to learn from multiple expert teachers can make them better at different tasks, but it’s hard to keep them good at things they weren’t explicitly trained on. The authors study how different fine-tuning methods affect the balance between learning new skills and staying versatile. They propose a new fine-tuning method called SoFT that gently nudges the model to learn new tasks while keeping old abilities intact. Tests show SoFT improves performance both on tasks the model was trained on and on new, unseen tasks.
Open → 2609.32493v1

SCLATE platform improves testing and training of continual-learning AI agents

SCLATE: a Substrate for Continual-Learning Agent Training and Evaluation

Abstract: Continual-learning agents are systems of models, harnesses, and memory operating over long multi-session horizons. Evaluating and training them requires interleaving tasks with agent-side events such as session stop and start, crons, and memory consolidation. Yet existing benchmarks and training frameworks schedule only the benchmark's own events, leaving each benchmark and agent pair to build a custom scheduling loop. We present SCLATE, an execution substrate where benchmarks and unmodified agents each add their events to one open event scheduler through an adapter. A hybrid simulated clock runs these events on a shared timeline, flowing in real time while the agent works and skipping idle gaps, which compresses a month-long scenario into hours. SCLATE also serves as a rollout engine that runs any agent's harness and memory unmodified, recording the tokens and log probabilities of every model call through an in-container proxy. We port seven benchmarks to SCLATE and compare ten unmodified harness and memory configurations head to head on ten models. The comparison shows that an added memory system does not reliably beat the harness's native memory and that models differ widely in how they use the same harness and memory. We then post-train Qwen3.5-4B through unmodified harnesses and memory systems. The model learns to use both, reading 6.8x fewer file lines with a 16.7-point higher SWE-bench Verified pass rate, and writing richer memory records, while its held-out MetaClaw accuracy rises by up to 11.8 points.

Sat 26 SeptArtificial IntelligenceDistributed, Parallel, and Cluster ComputingMachine Learning
The gist
Continual-learning AI agents need to be tested and trained over many sessions with different tasks and breaks. The authors created SCLATE, a system that can schedule all these activities together on one timeline, making it easier to run month-long tests in just hours. They showed that adding extra memory to agents does not always help and that different AI models use memory in very different ways. They also improved a model’s performance by training it with various memory setups without changing the original training code.
Open → 2609.32391v1

Multilingual AI models reveal brain-like first-word language circuits

FTB Graph: Determining and Validating First-token Broadcasters and Language-Identity Head Circuits in Multilingual Language Models

Abstract: Large language models operating in multilingual contexts must resolve target response languages early in generation, yet the causal circuitry governing first-token language identity decisions remains poorly mapped. We present an end-to-end structural circuit analysis across six model architectures spanning four families: GPT-2, BLOOM-560M, Pythia-1B/2.8B, and Qwen2.5-1.5B Base/Instruct. Using Edge Attribution Patching (EAP) with FP16 active clamping, followed by exact activation patching verification with a 2,000-candidate-edge search ceiling, we extract directed acyclic graphs driving first-token language broadcasting. Across the standalone models, we observe deep or mid-to-deep broadcasting hubs, though the evidence is strongest for Pythia-2.8B and BLOOM-560M because GPT-2 and Pythia-1B leave few out-of-graph heads for comparison, while both Qwen2.5-1.5B variants invert the necessity check. Scaling from Pythia-1B to 2.8B expands node participation while maintaining a similar verified edge budget, producing sparser topology. The Qwen2.5-1.5B base and instruct circuits retain 84.7% Jaccard similarity, including the Layer 27 hub, indicating that first-token routing is largely established during pretraining and preserved by instruction tuning. Finally, EAP scores correlate weakly with exact patching deltas across most models, showing that linear gradient approximations can diverge from causal interventions in FP16 and motivating exact-patching verification for reliable circuit discovery.

Fri 25 SeptArtificial Intelligence
The gist
When AI models talk in many languages, they decide which language to use from the very first word they generate. The authors studied this early language choice by analyzing how six different models direct information inside themselves. They found specific parts of the models act like hubs controlling the choice of language right at the start. Their techniques also showed that some popular shortcuts to understanding these decisions can be misleading, so exact checks are important. This helps better understand how AI models manage multiple languages during conversation.
Open → 2609.30954v1

Human agent collaboration improves when interfaces show how decisions form

The Interface Is Downstream: Designing the Terms of Human-Agent Collaboration

Abstract: Before an agent responds or acts, much of the experience has already been designed. Memory and retrieval shape what it notices. Evidence rules shape what it may claim. Permissions shape what it can do. Learning rules shape what it carries into the next encounter. The argument comes from Alicia, a personal agent I've built and used since January 2026. A fine-tuning pilot produced no defensible model-performance result. It exposed a provenance failure: Alicia repeated an interpretation from a retrieved synthesis, cited a source note credited by that synthesis, and left the synthesis out of the visible chain. In a model-blind review of thirty-three citations, one reviewer judged that the retrieved intermediary supplied the claim in sixteen relayed citations and part of it in four. Five of twelve citations to directly retrieved targets lacked support in the target excerpt supplied for review. These judgments remain unadjudicated, and the packet is not public. I call the shared setting a humorphic environment: a persistent computational setting that translates a human practice into software. The first Humorphism paper translated partnership. This paper translates the studio, the room where practice happens. The failure prompted an audit of attention, evidence, action, and learning, with a review artifact and available recourse for each. The test is whether the person can inspect and contest what shaped the teammate's behavior. The output is downstream. Correction, consent, and learning carry the collaborative interface back upstream.

Wed 23 SeptHuman-Computer Interaction
The gist
People working with AI helpers often don’t see how the AI decides what to say or do. The authors studied their own AI assistant named Alicia and found that it sometimes repeated information without showing the full source, making it hard to check facts. They call the environment where AI meets human practice a humorphic environment and suggest that better tools should let users inspect and challenge the AI’s memory, evidence, permissions, and learning steps. This way, the AI and human can work as true partners with clear, inspectable reasoning.
Open → 2609.28801v1

Rollout efficiency improves reinforcement learning in large language models

Rollout Efficiency in Reinforcement Learning for Reasoning Large Language Models: A Taxonomy and Future Directions

Abstract: Reasoning-oriented reinforcement learning enables large language models to solve mathematical, coding, and other multi-step tasks, but shifts a substantial portion of the training cost to rollout, where trajectories are generated for policy updates. Efficient rollout mechanisms are therefore essential to reduce this cost while maintaining the freshness, consistency, and statistical validity of training data. This survey provides a systematic taxonomy of recent research on rollout efficiency for reasoning-oriented reinforcement learning, classifying existing approaches from both mechanism and bottleneck perspectives. Based on this taxonomy, we analyze how different technique families address distinct sources of rollout inefficiency, examine opportunities and potential conflicts for combining them, identify gaps in the evaluation and reporting of efficiency gains, and discuss open challenges and future research directions.

Mon 21 SeptArtificial IntelligenceDistributed, Parallel, and Cluster Computing
The gist
Training large language models to solve step-by-step problems like math or coding takes a lot of computing power, especially when generating example solutions (called rollouts). The authors organize and explain recent ways to make this rollout process more efficient without losing accuracy or freshness of data. They identify different challenges and how techniques try to solve them, as well as gaps in how improvements are measured. Finally, they point out open questions to guide future research in this area.
Open → 2609.25463v1

Model merging improves by adapting to task differences and depth

Beyond Uniform Subspaces: Spectrum-Aware and Depth-Adaptive Fusion for Multi-Task Model Merging

Abstract: Model merging aims to consolidate multiple task-specific models without access to extra training process. However, existing subspace-based methods largely rely on a uniform treatment of task updates, overlooking their intrinsic spectral and depth-wise heterogeneity. We identify two key deviations from this assumption: different tasks require different subspace capacity and exhibit different tolerance to spectral transformation, while subspace projection introduces depth-dependent distortion. Based on these observations, we propose SADA-Merging, a spectrum-aware and depth-adaptive framework for data-free model merging. SADA-Merging allocates task-specific subspace capacity according to spectral complexity, adapts spectral preservation according to task-wise plasticity, and applies depth-dependent anchoring to compensate for projection-induced distortion. This enables the fusion process to adapt to both the intrinsic geometry of each task and its sensitivity across network depth. SADA-Merging operates directly on task updates and is applicable to both full fine-tuning and LoRA settings. Extensive experiments demonstrate consistent improvements over existing data-free merging methods across different task scales and adaptation settings.

Mon 21 SeptComputer Vision and Pattern Recognition
The gist
Combining models trained for different tasks usually treats all tasks the same, which can miss important differences. The authors found that tasks vary in how complex their updates are and how sensitive they are to changes across different layers of the network. They created a new merging method that adjusts to these differences, improving how multiple task models can be combined without extra training. Their approach works well on two popular types of model updates and shows consistent gains in experiments.
Open → 2609.24612v1

Security risks in autonomous ai systems need more thorough testing

Connecting the Dots in Agentic AI Security: A Cross-Dimensional Threat Taxonomy, Evaluation Maturity, and Open Challenges

Abstract: Agentic AI extends LLM security beyond generated content to persistent state, autonomous actions, tool use, and interactions with humans and other agents. Existing threat classifications often emphasize individual dimensions, obscuring connections among entry points, affected components, and security consequences. The known threat landscape also differs from the coverage demonstrated by empirical research. Through a structured review of 66 studies published from 2022 to 2026, we introduce T={S, B, P, A}, a cross-dimensional representation linking affected functional or system surfaces {S}, interaction or trust boundaries {B}, violated security properties {P}, and empirically examined architectures {A}. We analyze 22 artifact-backed red-teaming studies and 11 representative security benchmarks to characterize empirical coverage and evaluation maturity. Within the selected studies, evidence concentrates on prompt/reasoning, memory, and tool-mediated attacks, predominantly in single-agent settings. Persistent, Human--Agent, complex multi-agent, systemic, and long-horizon threats receive less coverage. These findings describe the selected corpus rather than establish gaps across all empirical research. Heterogeneous metrics, limited adaptive defense evaluation, architectural imbalance, and incomplete execution-state capture further constrain comparison and reproducibility. We derive 13 open research questions to guide more systematic, architecture-aware, and reproducible security evaluation of agentic AI.

Sun 20 SeptCryptography and SecurityArtificial Intelligence
The gist
Agentic AI refers to smart systems that do more than just create text—they keep information over time, take actions, use tools, and interact with people or other AI systems. The authors found that existing studies often look at only one aspect of these systems’ security but miss how different parts connect. They reviewed many studies and identified which types of risks and attacks have been tested well, like tricking the AI’s reasoning or memory in simple setups. However, more complex threats involving long-term actions, multiple agents, or human interactions are less studied. The authors suggest new questions to guide future research for stronger and more reliable AI security testing.
Open → 2609.23894v1

Ai reviewer training risks causing loss of scientific judgment diversity

When AI Reviews Train AI Reviewers: Scientific-Judgment Collapse and Mitigation

Abstract: Large language models (LLMs) increasingly participate in scientific evaluation, both as automated reviewers and as assistants to human reviewers. As model-generated reviews enter public data and future training corpora, AI peer review can become recursive: later reviewers learn from judgments produced by earlier models. We study one step of this feedback loop in a controlled setting. Starting from Llama 3.1 8B, we first fine-tune a reviewer on official ICLR reviews from 2018--2023 and then train four successor models on ICLR 2024 data with systematically varied mixtures of official and model-generated reviews. Our study shows that introducing synthetic reviews compresses rating distributions and reduces both same-paper and corpus-level semantic diversity. We call this pattern $\textbf{scientific-judgment collapse}$. To mitigate this failure mode, we introduce $\textbf{TrustReviewer}$, an open-source LLM-based system for generating peer reviews of AI and machine learning papers. TrustReviewer intervenes at two complementary stages. For training-time prevention, we train the core reviewer in a single stage on a curated corpus designed to reduce low-quality and semantically degenerate supervision. For test-time correction, paired activation steering aims to further mitigate residual tendencies toward collapsed judgments without further training or additional expert annotation. Together, these results characterize a concrete risk of recursive reviewer training and provide practical interventions for preserving judgment diversity and improving recommendation alignment in AI-assisted scientific evaluation.

Thu 17 SeptMachine Learning
The gist
AI models are starting to review scientific papers, but when these AI-generated reviews are used to train new AI reviewers, the variety and richness of their judgments shrink. The authors call this problem scientific-judgment collapse. They studied this effect using several versions of AI models trained on real and synthetic reviews. To fix it, they created a system called TrustReviewer that carefully curates training data and adjusts AI behavior during review to keep diversity and quality high.
Open → 2609.20942v1

Chronicle creates repeatable tests for large language model agent failures

Chronicle: Cut-Point Replay for Regression Testing of LLM Agents

Abstract: Large language model responses are non-deterministic, so failures in LLM agents are hard to reproduce: a failure depends on inference that is not bitwise reproducible, on tools that read changing state, and on a multi-step trajectory that a re-run rarely repeats. Record-and-replay makes a run reproducible, but existing agent tooling records runs only to trace or score them, not to test a code change against them. We present Chronicle, which records an agent run at its non-deterministic boundaries as immutable envelopes and replays it from the record. Its central operation, cut-point replay, serves a chosen subset of boundaries from the record and executes the complementary subset live with new code, turning a recorded incident into a regression test that runs in continuous integration. On a benchmark of 6 recorded failures with simulated model boundaries, recording adds 23 μs per crossing (0.008% of an assumed 300 ms model call), full replay issues zero model calls and is bit-stable across 20 repetitions, and cut-point tests fail on faulty code and pass on guarded and benign changes for all 6 incidents. In a mutation study of the guarded tools, cut-point tests catch every mutant that lets the recorded unsafe action through, while a baseline that stubs every boundary, using the same assertion, catches none. Chronicle and the benchmark are publicly available at https://github.com/theagentplane/chronicle.

Thu 17 SeptComputation and LanguageArtificial Intelligence
The gist
Large language models can give different answers each time they run, making it hard to recreate and fix mistakes made by programs using them. The authors present Chronicle, a tool that records key points where the model’s randomness affects the run and can replay these while running new code on other parts. This makes it possible to turn a past failure into a reliable test that checks if code changes fix the problem. They show Chronicle works well on simulated data and can catch more errors than simpler testing methods.
Open → 2609.20625v1

Chatbots vary widely in product advice and sources given

"If I Had to Buy Just ONE: Galaxy S26 Ultra": Auditing AI-Generated Product Recommendations

Abstract: Consumers increasingly use AI chatbots for advice on what to buy. With companies like OpenAI and Google monetising their AI through advertising, this raises difficult questions about the bias and impartiality of such advice. In response, we conduct an AI audit of popular chatbots using real commercial-advice queries. First, we curate a dataset of 2,528 real commercial-advice queries (ConsumerQ). Then, we evaluate 1,536 responses to product queries from popular AI chatbots: ChatGPT (chatbot and API), Google Gemini (chatbot and API), and Google Search (AI Overviews). We find that ChatGPT expresses a first-person product preference in 79% of product-recommending responses, compared with 7% for Gemini and 2% for AI Overviews, while the products recommended often change across repeated requests. Displayed sources vary strongly: for the same query, the ChatGPT and Gemini interfaces share only 5.4% of domains on average, with no domain in common in 76.7% of comparisons. APIs provide a different view from their corresponding interfaces, with mean domain overlaps of 12.0% for ChatGPT and 14.8% for Gemini, and also differ in the types and layers of source information they expose. Our findings show that neither isolated responses nor API observations can be assumed to represent the commercial advice consumers encounter. Independent audits of AI-mediated commercial advice should therefore account for repeated responses, consumer-facing conditions, and the source layer being observed.

Wed 16 SeptComputers and SocietyComputation and Language
The gist
People often ask AI chatbots for shopping advice, but these chatbots give very different answers and mention different websites as sources. The authors studied popular chatbots like ChatGPT and Google Gemini by asking them real questions and found that only ChatGPT often shared its own preferences. The chatbots’ recommendations and source websites changed a lot even when the same question was repeated. This means the shopping advice people get from these AIs can be biased and inconsistent depending on which chatbot or platform they use.
Open → 2609.18729v1

Teacher network structure shapes how well students learn functions

Teacher Geometry Shapes Learnability in Teacher-Student Networks

Abstract: Teacher-student systems, in which a teacher neural network generates training labels so that a student neural network can learn to implement the same function, are widely used as an abstract setting to study learning. However, the structure of the teachers is often overlooked by assuming randomly-generated, normally-distributed parameters. This hides substantial variation in how learnable different teachers are. We formalize learnability as the success rate of converging to the global minimum, as a function of overparameterization, learning algorithm, student initialization distribution, and teacher geometry. We both identify an easy distribution that maximizes node dissimilarity and a hard distribution that minimizes it, and show that these two distributions induce markedly different success rates across a large range of settings and for different activation functions. To explain the gap, we study the loss landscape of small neural networks that contain two distinct kinds of suboptimal local minima, out-of-bounds (OOB) minima at the edge of the data distribution and interior minima within. Assuming infinite data and a fast readout layer, we analytically reduce the loss landscape of small networks to two dimensions, showing that the region of attraction of interior minima changes as a function of teacher structure. In larger networks, maximally dissimilar teachers induce more interior minima, while minimally dissimilar teachers induce more OOB minima. Motivated by these analyses, we show that differentially increasing the learning rate of the readout layer and decreasing the learning rate of the inner biases increases success rates. These findings provide an important step in narrowing the gap between the study of teacher-student networks and more structured functions that arise in practice.

Wed 9 SeptMachine LearningArtificial IntelligenceNeural and Evolutionary Computing
The gist
Teaching one neural network to copy another isn’t always equally easy. The authors show that the internal setup of the teacher network affects how likely a student network is to learn the correct function. They find specific teacher setups that make learning easier or harder by creating different patterns in the learning process. By studying these patterns, they suggest ways to adjust learning rates to improve success. This helps make teaching-student neural network studies more relevant to real-world situations.
Open → 2609.09595v1

NeoHorse-1 improves AI models by learning from their own use

NeoHorse-1: Towards Recursive Self-Improvement via Agentic Post-Training with Routing Harness

Abstract: Recursive self-improvement (RSI) requires a concrete mechanism through which an AI system observes its capabilities and converts that evidence into the next round of learning. We present NeoHorse-1, a family of agent-native models developed to explore this path through agentic post-training. Our system combines a heterogeneous model pool with intelligent routing, recording the predicted capability demand, selected service tier, and subsequent interaction for each user turn. These records are converted into training examples that preserve interleaved reasoning, tool calls, and harness context, and are admitted through structural validation, six-dimensional semantic evaluation, and subscene-level labeling. Routing signals organize supervised fine-tuning into a three-stage curriculum and extend to routing-guided on-policy distillation, where a teacher supervises student-generated responses under the same progression. Capability-guided allocation then converts evaluation feedback into the next training mixture, closing an evaluation-selection-update loop in which what the system learns to do shapes what it learns from next. Across eleven benchmarks covering harness-based agents, tool use, coding, and instruction following, post-training raises the macro-average from 58.94 to 64.87 at 4B and from 65.60 to 69.04 at 9B, substantially narrowing the aggregate gap between the post-trained 4B model and the 9B base model. NeoHorse-1 provides an initial prototype of this feedback-driven process and a path toward harness-mediated RSI across successive iterations.

Tue 8 SeptComputation and Language
The gist
Improving AI often means finding ways for the AI to learn from its own performance in tasks. The researchers created NeoHorse-1, a system where AI models watch their own actions and use that information to get better at future tasks. This happens through a cycle of selecting tasks, recording how the AI responds, and retraining itself using these records guided by a smart routing system. The result was better overall performance on several benchmarks, especially narrowing the gap between smaller and larger AI models.
Open → 2609.08183v1