Papers for

chatbot 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.

LLMs recall facts in huge texts using less memory

Residual Vector-based Reconstruction as Long-Context Recall Regardless of Context Window Size

Abstract: Large language models (LLMs) process long contexts, including long documents and lengthy conversations, but face token-level memory usage that increases proportionally to input length. Although model optimization and lossy prompt compression are widely used, these methods still fail to solve the long-context recall problem beyond pretrained and size-constrained context windows. This paper proposes a long-context recall method that maintains near-constant GPU memory usage as context length increases, without additional training. The main idea is to reconstruct facts using parameter activations in the LLM's feed-forward layers, which store residual vectors representing facts from the source document. Utilizing residual vectors allows the LLM to deterministically reconstruct query relevant facts without referencing the original document, preserving high fidelity and reducing memory usage without fine-tuning weights. Experimental results show that the proposed method enables answering single-fact questions in two-million-token story contexts where previous methods fail.

Fri 11 SeptArtificial IntelligenceComputation and Language
The gist
Large language models struggle to remember information in very long texts because they use more memory as the text grows. The authors present a way for these models to recall specific facts from massive documents without needing extra memory or retraining. They do this by using hidden signals inside the model’s own layers, which keep track of facts in a compact form. As a result, the model can answer questions about documents millions of words long when previous methods could not.
Open 2609.12686v1

Memory system improves long-term knowledge retention in AI agents

LifeFuse-Mem: Lifecycle-Aware State Fusion Against Temporary Overwriting for Long-Term Memory

Abstract: Long-running LLM agents require memory mechanisms that maintain coherent internal states across interactions. We study a lifecycle-labeled memory setting in which write episodes provide lifecycle metadata during training, and phase-aware readout is used during evaluation. This setting reflects the need to distinguish information that should remain influential across future interactions from information that should affect only the current context. A mismatch between these lifecycles can cause temporary information to overwrite durable knowledge, leading to behavioral drift in persistent agents. Within this setting, we introduce \textbf{LifeFuse-Mem}, a lifecycle-aware neural memory framework that separates information according to its temporal commitment. LifeFuse-Mem uses dedicated memory components and lifecycle-aware updates to allow stable and transient knowledge to evolve locally without converting temporary context into durable state. On the controlled anti-overwrite benchmark, LifeFuse-Mem improves acquisition-controlled retention and reduces temporary overwrite; on two public long-memory benchmarks, it remains broadly competitive. These results suggest that explicit lifecycle signals can help diagnose and mitigate overwrite in compact online memory.

Fri 11 SeptArtificial Intelligence
The gist
Some AI programs need to remember information over a long time, but sometimes temporary facts can accidentally erase important lasting knowledge. The authors studied a way to label memories with their expected lifespan during training and then read from them carefully during use. They created a system called LifeFuse-Mem that keeps temporary and permanent memories separate, so temporary info doesn’t overwrite important facts. Their tests show this method helps AI agents keep useful memories longer without confusion.
Open 2609.12436v1

Language models improve tracking of changing user preferences

Toward Robust Personalized Alignment for LLMs: Mitigating Persona Drift in Multi-Turn Dialogue

Abstract: Persona drift remains a central challenge for personalized language models, as user profiles evolve over long interactions rather than remain permanently fixed. Models must therefore revise persistent persona states when preferences genuinely change, while avoiding updates driven by transient, ambiguous, or unresolved observations. We propose CORE, which separates turn-local evidence from persistent persona-state revision and selectively updates grounded user preferences through uncertainty-aware belief revision. We also introduce PERSIST, a held-out post-anchor benchmark for persona-state robustness under sequential interaction stress, covering ambiguity, conflict, and controlled social influence. Across ALOE, PersonaChat, and PERSIST, CORE improves personalized alignment and robustness, with complementary gains in normalized closed-slot state fidelity. Human evaluation and mechanistic controls further support explicit update control beyond stronger generation or persistent memory alone.

Fri 11 SeptArtificial Intelligence
The gist
When people chat a lot with AI language models, their preferences and personality details can change over time. The authors found that typical AI models struggle to keep track of these changes accurately, sometimes getting confused by short-term or unclear information. They created a method called CORE that helps the AI decide when to update what it knows about a person’s preferences and when to hold back. They also introduced a new test called PERSIST to check how well AI keeps a consistent sense of a user's persona across many conversations. Their method improved how well AI stays true to users' personalities over time.
Open 2609.12373v1

CueMem improves long-term chat memory by reconstructing dialogue context

CueMem: Cue-Guided Context Reconstruction for Long-Term Conversational Memory

Abstract: Long-term conversational agents must answer user queries by recalling information from extended dialogue histories, yet directly using the full history is costly and often unreliable, while compressed memory units may lose fine-grained evidence needed for question answering. Motivated by the reconstructive view of autobiographical memory, we propose CueMem, a cue-guided framework that treats extracted memory records as retrieval cues rather than self-contained evidence and reconstructs query-relevant dialogue context from their source turns. During memory construction, CueMem extracts fine-grained memory cues from dialogue turns and links each cue to its source turn. At query time, it retrieves query-relevant cues, maps them to source-turn anchors, and expands from these anchors over a turn graph that captures temporal proximity and semantic relatedness, reconstructing a compact evidence context from the original dialogue for LLM answer generation. Experiments on LoCoMo and LongMemEval show that CueMem consistently outperforms representative long-term memory baselines. Further analyses show that graph-based context reconstruction helps recover supporting dialogue evidence while reducing query-time input tokens and latency compared with the full-history LLM setting. These results highlight retrieval cues as an effective alternative to self-contained memory evidence for long-term conversational question answering.

Fri 11 SeptComputation and Language
The gist
When chatbots try to remember long conversations, keeping all the chat history can be slow and confusing. The authors created CueMem, a system that stores small memory clues linked to the original chat parts. When asked a question, CueMem finds these clues and rebuilds just the important parts of the conversation to answer better. This method is faster and more accurate than using the entire chat history or compressed summaries.
Open 2609.12354v1

Agentic memory system shares private and public data across users

AIM: A Privacy-Aware Interoperable Memory Framework for Multi-Agent Multi-User LLM Systems

Abstract: Traditional large language models (LLMs) are scoped to individual user sessions, limiting their knowledge to a single conversation and preventing them from learning user preferences that evolve over time. Existing agentic memory systems address this limitation but generally operate at the individual-user level, restricting the public knowledge that could be shared across users to improve downstream responses. We introduce AIM (Agentic Interoperable Memory), a unified, privacy-aware memory framework that enables multi-agent, multi-user LLM systems to persistently manage private and shared memory. AIM dynamically classifies information as private, scoped to one user and inaccessible to others, or public, accessible to all users. It enforces index-level access controls so that private memories are retrievable only by their owner, protecting sensitive data while allowing beneficial shared knowledge to improve coordination and consistency. We also introduce MUMBench (Multi-User Memory Benchmark), a dataset of multi-user interactions containing private and shareable information across four domains. To our knowledge, MUMBench is the first public dataset designed to evaluate multiple memory operations, including retrieval, creation, update, and deletion, in a multi-user environment. Across three independent runs on MUMBench, AIM achieves 96.0% visibility classification accuracy, 58.8% strict operation accuracy, and 70.5% state-aware operation accuracy.

Fri 11 SeptArtificial IntelligenceMachine Learning
The gist
Large language models usually forget what you talked about once the chat ends and don’t remember your likes over time. The authors developed AIM, a system that helps many users and AI agents share memory safely by separating private info only a user can see from public info everyone can use. AIM makes sure private memories are kept secret while useful shared memories help AI agents work better. They also created MUMBench, a test set to check how well these systems remember, update, and remove info when many people interact.
Open 2609.12320v1

LLM judges miss task success in simulated user evaluations

GAUGE: When Not to Trust LLM-as-a-Judge in User-Simulated Evaluation of Task-Oriented Agents

Abstract: Comparing and selecting task-oriented LLM agents increasingly relies on a low-cost offline evaluation gate: persona-driven LLM user-simulators converse with each candidate, an LLM-as-a-judge scores the transcripts, and the higher-scoring agent is promoted. We introduce GAUGE, a reusable offline protocol that measures whether this gate's ranking matches a grounded verifiable reward across 25 agents from six providers on the $τ^2$-bench and SimulatorArena benchmarks, separating two kinds of evaluation validity that release practices conflate: ranking validity and construct validity. First, a satisfaction-success gap: satisfaction carries essentially no information about task success, as conversations rated satisfied by our blind panel are decorrelated from actual success, with 57.5% of them failing the customer's task, a pattern consistent across five rater populations, both benchmarks, and every subjective dimension we rated. Second, while the gate's ranking is robust across the broad capability span, it loses resolution among the near-equal strong agents: this decision-disagreement rate jumps from $<$1% on wide-reward pairs to 31% on close pairs. The gate is thus human-validated yet mis-anchored. As a remedy, we propose a calibrate-then-trust cadence in which a judge-free completion bit is a zero-cost tripwire for truncation regressions.

Thu 10 SeptComputation and LanguageMachine Learning
The gist
It can be hard to tell which computer assistants do the best job. The authors found that when AI judges rate conversations they have with simulated users, their ratings often don’t match whether the assistant actually completed the task. Even conversations that looked satisfying to human reviewers often failed the tasks. The paper shows this mismatch and suggests a way to check for errors before fully trusting the AI judge’s scores.
Open 2609.12191v1

Assistants personalize user voice by modeling stable personality layers

Creating an Atomic User Model for Personality-Aware Large Language Model Interaction

Abstract: Assistants built on large language models are expected to write as their user would, and the dominant approach is single-channel: preferences summarised from conversation history and reinserted into context. This inverts the order of inference. Preferences are the task-dependent surface of a comparatively stable personality structure, so a system storing only preferences relearns the person whenever the task changes. First, we characterise personality seepage, where a prompt's linguistic surface carries a personality fingerprint the assistant mirrors without access to the personality behind it. Second, we propose the Atomic User Model (AUM), a human-readable representation organising a person as a stable identity nucleus with four interpretable shells (psychological, cognitive and experiential, behavioural, and social), plus cross-shell entries recording internal conflict and authenticity. Third, we treat AUM as a retrieval index over a person rather than a prompt prefix, with a pipeline where a task classifier, component-selection function and budgeted retriever return a small payload of fields at generation time. Fourth, we evaluate it with sixteen language-model-simulated participants, six style-sensitive tasks and three seeds, plus a synthetic scaling study of the retriever. Retrieving eight fields matched the style fidelity of the full user model on 23% of the context (211 tokens against 915), improved on flat preference notes by 0.24 points on a five-point scale (p < 0.001, dz = 0.50), and raised forced-choice identification of the participant's own voice from 14.9% to 42.7% (25% chance). Four pre-registered controls returned null, locating the effect in the representation rather than the search over it. The benefit is largest for participants the un-personalised assistant reproduces worst (rho = -0.61, p = 0.013): personalisation is worth most to those the default serves least.

Thu 10 SeptHuman-Computer InteractionArtificial IntelligenceComputation and Language
The gist
People use digital assistants that try to sound like them, but current methods focus only on recent preferences, missing the deeper personality behind those choices. The authors show that personality traits can leak into writing style, and they create a new model called Atomic User Model (AUM) that breaks down a person’s identity into stable, understandable parts like psychology and behavior. Instead of just adding preferences as a prompt, their system retrieves small, relevant pieces from this layered model to guide the assistant’s responses. Tests with simulated users found this made the assistant’s style much closer to the user’s real voice, especially helping those whose style the basic assistant couldn’t match well.
Open 2609.12086v1

Diffusion vision-language models improve answers by adapting reasoning length

Routing by Reasoning Need: Trajectory-Aware Decoding Control for Diffusion Vision-Language Models

Abstract: Diffusion vision-language models generate answers through iterative refinement, exposing intermediate answer trajectories that can be inspected and controlled at inference time. However, this controllability creates a reasoning-need mismatch, where a universal generation length is applied to questions with different reasoning demands. Visually closed questions may be harmed by continued refinement after a stable answer has formed, whereas reasoning-sensitive questions may be harmed by premature commitment. We formulate this problem as reasoning-budget mismatch and study it in LLaDA-V. Rather than choosing a universal generation length, our training-free controller routes each example to early commitment, baseline preservation, or reasoning-supportive decoding using trajectory signals from answer closure, commitment evidence, and representation revision pressure, without using ground-truth answers. Across answer-focused, mixed-reasoning, and CoT-sensitive benchmarks, routed control improves robustness over fixed long decoding, pure short decoding, and single-rule interventions. The gains are not explained by shorter outputs alone. Answer-closed examples often benefit from commitment, whereas CoT-sensitive examples require preserving or supporting intermediate reasoning. Taken together, these results suggest diffusion VLM decoding should route inference-time control by the state suggested by the observed trajectory instead of relying on a universal decoding length.

Thu 10 SeptArtificial Intelligence
The gist
Some AI models answer questions by slowly refining their guesses step by step. But using the same number of steps for all questions can cause problems: simple questions may get overthought, while complex questions may be cut short. The authors studied this problem with a model called LLaDA-V and created a way to watch how the answer changes during thinking. Their system decides when to stop early, keep going normally, or focus on detailed reasoning, based only on signals seen without knowing the true answer. Tests showed this approach gave better, more reliable answers across different types of questions.
Open 2609.11315v1

KuaiRP role-playing models balance knowledge and general ability efficiently

KuaiRP Series Role-playing Models Technical Report

Abstract: This paper introduces the complete technical solution for the KuaiRP series of role-playing models. We aim to achieve four core objectives for a dedicated role-playing model: simplified prompt engineering, highly stable output quality, built-in domain world knowledge, and high-efficiency deployment with a small parameter size. However, effectively injecting deep domain knowledge often leads to a severe catastrophic forgetting of the model's general agent capabilities. To overcome this trade-off, we propose a multi-stage training pipeline. First, we design a standardized character template and construct an SFT data pipeline based on user behavior simulation and reverse profile filtering. Next, we utilize a rule-based composite reward function during the Reinforcement Learning (RL) phase to eliminate common degradation phenomena like length expansion and repetitive generation. Finally, to recover the general capabilities compromised during SFT and RL, we propose a novel self-distillation paradigm using Two-stage On-Policy Distillation (OPD) equipped with Cumulative-Divergence Decay (CDD). By using the domain-adapted model as the teacher and the original base model as the student, we effectively balance deep domain knowledge injection with the preservation of general agent capabilities. Experimental results demonstrate that the KuaiRP models not only match the current state-of-the-art proprietary models in role-playing fidelity within our target domains, but also successfully recover general agent capabilities, maintaining extremely low deployment costs.

Thu 10 SeptArtificial IntelligenceComputation and Language
The gist
Role-playing AI models often struggle to combine deep knowledge about specific characters with general abilities to respond well overall. The authors designed a new training process that first teaches the model using detailed character templates and rules, then uses reinforcement learning and a special technique called self-distillation to keep the model’s broad skills intact. This approach helps create smaller, stable models that act closely like real role-players while still giving good general responses. Their experiments show the models perform well without needing big computing resources.
Open 2609.11127v1

Language agents manage memory by separating stored facts from used evidence

What Should an Agent Forget? Separating What Is Stored from What Is Used

Abstract: Persistent language agents need stored experience to remain available across time, while each answer requires evidence suited to a particular question. A superseded fact can mislead a current-state answer and still be essential for a historical query. We present RD-Forget, a training-free framework that separates what an agent stores from what it uses. A retained source archive preserves observations, and a query-conditioned memory view controls their influence on the current answer. A frozen language-model curator extracts relevant evidence, groups facts into semantic slots, and preserves the relations needed for multi-hop reasoning. Same-slot replacement links suppress superseded values in current-state contexts, while intent-aware retrieval makes earlier evidence eligible again. A rate-distortion formulation guides construction of the answer-time view within a memory budget. Experiments span conversational memory, knowledge updating, fact consolidation, long-context reasoning, and personalization under a shared answering pipeline. The results associate accurate answers with both query-relevant evidence construction and control over obsolete alternatives. Configurations without forgetting or query conditioning have the largest score deficits, while slot grouping, historical access, and relation preservation contribute complementary functions. Retaining history while selectively controlling its use offers a practical way to accommodate changing facts and future questions.

Wed 9 SeptArtificial Intelligence
The gist
Sometimes, an AI assistant needs to remember facts over time, but not all facts should be used in every answer. For example, old facts might be wrong now but still important for history questions. The researchers created a system called RD-Forget that keeps all facts stored but only uses the relevant and current ones when answering. This system groups related facts and knows when to ignore outdated information depending on the question. This helps AI give more accurate and flexible answers.
Open 2609.10263v1

Personalized assistants struggle to give good advice in long chats

PRAGMA: Evaluating Personalized Guidance with Memory Alignment in Lifelong Conversations

Abstract: Large language models (LLMs) are increasingly deployed as personalized assistants that interact with users over extended periods of time. As conversations grow longer, relying on full interaction histories becomes increasingly inefficient and unreliable: long contexts introduce substantial computational overhead, making it difficult for models to consistently identify and utilize the most relevant information for the current request. These challenges have motivated memory systems that structure and retrieve user-specific information. In realistic interactions, users often seek practical guidance such as recommendations, planning, and decision support. Unlike factual recall tasks, personalized guidance requires models to integrate information across multiple past conversations and reason about changing user preferences and experiences. However, existing conversational memory evaluations mainly focus on retrieval and factual recall. To study this challenge, we introduce PRAGMA, a benchmark for evaluating personalized guidance in long-term conversations. PRGAMA contains curated longitudinal conversation histories, evidence annotations, and guidance scenarios grounded in evolving user contexts and incorrect user assumptions. Experiments across retrieval systems, memory systems, and long-context models reveal that current systems struggle both to recover the appropriate conversational evidence and to effectively use it for personalized guidance. Our results highlight the need for memory architectures that support robust conversational retrieval and memory-grounded reasoning beyond evidence recall.

Wed 9 SeptArtificial Intelligence
The gist
When people use AI assistants over a long time, these assistants find it hard to remember and use the right parts of their past talks. The authors built a test called PRAGMA to see how well different systems can guide users by using their conversation history. They found existing systems often fail to pick the best memory bits and use them correctly for personalized advice. This shows we need better ways for AI to remember and reason over long interactions.
Open 2609.09664v1

Personalized language models learn minimal user profiles to save computing costs

Less Is Personal: Learning Minimal Sufficient User Profiles for Personalized Language Models

Abstract: Retrieval-augmented personalization enables large language models to produce more accurate and preference-aligned outputs using relevant records retrieved from user histories. Personalized language models typically prepend a fixed number of retrieved user records, even when additional history is redundant, harmful, or unrelated to a user's distinctive behavior. We study minimal sufficient personalization: constructing the least costly ordered profile for each input while preserving the utility achievable from a retrieved candidate pool. We introduce ENOUGH, a method that iteratively appends behavioral records or emits STOP to construct profiles with adaptive lengths. Offline, bounded counterfactual search evaluates profile prefixes by jointly considering downstream gains, user specificity, and token costs. The resulting long-horizon targets are distilled into a multi-head value controller with explicit ranking and stopping supervision. At inference, the controller selects and orders records through lightweight decisions, and the frozen generator is invoked once after stopping. Extensive experiments on six personalized tasks demonstrate that ENOUGH consistently outperforms strong heuristic and retrieval-augmented baselines in both effectiveness and efficiency, achieving minimal sufficient profiles that preserve personalization utility while reducing unnecessary context costs.

Tue 8 SeptArtificial Intelligence
The gist
Language models can give better, more personalized answers by looking at a user’s past behavior, but not all past data helps. The researchers found a way to pick just enough relevant user history each time, instead of loading a fixed amount that might be too much or too little. Their method, called ENOUGH, learns when to stop adding more user records based on how useful it is for predicting the best answer. This approach makes personalized models faster and cheaper while still being accurate.
Open 2609.08180v1

Kv cache eviction improves long context inference in large language models

Jacap: Robust KV Cache Eviction via Jacobian-Based Nonlinear Information Capacity Preservation

Abstract: Key-value (KV) cache eviction is essential for scaling long-context inference in Large Language Models. However, existing policies predominantly rely on empirical heuristics, lacking a rigorous characterization of token utility under the inherently nonlinear softmax attention mechanism. In this work, we rethink KV cache eviction through the lens of local information geometry, modeling the attention process as a nonlinear Gaussian communication channel. By performing a first-order Taylor expansion of the attention mapping, we derive the Jacobian Information Capacity, a novel objective that explicitly captures query relevance, softmax sensitivity, and structural diversity. Guided by this theory, we introduce Jacap, a capacity-aware eviction method that utilizes softmax-aware importance weighting and statistical leverage scores for subset selection. Extensive experiments across diverse architectures and benchmarks demonstrate that \textsc{Jacap} delivers superior performance in most scenarios, particularly in high-compression regimes.

Tue 8 SeptComputation and Language
The gist
Large language models use key-value caches to remember what they have seen so far, but these caches have limited space and need to decide what to keep or remove. Existing methods use simple rules that don’t fully consider how attention works in these models. The authors thought about this problem using ideas from information theory and geometry to better understand which cached tokens are most useful. They created a new method called Jacap that smartly chooses which tokens to keep, leading to better performance, especially when the cache is very limited.
Open 2609.08131v1

Multimodal agents learn to verify and improve search using reinforcement learning

Eliciting Self-Verification in Multimodal Reasoning Agents with Reinforcement Learning

Abstract: Reasoning agents increasingly rely on external tools such as web search to answer complex queries. Reinforcement learning (RL) finetuning algorithms such as GRPO have improved long-form reasoning in text-only language models, particularly for coding and mathematics. Reliable tool use in multimodal agents, however, remains challenging because models must interpret text and images while integrating noisy retrieved evidence, often under sparse outcome-level supervision without explicit verification signals. We present Self-Verification via Reinforcement Learning (SVRL), an RL-only finetuning framework that trains multimodal agents to verify and filter retrieved evidence within their own reasoning traces, reducing reliance on external verifiers at inference time. SVRL also introduces a search-aware penalty that discourages unnecessary tool calls and a query-diversity reward that encourages diverse, well-formed search queries, providing fine-grained feedback on when and what to search. Finetuning Qwen-2.5-VL-7B with SVRL on only 5{,}000 visual question answering examples yields consistent gains in multi-hop VQA generalization and tool efficiency across benchmarks. Overall, SVRL narrows the gap between compact agents and much larger proprietary models while requiring substantially lower training and inference cost.

Mon 7 SeptArtificial IntelligenceComputation and LanguageComputer Vision and Pattern Recognition
The gist
Multimodal reasoning agents that use tools like web search struggle to use noisy information from images and text correctly. The authors developed a method called SVRL that helps these agents teach themselves to check and filter the information they find during their reasoning process. This learning method also encourages the agents to only make useful searches and to ask better questions to improve their answers. Testing on a visual question answering task showed that SVRL helps the agents become more accurate and efficient, closing the gap with much larger systems while using less computing power.
Open 2609.08025v1

Language models show consistent beliefs that predict responses

Beliefs and Behavior in Language Models

Abstract: There is significant uncertainty about whether abstractions like beliefs or desires usefully describe the behavior of large language models (LLMs). In addition to the inherent scientific interest of this question, these latent quantities are often invoked to explain the behavior of LLMs to users or to define and evaluate harmful behaviors which are relative to intent. Nevertheless, we currently lack a means to systematically test whether concepts like "belief" are well-applied to LLMs, and hence whether they are likely to be fruitful ingredients of attempts to align models with human interests. We propose an approach for empirically studying such questions, asking whether a single latent variable inferred from the LLMs' outputs -- interpreted as a degree of belief -- allows an observer to make interpretable predictions of how the LLMs' will respond to new prompts. We find that highly capable models are usefully described as holding beliefs and that, generally, the predictability of model outputs based on an inferred latent belief tracks overall trends in model capability. Building on these findings, we provide empirical strategies to study how beliefs in LLMs can be measured, the extent to which LLMs comply with instructed decision rules or payoffs, and how beliefs evolve within individual instances of an LLM over the course of reasoning.

Mon 7 SeptArtificial IntelligenceMachine Learning
The gist
It is unclear whether big AI language models really have something like beliefs or desires inside them, which people often mention to explain their behavior. The authors study whether we can treat certain hidden variables, drawn from the models' answers, as a kind of belief that helps predict what the models will say next. They found that more capable models behave in ways consistent with holding such beliefs, making it easier to predict their answers. They also explore how these beliefs change when the model processes reasoning tasks and how well models follow instructions based on these beliefs.
Open 2609.07943v1

Language models struggle to show strong emotions they are asked to express

You Can't Prefer Emotions You Don't Sample: Intensity Undershoot in DPO-Tuned LLMs

Abstract: Ask a language model to respond "very excitedly," and its output is typically only mildly more energetic. We quantify this effect. We condition an instruction-tuned LLM on a continuous Valence-Arousal (VA) target, where valence measures how pleasant a state is and arousal how activated it is, measure the achieved affect with a frozen regressor, and sweep the requested target from -1 to +1. The response moves far less than asked: the gain, the slope of achieved against requested affect, is only 0.26 for valence and 0.13 for arousal on Llama-3.1-8B, where a faithful controller would score 1. The model systematically undershoots requested emotional intensity, which puts a number on the qualitative observation of Fazzi et al. (2025). Our experiments trace this to the preference-learning pipeline. Training targets from natural corpora such as EmoBank are neutral-heavy, and the sampled candidates themselves rarely reach extreme affect, so Direct Preference Optimization (DPO) is left with no extreme exemplar to prefer. If instead we cover the target space uniformly and sample a hotter, larger candidate pool, valence gain rises from 0.26 to 0.40 +/- 0.02 (3 seeds) and extrapolation error drops, at only a modest in-distribution cost (EmoBank-test VA distance 0.092 to 0.107). The same recipe reproduces on Qwen3-8B (gain_v 0.44, with in-distribution accuracy preserved). Arousal is harder and less reliable: its gain barely moves on average and swings across seeds (0.14 +/- 0.07, against valence's tight +/- 0.02), because raising arousal needs candidates the base model is reluctant to generate. The evidence indicates that faithful intensity is bottlenecked by the extremity of the candidate pool rather than by the conditioning format.

Mon 7 SeptComputation and LanguageArtificial IntelligenceMachine Learning
The gist
When asked to produce very excited or intense emotions, some language models only respond mildly. The authors found this happens because the training data mostly contains neutral or mild emotions, and the models rarely see or generate strong emotional examples. By changing the way examples are selected during training to include more intense emotions, the models respond more closely to requested emotional levels. However, it remains harder for models to increase certain emotions, like excitement, than others.
Open 2609.07808v1

Multimodal memory method improves long-term AI agent reasoning

MEMO: Multimodal Evidence Memory Organization for Long-Horizon LLM Agents

Abstract: Long-running LLM agents rely on external memory to store and reuse information beyond a single context window, yet there is a fundamental tension between the continuous accumulation of interaction trajectories and the limited context capacity. The key challenge in agent memory is therefore not only to retrieve relevant records, but also to select necessary evidence under a given budget and organize it in an appropriate modality. Existing memory readout methods mainly use textual or visual forms. Text preserves high fidelity, but its linear token representation makes contents with different importance compete for the limited context at nearly uniform unit cost. Visual readout renders text into document-like images, which can use two-dimensional layouts to expose structure and emphasize key information, but it may lose fine-grained details during rendering and compression. To address this issue, we propose MEMO, a multimodal evidence memory organization method for LLM agents. MEMO first uses a trained evidence extractor to select relevant memory blocks and form evidence units with source information and presentation requirements. A trained query-conditioned memory manager assigns each unit to a textual, visual, or dual-channel carrier and selects a layout that matches the evidence structure. A deterministic memory construction module then generates the textual package and visual pages. The memory manager is trained with feedback from an offline reader that measures the utility of the guided memory plan, so that retention and presentation decisions align with downstream usage. We evaluate MEMO on four benchmarks, HotpotQA, 2WikiMultiHopQA, LoCoMo, and ALFWorld, with multiple reader backends. The results show that MEMO presents memory more efficiently with fewer memory tokens, improves downstream task performance, and builds more effective working memory under constrained budgets.

Mon 7 SeptComputation and Language
The gist
Large language model (LLM) agents need to remember important information over many steps, but their memory space is limited. The authors created a system called MEMO that chooses what to remember and whether to store it as text, images, or both, depending on what helps later tasks the most. MEMO organizes memory efficiently so the AI can find and use key facts better, improving its performance on several question-answering and task benchmarks. This method balances detail with space, making long-term reasoning more effective.
Open 2609.07471v1

LLMs change their values depending on context and pressure

Probing the Structure and Dynamics of LLM Value Expression through Value Conflicts

Abstract: Ethical evaluation of Large Language Models (LLMs) often characterizes model values as static and monolithic. In contrast, we argue that LLM value expression is better understood as a structured yet dynamic phenomenon. To investigate this, we introduce Conflict-driven Value Probing, a controlled framework that places LLMs in value conflicts and implements four types of interventions that perturb these conflicts to probe LLM value expression. Applying this framework to ten LLMs, we identify three recurring patterns. (1) Expression duality: models shift from broad idealistic orientations in abstract assessment toward more pragmatic priorities in concrete conflicts. (2) Functional steerability: models readily reconfigure their expressed value profiles toward task-defined value objectives. (3) Bounded plasticity: such reconfiguration is not without constraints, i.e. pressure induces a security- and goal-oriented priority shift while negative framing distinguishes protected values from those more amenable to redirection. Together, these findings characterize both the structure and dynamics of LLM value expression: context flexibly reconfigures expressed priorities, yet within behavioral boundaries. This behavioral account provides a foundation for understanding controllability, alignment, and safety in LLMs. Code and data are available at https://github.com/ZeroGen-Lab/CFProbe.

Mon 7 SeptComputation and Language
The gist
People often think that large language models (LLMs) hold fixed and simple values when making ethical judgments. The authors show that LLMs actually express values that can shift depending on the situation and how questions are framed. They created tests that put these models into conflicts between values and changed conditions to see how the models respond. They found that LLMs switch from general ideal ideals to practical trade-offs when facing specific conflicts, and they can adjust their values but only within certain limits. This helps us better understand how to control and align LLM behavior safely.
Open 2609.07296v1

Language model stability and memory horizons explained

Separating Stream Stability from Long-Term Recall in Language Models

Abstract: Methods for streaming language models are often discussed alongside long-context and memory systems, although they solve different problems. An attention sink can stabilize autoregressive generation over an indefinitely long stream while the model remains unable to use content that has left its recent-token cache. We argue that this distinction should be explicit in system claims and evaluation. We introduce three horizons: the stability horizon, over which predictive behavior remains well behaved; the access horizon, over which past content can still causally affect the output; and the utility horizon, over which a task retains acceptable performance. We show constructively that the stability horizon can be infinite while the access and utility horizons are finite. We then propose ThreeH, an evaluation contract that measures all three horizons under a common state and compute budget. Applying the framework to attention-sink streaming clarifies its strength, constant-memory, stable generation, without treating anchor tokens as semantic memory. The framework exposes roles for cache policies, recurrent state, retrieval, and external memory. Experiments on 128K-token streams, delayed binding recall, and delayed decisions show that attention sinks preserve local modeling but not content beyond the active cache; recurrent and retrieval state extend the semantic horizon.

Mon 7 SeptComputation and Language
The gist
Language models that generate text over long streams can stay stable in their output even when they forget details from earlier parts. The authors point out that stability in generating text is different from remembering past content or maintaining task performance over time. They define three 'horizons' to measure these factors separately: how long the output stays stable, how far back the model can access content, and how long tasks perform well. Their tests show a model can be perfectly stable but still forget older information unless additional memory mechanisms are used.
Open 2609.07282v1

Transformers encode partner expertise early but use it late in processing

Encoded Early, Used Late: Where Transformers Begin to Act on an Inferred Partner's Expertise

Abstract: A transformer can make an attribute linearly decodable in its residual stream at a depth where that attribute does not yet influence the output. This gap between where information is readable and where it is used has been shown for attributes stated directly in the input. We ask whether it also holds for an attribute the model must infer gradually over a conversation, namely how expert its dialogue partner is. Using ExpertCollab, a corpus of multi-turn research-planning dialogues between model-played personas at four expertise levels, we find that partner expertise is most decodable in the early layers and falls to near chance before the midpoint of the network. Counterfactual patching shows that injecting the expertise difference at the layer of peak decodability barely changes a fixed late-layer readout, whereas the same difference injected past the midpoint propagates almost completely, a separation of more than an order of magnitude. A content-matched random control and a probe-free diagnostic place the transition at the same early layer, and a statically specified control attribute stays decodable throughout. An inferred relational attribute is therefore represented well before it becomes causally active, which bounds where any attempt to read out or steer partner-conditioned behavior must intervene. We use one model on a synthetic corpus as an initial demonstration.

Mon 7 SeptArtificial IntelligenceComputation and Language
The gist
This paper looks at how transformer AI models understand how expert their conversation partner is during a dialogue. The authors found that while the model stores this information early in its internal layers, it doesn’t actually use it to shape its responses until much later. This means the model has some knowledge available before it influences output, and interventions to change behavior based on partner expertise must target deeper layers. The study shows this gap using dialogue examples involving different expertise levels.
Open 2609.07139v1

MemLoc improves long-term chat memory retrieval and answer quality

Where to Look and What to Use: Retrieve-Localize-Generate for Long-Term Conversational Memory Question Answering

Abstract: Retrieval-augmented generation (RAG) enables large language models (LLMs) to answer questions by accessing external knowledge and has been widely adopted for long-term conversational memory question answering. However, existing methods suffer from two key challenges: (1) fragmented evidence scattered across temporally distant sessions, and (2) noisy content within retrieved sessions that triggers the lost-in-the-middle effect. To address these challenges, we propose MemLoc, a unified Retrieve-Localize-Generate framework for long-term conversational memory QA. For retrieval, MemLoc decomposes each session into multi-granularity memory units and performs query routing via an inner-memory graph with entropy-based granularity selection. It further models cross-session semantic and temporal dependencies through a cross-memory graph, enabling coarse-to-fine retrieval of top-K relevant memory candidates. For localization, we introduce a reasoning-based evidence locator trained with Self-reflective Hint Policy Optimization (SHPO), which performs progressive refinement by extracting query-relevant fragments within memory units to suppress noise and reranking across candidates to remove redundancy, producing a compact evidence set with lightweight location IDs. For generation, these IDs act as precise grounding signals that guide the LLM to the correct memory positions, mitigating the lost-in-the-middle effect while preserving original contextual integrity. Extensive experiments on four benchmarks demonstrate that MemLoc achieves state-of-the-art retrieval accuracy and response quality while maintaining efficiency. Our code is available at: https://github.com/Nikol-coder/MemLoc.

Mon 7 SeptComputation and LanguageInformation Retrieval
The gist
Remembering details from long conversations is hard because information can be scattered and mixed up. The authors created MemLoc, which breaks conversations into smaller parts, finds the most helpful bits, and guides language models to use them correctly. This method helps computers give better answers by focusing on the right pieces of past conversations. Tests showed MemLoc works better and faster than other methods.
Open 2609.07093v1

Multi-hop retrieval improves question answering by exploring evidence progressively

Beyond One-Shot Expansion: Contrastive Evidence Exploration for Multi-Hop Retrieval

Abstract: Retrieval-augmented generation (RAG) critically depends on retrieving the evidence necessary for effective reasoning. However, this remains particularly challenging in multi-hop question answering (QA), where supporting passages are often linked through intermediate entities and relations that must be progressively uncovered. Existing retrieval approaches typically rely on a single retrieval intent or one-shot query expansion, limiting their ability to adapt to newly retrieved evidence and potentially introducing noisy or redundant retrieval signals. To address these limitations, we propose a training-free multi-hop retrieval framework that integrates evidence-conditioned exploration, passage-specific contrastive refinement, and coverage-aware final ranking. During offline indexing, the framework constructs passage-specific contrastive facets that characterize each passage relative to its semantically similar neighbors, providing fine-grained signals to distinguish closely related candidates. At inference time, the framework iteratively retrieves evidence, generates probes targeting unresolved information needs, refines candidate relevance using the contrastive facets, and selects a complementary set of passages that collectively cover diverse evidence-seeking intents. Experiments on MuSiQue, HotpotQA, and 2WikiMultihopQA demonstrate consistent improvements in retrieval quality and downstream QA performance over baselines.

Mon 7 SeptArtificial IntelligenceInformation Retrieval
The gist
Finding the right pieces of information is tricky when answering questions that need several steps, because the clues are linked in complex ways. The authors developed a way to search for information bit by bit, checking what’s already found to guide the next search more smartly. They also use comparisons between similar pieces of information to pick the best clues and cover all parts of the question. Their approach improved results on several challenging multi-step question-answering tests.
Open 2609.07050v1

Cantonese language model improves reasoning with limited data

CantoneseLLM v2: Reasoning in a Low-Resource Language

Abstract: Cantonese is widely spoken but remains low-resource in written data, with no large corpus of native Cantonese reasoning traces available for model training. We develop and release CantoneseLLM v2, comprising models based on Qwen3 8B and 30B-A3B. The models are trained through CPT on 784 million Cantonese and Hong Kong-related tokens, chat-vector merging, SFT, DPO, and RLVR. Evaluation across the training stages shows that chat-vector merging transfers instruction following but preserves the donor model's reasoning language, while SFT with limited Cantonese reasoning data substantially shortens or removes reasoning traces and reduces benchmark performance. DPO restores the reasoning-block format, particularly for the 8B model, but recovers only part of the lost performance. The RLVR training with Cantonese language and Traditional Chinese scripts as multiplicative constraints introduced Cantonese language alignment and restored the lost performance. The 30B-A3B model reaches 73.16 on HKCanto-Eval, within 1.20 points of its merged checkpoint, while retaining the Cantonese reasoning behaviour absent from that checkpoint. We release the model checkpoints, the training environments, and a thirteen-year Traditional Chinese Common Crawl dataset. The models can be accessed at https://huggingface.co/collections/hon9kon9ize/cantonesellm-v20

Mon 7 SeptComputation and Language
The gist
Cantonese is widely spoken but lacks large amounts of written data, especially examples of logical reasoning for teaching computers. The authors created CantoneseLLM v2, a set of language models trained on many Cantonese and Hong Kong-related texts, using special training steps to improve understanding and reasoning in Cantonese. They found that some training methods helped the models follow instructions but weakened reasoning ability, while others restored reasoning and improved performance. The final model closely matches previous versions in test scores but better understands and reasons in Cantonese.
Open 2609.06970v1

Turkish English social media texts challenge AI language and name recognition

TurEngMix: A Text Corpus and Benchmark for Turkish-English Code-Mixed Language Identification and Named Entity Recognition

Abstract: Natural language processing systems underperform on code-mixed text, particularly for low-resource language pairs. Turkish-English poses a further challenge: it lets English stems combine with Turkish suffixes to form single mixed-language tokens. We introduce TurEngMix, a corpus of 5.5K noisy, naturally occurring social media posts (486,974 tokens) rich in Turkish-English code-mixing. From this corpus, we construct a new Turkish-English benchmark for code-mixed language identification (LID) and named entity recognition (NER), comprising 15K expert-annotated tokens. Evaluating both decoder LLM and fine-tuned encoder baselines, we find that monolingual Turkish and English tokens are labeled reliably, but all models have high error rates on mixed-language tokens for both LID and NER. For morphologically integrated tokens, NER error rates were 5.2x and 6.3x higher for GPT-4o and Qwen, respectively. This highlights how morphological integration remains a challenge. We release the corpus, annotations, and code to support future computational and sociolinguistic research on Turkish-English code-mixing.

Mon 7 SeptComputation and Language
The gist
Texts mixing Turkish and English are hard for AI systems to understand, especially when English and Turkish parts form combined words. The authors collected over 5,000 social media posts full of these mixed words and labeled the language and names within them. They tested popular AI models and found that while these models recognize pure Turkish or English words well, they make many mistakes on mixed words. This shows current AI struggles with this kind of language blending, and the authors shared their data and code to help improve future research.
Open 2609.06963v1