Papers for

automated customer support 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.

Capability-preserving neuron steering improves language model behavior control

CANS: Capability-Preserving Neuron Steering for Large Language Models

Abstract: Activation steering offers training-free and dynamic control of target behaviors in large language models, but existing methods can impair general capabilities and require domain-specific intervention designs. We introduce Capability-Preserving Neuron Steering (CANS), a unified framework that balances target-behavior control with capability preservation. To make target-behavior improvement and general-capability preservation tractable, we introduce two proxies: log-probabilities of target tokens in model generated responses, and output-distribution KL divergence on general-purpose inputs. Combining the local approximation of the two proxies yields a closed-form solution, enabling lightweight steering without iterative model training or additional inference-time computation. The resulting neuron-wise scaling coefficients achieve effective steering while limiting general-capability loss. A shared data-construction and intervention procedure supports adaptation across domains using sampled responses with target-behavior filtering and target-span annotations. Across safety, toxicity, and hallucination control on Qwen and Llama models, CANS achieves comparable or better steering while better preserving MMLU, BBH, and IFEval performance than SFT, CAA, and neuron-level baselines. On Qwen3-4B, CANS reduces HarmBench attack success from $15.50\%$ to $1.75\%$ with a $1.11$-point decrease in average capability. These results support CANS as a practical approach to behavioral control across domains.

Mon 26 OctArtificial Intelligence
The gist
Controlling how large language models behave can sometimes reduce their overall usefulness. The authors present CANS, a way to steer a model’s responses toward desired behaviors without losing its general abilities. Their method adjusts parts of the model based on mathematical shortcuts, avoiding extra training or slower runs. Tests show CANS can reduce unsafe or incorrect outputs better while keeping the model's skills intact.
Open → 2610.35530v1

Adaptive transfer improves detecting unreliable outputs in language models

Adaptive Transfer of Representational Signatures for LLM Reliability Detection

Abstract: Large language models (LLMs) are reported to be susceptible to reliability issues including hallucinations and reasoning errors. Existing quality detectors can predict unreliable outputs based on internal representations with decent accuracies. However, training these detectors often requires substantial domain-specific labeled data, which limits their applicability to new domains. We propose to address this challenge by transferring representational signatures across related domains. More specifically, we build a statistical framework that first extracts low-dimensional signatures for each domain, then uses cross-fitting to learn composition weights of domain-specific predictors. The weights adapt to each source domain's predictive relevance to the target domain. Our asymptotic analysis of a least-squares analogue characterizes the limiting prediction risk and aggregation weights in terms of domain discrepancies and representation bias. Experiments across multiple hallucination datasets and open-weight LLMs show that, with only 25 labeled questions in the new domain, adaptive transfer improves hallucination-detection AUROC by 6.8%. For reasoning-step prediction, it improves AUROC by 8.4%.

Sat 24 OctComputation and LanguageMachine Learning
The gist
Large language models sometimes give unreliable or wrong answers, which can be hard to spot. The authors show a new way to use knowledge from related areas to better detect these mistakes, even with very little labeled data from the new area. Their approach combines different detectors by learning how well each relates to the new task, improving prediction accuracy significantly. This helps make language models safer and more trustworthy in diverse topics.
Open → 2610.33442v1

Learned tokens improve large language model confidence estimates

Learned Readout Tokens for Extracting Large Language Model Confidence

Abstract: Large language models (LLMs) are increasingly used within everyday applications where their responses have significant downstream impacts. For responsible deployment of such systems, we desire insight into how much we can trust their individual outputs. A popular approach for estimating LLM confidence is to train probes on the hidden states of the LLM's tokens to predict the correctness of the model's output. These probes typically read hidden states from tokens that are already in the model's vocabulary. In this work, we introduce a new approach to confidence probes that learn a new readout token and utilize its hidden states to train the probe. We show that our learned readout approach ScratchProbe outperforms its existing-token counterpart on a variety of datasets and LLMs. We also extend our method to a multi-token approach which we show provides further performance improvements. Finally, since the learned readout changes only the position a probe reads from, any existing probe can adopt it. Applied to a state-of-the-art probe, it improves AUROC on every backbone, in domain and out of domain.

Tue 20 OctComputation and LanguageArtificial IntelligenceMachine Learning
The gist
Large language models often give answers whose reliability we want to measure. The authors propose a new method that creates a special token to better understand how confident these models are in their answers. This new token helps assess correctness more accurately than older methods that just looked at existing parts of the model's output. They tested their approach on several datasets and models, showing consistent improvements in confidence prediction.
Open → 2610.27566v1

Self-play method improves accuracy in document optical character recognition

SP-DocReader: Difference-Aware Self-Play for Precise Document OCR

Abstract: Accurate page transcription remains difficult for vision language models under limited input and training budgets. We present SP-DocReader, a self-play framework for optical character recognition (OCR) that targets residual errors after supervised fine-tuning. Reading Discrepancy Masking aligns reference and generated model tokens through a longest common subsequence, then scores unmatched positions with their full conditioning prefixes. Focused Fidelity Loss adds direct negative log-likelihood supervision at unmatched ground-truth positions. Only the OCR module is trained, while the backbone remains frozen. We derive the combined gradient to distinguish relative score optimization from direct supervision. Compared with SFT-2, SP-DR-3 reduces Vary-600K character error rate on both backbones. On Qwen3-VL-4B, it reduces character error rate by approximately 54 percent and improves DocVQA Average Normalized Levenshtein Similarity (ANLS) by 3.7 points. These results show the value of focusing self-play training on the discrepancies that remain after supervised fine-tuning.

Thu 8 OctComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Reading text from images of documents is still tricky even for advanced AI models because of limited training resources. The authors created a new method called SP-DocReader that focuses on fixing mistakes that remain after normal training. Their method compares the AI’s output with the correct text to find differences and gives extra attention to these errors during training. This approach improves how accurately the AI reads characters and answers questions about documents.
Open → 2610.11148v1

Adaptive iterative repair improves on-policy distillation for math reasoning models

Learning from Evolving Errors: Adaptive Iterative Repair for On-Policy Distillation

Abstract: On-policy self-distillation (OPSD) supplies dense token-level feedback on trajectories sampled from the student's own policy, a richer training signal than the outcome-level rewards of reinforcement learning. This feedback comes from a teacher conditioned on a full reference solution unavailable to the student. The reference solution specifies the target but not how to move from the student's current error toward it, creating a solution-conditioned shortcut risk. We introduce AIR-OPD, an adaptive iterative repair framework for on-policy distillation that provides error-to-repair supervision. Given a failed response, a guidance generator synthesizes repair guidance for the current error. The student samples an on-policy retry with this guidance. If the retry remains incorrect, the generator produces new repair guidance for the newly observed error. At each round, a fixed teacher receives the guidance as privileged context and supervises the student on an error-aligned region of its latest failed response. Outcome-aware stage weighting favors early repair stages and credits stages whose immediate retry passes verification. We train AIR-OPD on the DAPO-Math-17K dataset and evaluate on AIME24, AIME25, and HMMT25, alongside out-of-distribution tests on MMLU-Pro and GPQA. We examine two guidance sources, self-guidance from the current student policy and external guidance from a larger model. For both Qwen3-4B and Qwen3-8B, AIR-OPD attains the best mathematical-reasoning averages, improving over the strongest baseline by up to 3.6 points, while preserving base-model performance on the out-of-distribution benchmarks.

Fri 2 OctMachine LearningComputation and Language
The gist
The paper focuses on teaching AI models to fix their own mistakes when solving math problems by giving detailed feedback on each error. The authors developed a method called AIR-OPD, which helps the model get better by guiding it step-by-step through its errors and retries. This approach uses a teacher model that provides hints based on the current mistake, allowing the student model to try again. They tested it on various math test sets and found it improved the models' problem-solving skills without hurting performance on unrelated tasks.
Open → 2610.02700v1

Context language models improve memory and compute efficiency in AI tasks

Context Language Models

Abstract: We introduce Context Language Models (CLMs), language models that natively manage their own context. We implement this by treating the context as a file and allowing the model to make unrestricted updates to this file. This allows the model to learn what is most important to maintain in context, and naturally extends to multi-agent systems where multiple agent contexts coexist as files. Building CLMs zero-shot with existing models outperforms SOTA context management strategies across a variety of tasks: 11.4% higher accuracy with 21.5% fewer FLOPs on BrowseComp-Plus, 5% higher scores with 59% fewer FLOPs on 12-hour EdgeBench, and 65% greater improvement with the same compute on a 24-hour multi-repository agent-swarm task. Moreover, by shifting context management from external harness control to intrinsic model behavior, CLMs naturally enable both in-context and parametric learning of context-management strategies. We show that CLMs can be steered with natural-language instructions evolved through a standard skill-optimization loop, improving held-out accuracy by up to 35.9 points on a context-management task while reducing compute. We also introduce an online reinforcement learning method for CLMs, improving Qwen3.5-9B performance on BrowseComp-Plus by 47.6% while using 12% fewer FLOPs. Finally, we co-design Suffix Cache Reuse for CLM serving, further reducing server-side compute by 35% relative to standard SGLang at matched performance.

Tue 29 SeptArtificial IntelligenceComputation and LanguageMachine Learning
The gist
Language models usually rely on external programs to keep track of information they need while working. The authors created a new type of model that manages its own memory by treating context like a file it can change freely. This means the model learns what information to keep and update, working better and faster in multi-agent setups too. Their experiments show these models perform better and use less computing power than previous methods, and they can improve over time using natural language instructions and reinforcement learning.
Open → 2609.37725v1

CacheRepair speeds up language model retrieval with smarter cache fusion

CacheRepair: Learning to Repair Cross-Chunk Context in RAG for KV Cache Fusion

Abstract: Multi-document retrieval-augmented generation (RAG) requires a language model to process multiple retrieved text chunks before answering a question. Precomputing each chunk's KV cache independently and concatenating the caches when the chunks are retrieved can accelerate this step. However, the assembled cache lacks cross-chunk attention information, reducing answer quality. Selective recomputation methods recover the missing cross-chunk context by rerunning the target LLM on selected tokens, incurring substantial online computation. We introduce CacheRepair, a lightweight network that learns the difference between independently computed KV caches and those produced by processing the chunks together. The network combines compressed KV features with token embeddings and uses attention that is bidirectional within each chunk and flows from earlier to later chunks. Each repair block receives the compressed cache features, and the predicted residual is added to every document token's cache. Each repair network is trained for a specific frozen target LLM on a generic retrieval corpus and reused across downstream datasets. Our analysis shows that repair reduces KV errors both near chunk boundaries and throughout chunk interiors. Evaluation across three target LLMs and four downstream datasets places CacheRepair on the measured answer-quality-latency Pareto frontier in eleven of twelve model-dataset combinations. Reported time to first token (TTFT) includes online cache transfer and repair. Across all twelve combinations, the largest repairers achieve 1.69-4.61$\times$ speedups in median TTFT over full prefill and improve mean F1 by 2.1-26.1 percentage points over direct cache reuse.

Mon 28 SeptMachine Learning
The gist
When a language model answers questions using multiple documents, it processes pieces of text called chunks. Usually, it stores information from each chunk separately, which makes combining them less accurate and slower. The authors created CacheRepair, a small network that fixes missing links between chunks by learning how caches differ when chunks are processed together. This method makes answering faster without losing quality and works well across many models and datasets.
Open → 2609.35139v1

Agents reuse historical action credit to reduce tool interactions

When Does Action Credit Need Updating?

Abstract: Tool-using agents are continually updated with new interaction data. After each policy update, however, previously estimated action credits may become stale. Recomputing them from scratch can require many additional tool calls and environment interactions, making repeated updates increasingly expensive. We ask a simple question: when does historical action credit actually need to be updated? Our key observation is that a change in action value does not necessarily imply a change in the decision. Historical credit can still be useful as long as policy-induced drift is too small to overturn the existing action ranking. Building on this idea, we introduce pairwise branch sensitivity to capture how strongly a policy update affects the downstream regions that distinguish two candidate actions. We then derive a first-order anchored credit-transport estimator that updates historical credit using old interventional trajectories, and propose a Decision-Sufficient Credit Gate (DSC-Gate) that chooses whether to reuse, transport, or resample credit. Experiments show that branch sensitivity explains credit drift substantially better than global policy distance. With sufficient historical data, credit transport reduces estimation error, while its benefit to decision making is concentrated on updates that affect action-distinguishing branches. On a fully independent test set, DSC-Gate changes mean regret by only +0.00004 relative to a gap-based gate while reducing mean new tool steps from 472 to 286, a 39.4% reduction. We observe the same pattern after a real tool-agent parameter update. Overall, our results show that agents do not need to recompute action credit after every policy update: much of the historical evidence can be reused or cheaply corrected, reducing the additional interaction required to keep action decisions up to date.

Thu 24 SeptArtificial Intelligence
The gist
For agents that use tools, updating decisions after each change can be slow and costly if they recalculate old information every time. The authors found that agents often do not need to redo all their previous assessments because small updates usually do not change which option is best. They created a way to measure when old information stays useful and a method to update it efficiently. Their system cuts down the number of times agents have to redo tool actions by nearly 40% while keeping decision quality nearly the same.
Open → 2609.29007v1