Papers for

chatbot engineers

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.

Llm methods improve entity conflict handling in niche nlu systems

Can LLMs Resolve Entity Conflicts in Domain Specific NLU Pipelines?

Abstract: Resolving entity conflicts is a critical step in Pipeline-based NLU architectures, especially when multiple extractors provide overlapping or conflicting outputs. Traditional rule-based entity conflict resolution methods often lack flexibility and are unscalable. In this work, we aim to study if the broad knowledge of LLMs can be leveraged to resolve entity conflicts in domain specific NLU pipelines. We present an experimental comparison between a traditional rule-based conflict resolution method, and two LLM-based approaches: a multi-shot prompting method using the Llama3.1-8B-Instruct model and a LoRA fine-tuned Llama3.1-8B-Instruct model. The evaluation was conducted under two setups: (1) a broad assessment of LLM's capability to match existing NLU pipeline output, and (2) a more controlled scenario assessing the LLM accuracy on human-labeled data. Results show that while multi-shot prompting offers ease of adaptation and rapid behavioral changes, the fine-tuned model delivers superior performance on complex, ambiguous cases. Ultimately, the best approach appears to be a combination of both strategies, leveraging multi-shot prompting's flexibility alongside the broad accuracy gains of LoRA fine-tuning for a more comprehensive performance.

Thu 19 NovInformation RetrievalMachine Learning
The gist
When computers try to understand language, they often find overlapping or conflicting information about things called entities, like names or dates. The authors studied whether large language models (LLMs) can better solve these conflicts than traditional rule-based methods, especially in specialized language understanding systems. They tested two LLM approaches: one using examples to guide the model and another where the model was fine-tuned for the task. Their results show that using both methods together leads to the best performance, combining flexibility with accuracy.
Open → 2611.25733v1

Agent memory retrieval policies impact accuracy with stale facts

StaleBench: Isolating Stale Retrieval in Agent Memory, and Pricing the Fix

Abstract: An agent that stores facts over time eventually stores several versions of the same fact. Asked a value-agnostic question - "which team does X play for now?" - a similarity retriever cannot prefer the current version, because every version matches the entity the query names. StaleBench isolates this stale-retrieval failure on 892 real updating facts, with currency labels from the source (Wikidata validity years via TempLAMA), never from a retrieval score. Our central result is that retrieval metrics can rank memory policies backwards: a retention policy and its retain-everything control return the identical statement at rank 1 for every test query, yet differ by 29.5 and 65.6 points in reader accuracy on two readers when no date is shown. Contamination@5, the metric we add, ranks them correctly where current@1 and current@5 do not. Withdrawing the lexical anchor that statements carry costs deployed keying mechanisms tens of points of freshness; entity resolution on both the write path and the query recovers most of the loss. Three deployed systems (Mem0, Graphiti, LangMem) and a reimplemented ERASE each handle supersession differently, and no single scoring convention describes all four. We release the data, a frozen evaluator, and reference baselines.

Sun 15 NovComputation and LanguageArtificial IntelligenceInformation Retrieval
The gist
When a computer agent remembers facts over time, it might store multiple versions of the same fact, like which team a player is on now. The authors study how agents often retrieve outdated information mistakenly because old and new facts look similar. They created a benchmark with real data to show that usual ways to measure retrieval can be misleading, and they propose a new metric to better identify fresh facts. Their work also explores how different systems handle updates and how resolving entities helps keep retrieved information current.
Open → 2611.19752v1

Language models show varied knowledge recovery depending on context

Knowledge After Collapse: Context and Wording Shape Factual Accessibility in Language Models

Abstract: When a language model accepts a false correction in a factual discussion, its next answer can depend on how the conversation continues. We introduce Knowledge Answer Divergence (KAD), an event-conditioned evaluation protocol that distinguishes initial false-answer adoption from subsequent persistence, recovery, and abstention. KAD freezes the conversation at the first explicit adoption of a designated false target and branches independent probes from that exact history. This enables matched comparisons of post-adoption behavior and history-management interventions that a single susceptibility score cannot capture. We evaluate eight local checkpoint conditions and six hosted endpoints, alongside an audited 300-question rerun. In corrected Llama 3.2 Instruct 3B controls, a neutral-history branch yields 42/46 correct responses, compared with 16/46 under full history. A matched cue-placement control changes false adoption by 27.3 percentage points in Qwen 3.5 4B. Twelve independently authored pressure templates demonstrate substantial sensitivity to wording. Together, these findings demonstrate the utility of KAD for evaluating factual reliability beyond initial susceptibility, enabling systematic comparisons of false-answer persistence, recovery conditions and conversational interventions.

Fri 13 NovArtificial Intelligence
The gist
Sometimes language models accept incorrect facts during a conversation and then either keep repeating the mistake or eventually correct themselves. The authors study how the way a conversation continues after a wrong answer affects the model's responses. They designed a method called Knowledge Answer Divergence (KAD) to test how models handle false information over time. Their results show that context and wording have a big influence on whether a model sticks to or recovers from a false statement.
Open → 2611.17763v1

Diffusion language models speed token generation with overlapping blocks

Blurring the Block Boundaries: Overlapping Block Denoising for Efficient Diffusion Language Models

Abstract: Diffusion Language Models (DLMs) have emerged as effective alternatives to autoregressive models for latency-critical tasks, enabling faster token generation. Recent advances employ block diffusion with self-editing capabilities, where each block refines tokens iteratively before advancing to the next one. Yet each block is only as fast as its slowest token, and the next block cannot start before it. We suggest Blurring the Block Boundaries (B3), a novel method with which two blocks are refined in parallel within a shared forward pass. B3 calibrates itself on the fly, opening the next block only once the model is ready to start generating it. It is a training-free and hyperparameter-free acceleration method which seamlessly integrates within any self-editing block diffusion model. Evaluated on state-of-the-art DLMs across 10 diverse datasets spanning varied tasks and difficulty levels, B3 results in on par generation quality and 11.5-14.5% speedup compared to the base model, pushing the Pareto frontier for latency-quality trade-offs in DLM inference.

Tue 10 NovComputation and LanguageArtificial Intelligence
The gist
Diffusion language models generate text faster by refining words in chunks called blocks. Usually, each block waits for the slowest word to finish before moving on, which can be slow. The paper presents a way to blur the edges between these blocks by working on two blocks at the same time in one step. This method speeds up text generation by about 12-15% without hurting quality, and it works without any extra training or setup.
Open → 2611.14387v1

Large language models show persistent personality traits that affect tasks

More Than Just Style: Benchmarking Personality Influence in Large Language Models

Abstract: In addition to the effects of explicit input prompts and instructions, large language model outputs are influenced by underlying behavioral preferences similar to human personality tendencies. These tendencies can affect how models interpret situations and make decisions. However, their influence is difficult to disentangle from the effects of model capabilities and instructions. Therefore, we introduce SPACE, a benchmark framework combining a controlled evaluation protocol with complementary datasets for personality verification, capability assessment, and hierarchical situational tasks. Controlled comparisons across guidance conditions help distinguish personality influence from measured capability changes and immediate instruction effects. Experimental results demonstrate that although prompting can shift generation style, models' internal personality tendencies are persistent and not readily overridden by opposing instructions. Furthermore, these underlying tendencies have an observable influence on LLM task performance, highlighting the need for greater attention to these characteristics and potential applications. Training code and SPACE benchmark specifications are available at https://github.com/Niklauseik/SPACE-training.

Mon 9 NovComputation and Language
The gist
Large language models (LLMs) don't just follow instructions and prompts—they also have built-in personality-like traits that influence how they respond and solve problems. The authors created a special test called SPACE to measure these personality influences separately from the models' skills and prompts. Their experiments found that even when directed otherwise, LLMs keep their own personality tendencies, which can change how well they do certain tasks. This shows personality plays a real role in how LLMs work and should be considered more carefully.
Open → 2611.12392v1

Latent scores can replace deep question planning in proactive agents

Depth or Description? When a One-Step Latent Score Replaces Lookahead in Proactive Information Acquisition

Abstract: A proactive agent must decide what to ask before it acts. Exact lookahead values combinations of questions but is expensive and leans on a fitted model; a one-step score is cheap but can miss them. Our main finding: the need for depth often lies in how the hidden cause is described. A one-step score on the label can be blind to an interaction among answers. A score on a suitable latent cause is not, and where that latent encodes the decision it replaces most of depth at a fraction of the search. Described differently, the same problem can defeat the score while exact values do not move, so keep the latent small and check it against exact values. Probabilities learned from one language model's answers do not carry to another unless planning allows for both; those read from tokens are worth only a few labels.

Wed 4 NovMachine LearningArtificial Intelligence
The gist
When a system needs to ask questions before making decisions, it can either explore many possible question combinations (deep planning) which is slow, or use a quick estimate (one-step score) which can miss important details. The authors found that using a compact hidden representation (latent cause) of the problem lets a simple quick estimate capture important interactions between answers, often replacing the need for slow deep planning. However, this only works if that latent space is well chosen and kept small. They also found that probabilities from one language model do not directly transfer to another without accounting for both models during planning.
Open → 2611.07155v1

Speech large language models struggle to use memory accurately in conversations

The Right Source Is Not Enough: Understanding History Interference in Speech-LLM Memory

Abstract: Speech large language models retain audio history to support multi-turn conversations. Yet remembering an event does not ensure that its information is used only when relevant. We investigate why irrelevant historical audio changes answers even when the queried event remains represented. Controlled experiments on MOSS-Audio and MiMo-Audio show that historical values direct errors toward specific competing answers, beyond a generic effect of context length. Causal interventions distinguish two paths. In open-ended question answering, most history-value errors disappear when subsequent computation cannot directly access the irrelevant source. In multiple-choice answering, many errors persist: early historical influence is carried by question-candidate states even after direct source access is blocked. Low-dimensional interventions further separate source-role information from answer-value information. Their effects peak at different depths, and changing the source-role signal does not eliminate the causal influence of competing values. On naturally occurring errors, strengthening the queried role and counteracting the historical value each improve answers; their joint intervention gives the greatest recovery. These findings support a failure of downstream evidence use beyond source identification alone: source-role information can influence a decision without exclusively controlling which historical values affect it. Reliable conversational memory therefore requires not only retention and retrieval, but also control over how retained information enters answer computation.

Tue 3 NovComputation and LanguageArtificial Intelligence
The gist
Speech large language models remember what was said in earlier parts of a conversation to help answer questions. The authors found that even when these models remember an event, they sometimes use unrelated past information and give wrong answers. They showed that errors happen because memory signals affect decisions in more ways than just identifying the source. Fixing these errors requires not only remembering but also controlling how past information influences the answer.
Open → 2611.05124v1

Dory1.0-4B language model adapts compute for better accuracy and efficiency

Dory1.0-4B: A Looped Normalized-GPT

Abstract: We introduce Dory1.0-4B, a 4-billion-parameter looped (latent-recurrent) language model with elastic depth: a single checkpoint serves different inference compute budgets. Dory1.0-4B is built on a normalized Transformer (nGPT) backbone with interleaved sliding-window and full-attention layers, organized into an input block, a shared recurrent block, and an output block. At inference, the recurrent block can be applied a variable number of times. We pre-trained Dory1.0-4B on 6 trillion tokens. The first 4.5 trillion tokens were trained in NVFP4, and additional pre-training then extended the context length to 256K tokens. Next, we post-trained the model using Supervised Fine-Tuning (SFT) and Reinforcement Learning with Verifiable Rewards (RLVR), with a difficulty-aware loop curriculum that routes harder prompts to deeper loops. Increasing the loop count improves accuracy, with the largest gains on coding, agentic, and long-context benchmarks. With two or more loops, Dory1.0-4B outperforms larger models such as Qwen3.5-9B, Gemma 4 12B, and Gemma 4 26B-A4B on average across 12 benchmarks. Looping also makes Dory1.0-4B more token-efficient on agentic benchmarks: with four loops, it generates 1.3-2.5x fewer tokens than with one loop, as the extra computation is spent in latent space rather than on longer outputs. To reduce memory during looping, Dory1.0-4B caches keys and values only from the last loop, keeping its KV-cache footprint equal to that of a non-looped model at any loop count while retaining most of the accuracy gains. We open-source the BF16, MXFP8, NVFP4, and GGUF quantized checkpoints.

Mon 2 NovComputation and Language
The gist
Handling very long texts or complex tasks with language models is challenging because they need lots of computing power. The authors developed Dory1.0-4B, a model that can reuse its internal calculations multiple times during each run, adjusting how much work it does based on the difficulty. This looping improves accuracy especially on coding and long-text tasks, while using less memory and fewer output tokens. The model performs better than several larger models on many tests, making it efficient and flexible for different needs.
Open → 2611.03998v1

Textual memory updates reduce error persistence in long tasks

KEEPER: Learning Control-Sufficient Textual Memory for Long-Horizon LLM Agents

Abstract: Recursive textual memory can carry earlier errors into later updates, yet task performance alone does not establish memory reliability. We define self-consistency bias as the persistence of incorrect claims already present in the incoming memory. We present KEEPER, a comparative analysis of four auxiliary objectives along information-content and update-sensitivity axes within a shared recursive interface, examining how supervision targets relate to agent performance. Among evaluated conditions, reward-related prediction achieve the highest task performance before and after offline reinforcement learning, outperforming joint supervision. A claim-level analysis of one baseline trajectory documents error persistence despite corrective observations. Together, these analyses motivate evaluating error persistence and valid-information retention alongside task outcomes.

Fri 30 OctComputation and LanguageArtificial Intelligence
The gist
Keeping track of information over a long task is tricky because early mistakes can stick around and cause problems later. The authors studied different ways to help a computer remember what it learned in a way that avoids repeating errors. They found that focusing on rewards from past actions helped the system learn better and avoid mistakes compared to other methods. Their work shows that it’s important to check not just how well a task is done but also whether the system is holding on to correct information.
Open → 2610.41482v1

Large language models improve knowledge using state aware recursive updates

Weakness Localization Is Not Enough: State-Aware Recursive Knowledge Improvement for Large Language Models

Abstract: Knowledge improvement in large language models is shifting from predefined knowledge incorporation pipelines toward evaluation-guided updating. Existing methods use evaluation to localize model-specific knowledge weaknesses and guide targeted post-training. However, identifying what to improve does not necessarily provide sufficient information for deciding how to improve it. The same localized weakness can be compatible with distinct operational knowledge states: the relevant knowledge may be unavailable, available but difficult to access reliably, or accessible but ineffective for downstream use. We call this ambiguity knowledge-state aliasing. When compatible states favor different interventions, greater diagnostic resolution alone is insufficient for intervention selection. Moreover, model updates can change the underlying knowledge state before the observed weakness disappears, such that an intervention appropriate in one round may no longer address the bottleneck in the next. To address these challenges, we propose Recursive Knowledge Improvement (RKI), which formulates knowledge improvement as a sequential, state-aware intervention process. RKI organizes knowledge into graph-structured units that provide a shared basis for diagnostic evaluation and targeted intervention across rounds. At each round, RKI localizes knowledge weaknesses, estimates the model's operational knowledge state from diagnostic evidence and intervention history, selects a corresponding intervention, and re-evaluates the updated model before determining the next intervention. On HotpotEval and SafeInternalEval, RKI outperforms existing knowledge incorporation methods by 18.41 points on average. Further analyses show that knowledge states provide additional guidance for intervention selection beyond weakness localization and can change across model updates even when the observed weakness persists.

Tue 27 OctComputation and Language
The gist
Improving large language models isn’t just about finding what they get wrong but also understanding why they get it wrong. The authors explain that the same mistake can happen for different reasons, like missing knowledge or difficulty using it properly. They propose a new method called Recursive Knowledge Improvement that figures out the model's internal knowledge state over multiple steps to better fix problems. This approach led to significantly better performance on challenging tasks compared to older methods.
Open → 2610.36811v1

Language model instruction capacity measured under growing load

Instruction Capacity: Behavior and Degradation of Language Models under Controlled Load

Abstract: The quality with which language models follow instructions falls as the load grows, yet there is still no quantity that expresses the limit of a model in units of load with an uncertainty. We propose an instrument in which the load consists of rules that replace single-token words in a text without meaning: such an instruction is atomic, the rules are independent by the construction of the task, and the outcome of every application of a rule is determined by a computable reference answer. Every occurrence of a word to be replaced becomes a Bernoulli trial with a known position in the answer and a known rule number. The statistical model first measures the shape of the dependence of the probability of a right replacement on the text length, the word position, the replacement density, the number of rules and the rule number, then describes it by smooth laws and restores a reference level that does not depend on the choice of the coding. The model yields the instruction capacity - the number of rules held at a given share of right replacements - with an uncertainty. A measurement of GPT-4o mini (2958 requests, 642,430 trials) gave regular laws for every load factor and for the collapse of the answer; the instruction capacity was about 37-38 rules at a share of right replacements of 0.95, and about 18-19 rules at the full replacement density. The code of the instrument, the measurement data and the passport are open, and every number of the passport is recomputed from the published points. The passport of a model serves as the calibration of a future meter of the instruction load of prompts.

Mon 26 OctMachine Learning
The gist
Language models like GPT-4o get worse at following instructions when given more complex or numerous rules at once. The authors designed a way to measure exactly how much instruction a model can handle by replacing meaningless words with rules and checking accuracy. They tested GPT-4o mini and found it could handle about 37 to 38 rules correctly 95% of the time before performance dropped. This method gives a clear number for a model's instruction capacity and can help compare or calibrate models in the future.
Open → 2610.36095v1

Lightweight filter reduces policy checks in language agents by 30 percent

Signals and Queries: Token-Efficient Agentic Context Discovery

Abstract: User-facing LLM agents must identify which behavioral policies apply at each turn, but evaluating every policy with an LLM is costly. We introduce Signals and Queries (S&Q), a lightweight first-stage relevance filter developed for Parlant 4.0 that removes at least 30% of candidate policies before downstream evaluation while preserving high recall. For each policy, an LLM generates activating examples and hard negatives offline. An independent logistic classifier trained on their embeddings then predicts relevance using embeddings and vector dot products, with no per-turn LLM calls. This shifts expensive relevance evaluation to a smaller candidate set, while allowing each policy's classifier to be updated independently. Evaluated against 9,144 LLM-judge relevance labels covering 254 $τ^2$-bench conversation prefixes and 36 airline policies, S&Q achieves higher precision than top-K and cosine-threshold retrieval at every evaluated recall level, with consistent results across two embedding providers. These findings support inexpensive, per-policy classification as a practical first stage for reducing downstream evaluation workload in customer-facing agents.

Wed 21 OctComputation and Language
The gist
Large language model (LLM) agents decide how to respond by choosing from many possible behavior policies, but testing every policy each time is expensive. The authors created a method called Signals and Queries (S&Q) that quickly filters out unlikely policies before doing expensive checks. S&Q trains simple classifiers using example conversations generated offline, so that during use it avoids calling large models for every policy. This approach cuts the number of policies to evaluate by at least 30% while still keeping almost all relevant ones. It helps customer-facing chatbots run more efficiently without missing important options.
Open → 2610.29326v1

New method reduces unwanted concepts in retrieval-based text generation

C$^2$U in RAG: Compositional Concept Unlearning in Retrieval-Augmented Generation

Abstract: Retrieval-augmented generation can expose unwanted concepts through retrieved evidence even when the generator is moderated. We study query-side concept suppression with a fixed encoder and document index. Compositional Concept Unlearning (C$^2$U) routes a profile-derived direction through an augmented atom bank, adding only a bounded edited-minus-original delta to the raw query. Across five datasets, four encoders, and three seeds, the validation-selected configuration reduces pooled binary target Hit@5 by 4.25 percentage points with non-positive control degradation and target-exposure changes. Under the evaluated query transforms, it suppresses target density without increasing budgeted control-query exposure. Separately, ArXiv four-concept composition improves over an averaged-direction comparator after independent validation gates and first-use test evaluation.

Wed 21 OctComputation and Language
The gist
Sometimes, when AI models generate text using retrieved documents, unwanted ideas or topics can show up even if the AI is carefully controlled. This paper studies how to stop certain concepts from appearing by changing only the search query in a very limited way. The authors introduce a technique called Compositional Concept Unlearning (C2U) that edits queries to reduce exposure to specific unwanted content without harming normal queries. Tests on different datasets and encoders show it effectively lowers the chance of seeing targeted concepts while keeping other results stable.
Open → 2610.29223v1

Model disagreement reveals errors better than extra compute in reasoning

Not All Test-Time Compute Is Evidence: Model-Specific Bias in LLM Reasoning

Abstract: Test-time scaling methods implicitly assume that additional computation from the same model provides independent evidence. We show that this assumption fails within a single reasoning model: errors are correlated across repeated samples, across reasoning depth, and in the model's own self-evaluation, so more compute from the same model is not more evidence. We introduce DIA (Disagreement-triggered Independent Arbitration), which treats disagreement between an intermediate-stage and the final-stage prediction as a per-question signal of reasoning instability and resolves it by asking a small panel of heterogeneous models to solve the question independently, without seeing either candidate, and aggregating their answers directly. Across seven benchmarks and two base models, DIA outperforms full chain-of-thought in 12 of 14 settings, including a 7.00% gain on MuSiQue, while activating on only $\sim 17\%$ of examples and using up to 47.2% fewer tokens than a multi-agent baseline. Ablations show that both independent solving and solver heterogeneity are necessary for these gains.

Fri 16 OctArtificial Intelligence
The gist
More computing time on the same language model doesn’t always mean better reasoning because the model tends to repeat the same mistakes. The authors found that when a model’s early and final answers don’t agree, it signals uncertainty. Their method called DIA uses different models to independently answer these tough questions, improving accuracy while using fewer computing resources. This approach worked well on many tests and used less extra effort than other methods involving multiple agents.
Open → 2610.23213v1

Search augmented llms fail to use evidence behind outdated answers

Retrieved but Not Read: Understanding Why Search-Augmented LLMs Fail to Use Available Evidence

Abstract: Web search allows LLMs to access up-to-date information, but it remains unclear why they sometimes produce outdated answers even when relevant evidence is available. To study this problem, we construct temporal facts whose values changed after the models' training cutoffs. We evaluate one proprietary model under deployed web search and six open-weight model configurations under controlled retrieval. We find that models often answer from search snippets without opening the source pages, which is associated with higher rates of outdated answers and unfaithful citations. Our controlled experiments and layer-wise analysis reveal a gap between the availability of evidence and its effective use. Even when retrieved evidence influences internal predictions, models may still favour outdated information in their final answers. We hope these findings will help advance research on the reliable use of retrieved evidence in search-augmented LLMs.

Thu 15 OctComputation and LanguageArtificial IntelligenceInformation Retrieval
The gist
Sometimes language models that use web search give old or outdated answers even when newer information is available online. The authors studied this by creating facts that changed after the models were trained. They found that models often rely only on search result snippets instead of reading the full source, causing them to ignore up-to-date information. Even when the models see evidence, they may still prefer their old knowledge in their final answers.
Open → 2610.21731v1

Language models improve when to say i dont know on factual questions

Can Language Models Learn When to Abstain? Policy Learning and Calibrated Answer Selection

Abstract: A useful language model should know when to answer and when to say "I don't know." Can we improve that decision by training the model itself or by training a separate component to check its answers? We study both approaches on Qwen3-14B for factual questions, using a score that rewards correct answers, penalizes mistakes, and allows abstention. Across three training seeds and two held-out confidence thresholds, a learned answer selector improves threshold-averaged utility over the original model's calibrated confidence filter. On TriviaQA, mean coverage increases from 20.2% to 30.9%, while the pooled error rate among scored answers decreases from 23.0% to 14.5% under exact-match grading. The tested reinforcement-learning changes do not establish consistent gains. On NQ-Open, the selector improves threshold-averaged utility over the filter but still performs worse than always abstaining. A partial human-reviewed audit preserves the TriviaQA finding. Our results support learning to select answers in this setting while showing that reliable abstention across datasets remains unresolved.

Fri 9 OctComputation and Language
The gist
Knowing when to answer or say "I don't know" is important for language models. The authors tested two approaches: training the model itself or adding a separate answer checker to decide when to abstain. They found that training a separate answer selector helped language models avoid mistakes while answering more questions correctly on one dataset. However, this method was less effective on another dataset and the tested reinforcement learning did not show consistent improvements. Their work suggests answer selection can improve performance, but reliable abstention across different types of questions remains challenging.
Open → 2610.13821v1

On-policy distillation amplifies teacher feedback but risks repetitive outputs

Gains and Collapse in On-Policy Distillation:A Reinforcement Learning Perspective

Abstract: On-policy distillation (OPD) has become an important approach to language model post-training. However, despite its performance gains, OPD can also collapse into excessively long and repetitive generation, and the mechanism underlying these divergent outcomes remains poorly understood. We explain these outcomes through a reinforcement learning perspective: the teacher implicitly rewards student behaviors, even those it rarely exhibits itself. From this perspective, our experiments show that OPD improves performance without expanding the student's capabilities. When the implicit reward model is reliable, OPD makes correct responses easier to sample. In contrast, when the preference misaligns with quality, reward hacking happens: the implicit reward model amplifies overlong, repetitive student rollouts, even though it rarely generates such text itself. Guided by this diagnosis, we find that masking unhealthy responses during training and using SFT initialization can each effectively mitigate the collapse. Together, these findings show that OPD amplifies student behaviors favored by the teacher's implicit feedback, shifting the focus from how well the teacher generates to how reliably it evaluates student rollouts. Our code is available at https://github.com/HancCui/opd_hacking.

Fri 2 OctArtificial IntelligenceComputation and Language
The gist
When teaching a smaller language model by copying a larger one’s behavior, sometimes the smaller model gets better at generating correct answers. But other times, it starts producing long strings of repeated words, even if the teacher model rarely does this. The paper explains this happens because the teacher’s feedback unintentionally encourages such repetitive behavior. The researchers found ways to reduce this problem by ignoring bad responses during training and starting from a well-trained model.
Open → 2610.03185v1

Large language models can forget specific personas without losing skill

LLM Persona Unlearning

Abstract: Pre-training equips large language models (LLMs) with a broad repertoire of behavioral patterns associated with roles, styles, values, and goals. Post-training teaches conditional enactment and makes a helpful Assistant the default, but it does not erase alternative modes from the weights; explicit prompts can therefore elicit personas that repeatedly shape judgment, language, and action. In open-weight settings, runtime controls can be removed, motivating persona unlearning: a weight-level edit that makes a designated persona difficult to elicit and enact on unseen contexts. We introduce PersonaUnlearnBench, a model-specific paired benchmark spanning six LLMs from three families and five personas, with aligned forget/retain sets, held-out instruction paraphrases, and four-axis evaluation. The benchmark shows that standard unlearning methods cannot reliably erase the target persona without sacrificing meaningful generation or general utility. We therefore propose PaCE, which compares target and desirable responses to the same questions to locate an internal behavior direction, then trains target-prompt states away from the target mode and toward the matched desirable response. Experiments show that PaCE consistently suppresses target personas with high response quality and useful counterpart behavior, at moderate utility cost. These results establish persona unlearning as a distinct behavior-level editing problem and a practical route toward persistent control of latent LLM response policies.

Wed 30 SeptComputation and LanguageMachine Learning
The gist
Large language models learn many ways to act, like different personalities, but they can still show unwanted behaviors even after training. The authors spot a problem: current methods can't reliably erase these unwanted personas without harming the model's usefulness. They created a new way called PaCE that helps the model 'forget' specific personas while keeping good responses to other questions. This approach shows promise to keep AI assistants behaving consistently and avoids unwanted personality traits.
Open → 2609.39882v1

Mnemon divides memory into fast judgments and slow searches for better answers

Mnemon: Raw Records, Fast Judgments, Slow Thoughts

Abstract: Long-term memory lets an LLM assistant use a history it can no longer reread, and most memory systems build it by rewriting conversations into facts, graphs or typed memories at write time. We argue that the work of memory divides, as thinking does, into two systems. Most of it is fast System 1 work: many small, independent yes/no judgments about records, such as whether a record is needed or no longer current, which a decision model makes by the dozen in a third of a second. Only a little is slow System 2 work: writing a few search queries, naming what the reply needs and composing the answer, which an LLM does well but slowly. We present Mnemon, a memory agent built on this division. It keeps conversations as raw, dated records; an LLM (System 2) plans searches over them, a decision model, Jev (System 1), judges what the searches return, and rules with explicit budgets turn the judgments into a small View for an unchanged answering model. A background pass consolidates each record once into topic timelines, value histories and standing instructions linked to the records, so that questions about a whole conversation reach evidence their own searches miss. Because nothing is decided about a record when it is written, the same agent can read any store that returns dated records. With gpt-4.1-mini answering, as in a public re-evaluation of 14 systems, Mnemon scores 91.7% on LoCoMo, the highest among them, and 83.8% on LongMemEval-S, from under 4k tokens of context per question, with the lowest effective cost index on LoCoMo. With a reasoning model answering, it reaches 92.2% on LoCoMo and 94.4% on LongMemEval-S, the latter on par with the best published results. From 100K to 10M tokens of history on BEAM, its cost per question grows by a factor of 1.11. On the same records, Jev separates gold evidence better than two LLMs and is 3-11 times faster.

Mon 28 SeptComputation and LanguageArtificial IntelligenceInformation Retrieval
The gist
Large language models need ways to remember lots of conversation history efficiently. The authors show that memory can work like two brain systems: a fast one that quickly judges whether information is useful, and a slower one that carefully searches and writes answers. They built Mnemon, a system that keeps raw conversation records and uses these two steps to answer well without slowing down. Tests show Mnemon gives very accurate answers using much less context and cost than other systems.
Open → 2609.36059v1

Method improves editing of language model facts without side effects

ALOE: Semantically Addressed Low-Rank Operators for Knowledge Editing

Abstract: Knowledge editing changes what a model knows by modifying parameters so that a requested fact updates while unrelated behavior is preserved. This is usually treated as a write problem, but editing also involves an address problem: deciding which hidden states should receive the new residual. An update that activates too narrowly memorizes one prompt, while one that activates too broadly disrupts neighboring knowledge. Parametric editors encode this scope implicitly, whereas memory-based editors make the selection explicit but keep it outside the edited model. We propose ALOE (Addressed Low-rank Operator for Editing), which learns semantic addresses from paraphrases and hard same-subject negatives, aligns them with autoregressive hidden states through rollout refinement and gate calibration, and embeds the resulting gated low-rank operator within one MLP layer, so that the deployed model runs in a single forward pass with no external retriever or auxiliary router. Evaluated on CounterFact, ZSRE, and KnowEdit across three 7--8B model families, ALOE achieves efficacy between 0.955 and 0.999 and locality between 0.981 and 1.000; mechanistic analyses confirm that the learned geometry separates competing edits and that calibration suppresses out-of-scope activation. The remaining errors concentrate in paraphrase coverage and write fitting.

Thu 24 SeptArtificial Intelligence
The gist
Changing what a language model knows without messing up other things it has learned is tricky. The paper presents a new method called ALOE that helps decide exactly where to apply updates inside the model, so only the intended fact changes. ALOE learns to recognize similar facts and controls the update to avoid unwanted effects, keeping the model's other knowledge stable. Tests show it works well on various benchmarks and models.
Open → 2609.29269v1

LLM text generation improved with memory guided sampling for speed and accuracy

FLEET: From Logits Entropy to Enhanced Trajectories in Text Generation

Abstract: Solutions based on large language models (LLMs) often rely on temperature sampling to improve accuracy and stability by aggregating multiple samples from the completion distribution. However, this memoryless approach is inherently suboptimal: because it lacks awareness of prior generations and their evaluations, it produces an increasing proportion of semantically duplicate answers as more samples are drawn, leading to diminishing returns. To address this limitation, we introduce FLEET, a novel method that integrates a memory mechanism into the generation process. FLEET represents each generation as a sparse trajectory through states whose entropy exceeds a predefined threshold and uses these trajectories to infer per-token utility scores that adjust the logits. Benchmark evaluations demonstrate that FLEET achieves the same accuracy as the repeated sampling baseline, with a 3x speedup, and substantially improves accuracy on complex coding tasks (LiveCodeBench Pass@32 increases from 59.9% to 66.2%) under the same budget. Furthermore, in the greedy-decoding configuration evaluated here, the approach is deterministic and uses a single calibration pass to derive its principal hyperparameters, requiring only minimal modifications to existing LLM pipelines.

Wed 23 SeptMachine LearningArtificial IntelligenceComputation and Language
The gist
Language models often produce many repeated or similar answers if you ask them to generate multiple samples, which wastes time and computing power. The authors created FLEET, a method that remembers what was generated before and focuses on exploring new ideas by tracking the uncertainty of each word choice in a smart way. This approach helps the model avoid duplicates and generate better, more accurate outputs faster. It works well on tough coding problems and can be used with minimal changes to current systems.
Open → 2609.27657v1

Confidence scores fail in reasoning tasks for document retrieval

The Magnitude Mirage: Rethinking Confidence for Reasoning-Intensive Retrieval

Abstract: Many production RAG systems implement retrieval abstention by thresholding raw similarity scores, implicitly treating score magnitude as a confidence signal. We demonstrate that this practice degrades systematically as queries require reasoning beyond semantic matching. Across 11 retrieval architectures and 28 datasets, neural retrievers consistently assign high similarity scores to semantically related but constraint-violating documents, causing magnitude-based thresholds to collapse toward near-random abstention performance on logical and temporal reasoning tasks---a failure we term the Magnitude Mirage. To address this without computationally expensive alternatives, we conduct a large-scale empirical study of six zero-cost Query Performance Prediction (QPP) metrics across three cognitive tiers: semantic matching (BEIR), logical reasoning (BRIGHT), and temporal reasoning (TEMPO). Our central finding is that the key improvement comes from abandoning magnitude in favor of score-distribution signals: the gain from this shift exceeds the differences among distributional alternatives by a factor of 5-10$\times$. In particular, Score Gap ($s_1 - s_k$) and a practical adaptation of Score Magnitude and Variance (LSMV) improve abstention AUROC by up to 0.16 in settings where magnitude-based confidence provides little discriminative power. These methods require no additional inference, retraining, or latency, making them a practical zero-cost replacement for magnitude thresholding in deployed RAG systems.

Mon 14 SeptInformation Retrieval
The gist
Sometimes computer systems try to find documents by seeing how similar they are to a question, assuming higher similarity means more confidence in the answer. This approach breaks down for questions that need reasoning, like logic or time-based problems, because the system gives high scores to related but incorrect answers. The authors show this problem happens in many systems and datasets, calling it the Magnitude Mirage. They find better ways to guess confidence by looking at differences between scores, which doesn’t require extra computing and improves decision-making in these tough tasks.
Open → 2609.15578v1

Scene aware memory design improves personalized AI agent recall

CreaMem: A Scene-Aware Memory Architecture for Personalized Agents

Abstract: Long-term memory is a core capability for personalized LLM agents. To support it, existing memory systems organize information using various criteria such as topic segments or summary hierarchies. However, we identify two major limitations in these designs. First, they lack scene awareness: memories from unrelated life scenes share the same retrieval space, which inflates the search space and introduces cross-scene interference. Second, they encode each memory from a single perspective, making it difficult to retrieve complementary views of the same event. In this paper, we propose the CreaMem architecture, which enables scene-aware memory organization by partitioning memory into several Life Scene Memories to reduce cross-scene interference at retrieval. To go beyond the single perspective and achieve cross-memory synergy, entries are dual-coded from both episodic and trait-based perspectives within each memory. We further devise a permemory balanced sampling strategy at retrieval time. Extensive experiments on two long-term memory benchmarks show that CreaMem improves QA accuracy across all evaluation metrics, with particularly large gains on multi-hop reasoning performance, validating scene-aware partitioning and cross-memory synergy. To enhance reproducibility, we release our code in a public GitHub repository.

Tue 8 SeptComputation and Language
The gist
Personalized AI assistants need to remember what they learn over time, but current memory systems mix up memories from different situations and only remember one perspective at a time. The authors created a memory design called CreaMem that sorts memories by different life scenes and remembers both what happened and personality traits about them. This helps the AI recall information more accurately, especially when it needs to connect multiple facts. Their tests showed CreaMem makes AI agents better at answering complicated questions.
Open → 2609.08550v1