Papers for

ai application 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.

Harness system optimizations cut AI agent costs without hurting accuracy

System Optimizations for Cost-Efficient Agent Harnesses

Abstract: AI agent harnesses play the critical role of providing LLMs with an interface to a computing environment. Recent studies show that AI agents' task-execution accuracy depends mostly on the LLM used, while harness-side variances such as system prompts or tools have minimal impact. Rather, such harness-side variances show a larger impact on the cost of agent executions, achieving cost reductions up to 2.6 times on the same model and task. To further explore these harness-side cost optimization opportunities, we analyze the cost accumulation patterns across various agent traces and identify system opportunities to reduce token use and LLM calls without modifying the model or affecting task accuracy. Based on this analysis, we design Agency, a harness interposition platform that provides a unified abstraction and allows easy and portable implementation of harness-side system optimizations on existing off-the-shelf harnesses such as Claude Code or OpenAI Codex. Using Agency, we implement proof-of-concept optimization techniques based on our analysis and achieve cost reductions up to 35% across various real-world benchmarks on existing harnesses without compromising accuracy.

Mon 9 NovArtificial Intelligence
The gist
AI agents use language models (LLMs) to perform tasks, but the way the agent system is built can affect how much it costs to run these tasks. The authors found that changing the system around the LLM doesn’t change how well the tasks get done but can save a lot on costs. They created a platform called Agency that lets developers add cost-saving improvements easily to existing AI agent setups. Their tests show these system tweaks cut costs by up to 35% without making the agents any less accurate.
Open → 2611.12122v1

IdealCache speeds up diffusion transformers with better cache schedules

IdealCache: Rethinking Cache Scheduling in Diffusion Transformers via Ideal Trajectories

Abstract: Feature caching accelerates Diffusion Transformers by reusing intermediate computations across denoising timesteps, yet existing methods share a fundamental blind spot: they treat the standard reference denoising trajectory as the optimisation target, approximating its per-step states and thus inheriting its output as an implicit quality ceiling. We argue that this target is arbitrary -- what truly matters is the ideal result, not the intermediate path taken to reach it. We propose IdealCache, a training-free framework that abandons step-wise imitation of the reference trajectory. Instead, it anchors caching on a per-input ensemble of ideal trajectories constructed from candidate target results, aggregates their geometry into a single graph, and discovers optimal non-uniform schedules via a constrained shortest path on this graph. By decoupling from the reference process, IdealCache breaks the performance bottleneck of trajectory-approximation; our schedules can attain near-lossless fidelity in generation and even surpass on task-specific metrics (e.g., maintaining higher semantic consistency in image editing). Without retraining, IdealCache achieves 6.35x speedup on Qwen-Image, 5.84x on Qwen-Image-Edit, and 4.32x on HunyuanVideo, with competitive or superior quality across tasks.

Sat 7 NovArtificial Intelligence
The gist
Diffusion transformers create images or videos step by step, and usually save some calculations to speed up this process. But usual methods try to copy a fixed step-by-step path, which limits quality and speed. The authors propose IdealCache, which instead finds the best caching strategy by looking at many possible paths to the final result, not just one. This approach significantly speeds up generation without losing quality and even improves results in some editing tasks.
Open → 2611.10340v1

Caleta builds trust layer for local large language model inference

Caleta: An Evidence-Oriented Trust Layer for Reproducible Local Large Language Model Inference

Abstract: Local large language model (LLM) inference is often described as private, verified, or reproducible without separating the technical claims behind those terms. This paper presents Caleta, an Apache-2.0 process supervisor and evidence layer around llama.cpp rather than a new inference engine. Caleta combines versioned manifests, exact-size and SHA-256 verification, controlled backend construction, a restricted OpenAI-compatible proxy, prompt-free execution records, benchmark reports, and a small conformance suite. Its contribution is the composition of these mechanisms into explicit contracts that distinguish integrity from authenticated provenance and privacy controls from operating-system isolation. We evaluate the implementation through static checks, 22 unit tests, deterministic end-to-end tests on Ubuntu, macOS, and Windows, and a pinned real-model experiment on Windows CPU using Qwen2.5-0.5B-Instruct Q4_K_M and llama.cpp b11981. The real experiment validates artifact verification, startup, model listing, non-streaming and server-sent-event chat, and conformance. Three independent benchmark invocations produced fifteen successful warm requests with no failures. In this single configuration, median time to first token was 18.066 ms and median decode throughput was 54.394 tokens/s. These descriptive measurements do not establish cross-engine superiority, output quality, energy efficiency, or hardware-general performance. Raw JSON, commands, and environment metadata are published. Remaining challenges include signed manifests, time-of-check/time-of-use replacement, operating-system containment, proxy-overhead measurement, and broader experimental matrices.

Fri 6 NovSoftware Engineering
The gist
Running large language models on your own computer can be private and trustworthy, but the terms often get mixed up. The authors created Caleta, a system that works with an existing engine to check that models and outputs are authentic and untampered, separate privacy from technical safeguards, and record everything needed to reproduce results. They tested Caleta on different operating systems and hardware to confirm it works reliably and quickly. This helps users be more confident about the integrity and privacy of local AI model runs.
Open → 2611.10324v1

Benchmarking counterfactual spatial reasoning with causal transition modeling

CST-Bench: Benchmarking Counterfactual Spatial Transition Reasoning with Causal Transition On-Policy Self-Distillation

Abstract: Spatial reasoning is a fundamental capability of multimodal large language models (MLLMs), yet existing benchmarks mainly focus on static scene understanding. When objects are moved or swapped, models must infer not only spatial relations but also how interventions change the scene state. To address this problem, we introduce CST-Bench, a benchmark for counterfactual spatial reasoning. CST-Bench contains 7,082 examples covering 6 intervention types and 12 transformation operators, with dense causal annotations including intervention sources, affected relations, expected effects, invariant relations, and metric changes. We benchmark general-purpose MLLMs on CST-Bench and further compare post-training strategies on CST-Bench and standard spatial benchmarks. Results show that methods effective for ordinary spatial reasoning can still fail under counterfactual interventions. We further formulate counterfactual spatial reasoning as causal state-transition modeling and propose CT-OPSD, which uses CST-Bench annotations to guide a teacher model in learning counterfactual state transitions and causal reasoning chains. These chains are then distilled into a student model that reasons only from real observations. Overall, experiment results establish CST-Bench as a challenging benchmark and reusable supervision resource for counterfactual spatial reasoning. CT-OPSD further provides an initial demonstration of how its annotations can support model improvement.

Thu 5 NovArtificial Intelligence
The gist
Understanding how objects move and change in space is important but tricky for language models. The authors created CST-Bench, a large set of tests that check if models can reason about changes in scenes when things are moved or swapped. They found that usual methods struggle with these 'what if' scenarios. To help, they designed a new approach called CT-OPSD that teaches models to think about cause and effect in these changing scenes. This work provides both a tough test and a way to make models better at reasoning about space and change.
Open → 2611.07541v1

BtsPruner cuts visual tokens to speed up large vision language models

BtsPruner: Role-Aware Visual Token Pruning for Large Vision-Language Models

Abstract: Large Vision-Language Models (LVLMs) often process hundreds or thousands of visual tokens, resulting in substantial computational and memory overhead during inference. Existing training-free pruning methods typically estimate token importance using language-model attention, visual attention, or feature similarity. However, these methods treat visual tokens with uniform criteria and overlook that tokens may serve different roles during visual encoding. In this work, we investigate the evolution of visual token roles in LVLMs and observe that tokens progressively transition from local detail carriers to globally referenced representatives as encoding proceeds. Based on this observation, we propose BtsPruner, a training-free role-aware visual token pruning framework that preserves complementary token roles under a fixed budget. Specifically, BtsPruner first identifies the token-role transition point based on the evolution of attention concentration. It then discovers globally referenced representatives from later encoding stages and recursively retrieves local detail tokens from earlier stages to recover complementary fine-grained evidence. Extensive experiments across LLaVA-1.5, LLaVA-NeXT, Qwen-VL, InternVL, and CogVLM demonstrate that BtsPruner achieves superior performance retention under aggressive token reduction. On LLaVA-1.5-7B, BtsPruner preserves 91.6% of the dense model's performance using only 32 of 576 visual tokens (5.6%). In the high-resolution LLaVA-NeXT-7B setting, it achieves up to a 5.95x CUDA-latency speedup.

Tue 3 NovComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Processing many image parts in big vision-language AI models is slow and uses a lot of memory. The authors found these parts change roles as they are analyzed, from showing fine details to representing the whole image. They created BtsPruner, a method that saves important parts at each stage without extra training, keeping a mix of details and summaries. This method keeps most of the model’s accuracy while using far fewer image parts, making the AI run much faster.
Open → 2611.04537v1

AgentPro reduces AI token use and speeds up task workflows

AgentPRO: Coordinating Compiler Optimizations for LLM Agent Workflows

Abstract: LLM agents repeatedly return to a model to generate actions and interpret tool results, incurring repeated context processing and generation overhead. Yet a value needed to execute an action need not be observed by the model to generate that action. This distinction creates an optimization opportunity: reconsider where model decisions are necessary, together with the work performed between them. We present AgentPRO, a compiler framework for optimizing agent workflows as execution information becomes available. AgentPRO organizes planned duties, generation regions, and concrete operations in a hierarchical representation, distinguishing execution dependencies from observations required for generation. Region transformations combine compatible duties into fewer model requests, while operation transformations reduce redundant context and tool work. These scopes interact: eliminating a redundant read can remove an observation requirement that otherwise separates generation regions. AgentPRO coordinates transformations using initial plans, current observations, and historical execution profiles through just-in-time, adaptive, and profile-guided optimization. Runtime guards check state-dependent assumptions and retain fallback paths. We implement guarded workflow transformations for AppWorld agents. On 115 tasks selected by successful historical baseline executions, automatic AgentPRO reduces all-attempt mean token consumption by 41.85% and mean component time by 6.61% relative to those baselines, successfully completing 110 of 115 tasks.

Sat 31 OctSoftware Engineering
The gist
When AI-based agents work on tasks, they often ask the model many times, causing delays and extra effort. The authors present AgentPRO, a tool that smartly combines work steps and cuts down unnecessary AI requests. This tool checks how tasks are planned and updates the work in real-time to save time and resources. Tests showed that AgentPRO used fewer tokens and ran faster compared to existing methods while successfully finishing most tasks.
Open → 2611.00628v1

Open-weight multimodal models struggle comparing unnamed body parts

Open-Weight MLLMs Cannot Compare What They Cannot Name

Abstract: Multimodal Large Language Models (MLLMs) are increasingly capable of understanding images and performing complex visual reasoning, suggesting the possibility of using them to automate biological image analysis. This need is becoming increasingly urgent as advances in technology continue to generate ever larger and more diverse microscopy datasets, already exceeding the scale at which manual visual analysis is feasible. With the final aim to use MLLMs for visual comparison of complex phenotypes, we investigate a very simple baseline: comparison of the size of body parts in synthetic images of ants. We find that state-of-the-art open-weight MLLMs fail for some body parts, but not for others, even though the comparison itself is visually trivial for all of them. We evaluate different in-context learning strategies and analyze performance on the related object recognition task. Our results suggest a recognition-driven grounding failure: structures that the models cannot recognize are instead associated with a recognizable semantic concept, impairing the grounding and comparison of both. Further analysis of the vision encoder is consistent with the hypothesis that fine-grained visual structure may be less well preserved without semantic support. Together, our results reveal a surprising limitation of current MLLMs: semantic recognition can gate simple visual comparisons that do not intrinsically require semantic understanding. Our code and data are available at https://github.com/kreshuklab/Open-Weight-MLLMs-Cannot-Compare-What-They-Cannot-Name

Fri 30 OctComputer Vision and Pattern Recognition
The gist
Multimodal large language models (MLLMs) can understand images and do complex visual tasks, but they have trouble comparing sizes of body parts they cannot recognize or name. The authors tested these models on simple images of ants and found that when the model cannot identify a body part, it fails to compare it properly, even if the comparison is visually easy. This suggests that these models depend on naming or recognizing objects before they can compare them. Their findings highlight a limitation where understanding what something is named as is needed for even basic visual comparisons.
Open → 2610.41841v1

Latent lens improves visual understanding in small language models

Latent-Lens: Visual Perception in Small Language Models Through Latent Communication

Abstract: Bridging independent vision-language models (VLMs) and small language models (SLMs) in a modular multi-agent system typically forces them to exchange information as discrete text, which creates a lossy bottleneck for spatial and fine-grained details. This constraint is especially acute for SLMs, whose limited capacity makes them more reliant on the quality of the input signal. Recent latent-communication methods exchange states between language models. How a VLM can pass visual information to a separately pretrained text-only SLM though remains unexplored. We propose \textbf{Latent-Lens}, a lightweight codec that bridges the representation gap between a frozen VLM and a frozen SLM directly in latent space, enabling them to communicate purely through hidden states. The codec consists of a domain encoder that projects hidden states from the VLM into the SLM's embedding space, and an attention decoder formalised as a LoRA that teaches the SLM to attend to these visual prefixes, while training only ${\sim}1.6$M parameters (0.2\% of the combined model size). On visual question answering (CLEVR, GQA), Latent-Lens achieves $81.0\pm7.9$\% and $65.4\pm5.4$\%, compared with $58.3\pm5.7$\% and $61.8\pm1.0$\% for text communication with the same LoRA budget (+30.2--69.8pp relative to frozen text communication), while on image captioning (Flickr8k) it improves over the same baseline by +16.5 (+18.8 frozen). We also evaluate Latent-Lens with TinyLlama-1.1B and InternVL2-1B, which use different architectures, vocabularies, and hidden dimensions.

Fri 30 OctMachine LearningArtificial Intelligence
The gist
Small language models struggle to understand images well because they usually get visual information as plain text, which loses important details. The authors introduce Latent-Lens, which lets a visual model and a small language model share information in a hidden, compact form rather than text. This method helps the language model better answer questions about images and describe them more accurately. The approach works with different model types and only needs a small amount of extra training.
Open → 2610.41751v1

Activation steering changes large language model discourse style unexpectedly

When Steering Shifts Discourse: Identifying and Intervening on Discourse-Level Changes due to Activation Steering in LLMs

Abstract: Activation steering is an inference-time technique used to control or modify the behavior, tone, or safety properties of a large language model (LLM) without retraining the model's weights or editing its input prompt, but simply by adding a vector to its residual-stream activations. However, activation steering also changes the generated text in unintended ways, unrelated to intended behavior change, that are not well understood. Prior work has measured these changes only through coarse signals such as perplexity. In this work, we show that steering systematically produces significant changes in discourse dimensions of the generated text, such as its formality, use of evidence, and ambiguity. We present a way of countering this by adding a second, complementary vector that targets the affected discourse dimension. This intervention restores about 78% of the unintended discourse changes while preserving the intended steering behavior in about 93% of the generations.

Fri 30 OctComputation and LanguageArtificial Intelligence
The gist
Controlling large language models by adjusting their internal activity can change the style of the text they generate in ways people did not intend. The authors found that this method often alters things like how formal the text sounds or how clearly it presents evidence. They designed a way to fix these unintended changes by adding a second adjustment that targets the unwanted effects, keeping the main control effect mostly intact.
Open → 2610.41661v1

Parallel agents ask peers only when they need specific help

Ask on Demand: Targeted Peer Communication for Parallel Agentic Systems

Abstract: Parallel LLM agents tackle complex tasks by exploring multiple trajectories, yet useful discoveries remain isolated in individual execution histories. Existing sharing methods often select or summarize information before other agents' needs become clear, potentially overlooking details that become important later. We propose Ask on Demand (AOD), a communication framework that enables agents to seek targeted peer assistance when specific information needs arise. Upon an approved request, AOD retrieves relevant evidence from peer execution histories, selects a suitable peer, and generates a response tailored to the request. To determine when such assistance is worthwhile, we train a lightweight gate using paired team continuations, with supervision derived from final team outcomes and inference cost. Experiments on AppWorld and WebShop demonstrate that AOD consistently improves task performance over independent parallel execution while achieving lower inference cost than existing information-sharing baselines. These findings highlight the benefits of aligning peer communication with agents' evolving information needs to achieve more effective and efficient collaboration.

Fri 30 OctArtificial Intelligence
The gist
Solving hard problems by having many AI agents work in parallel often leads to each agent keeping useful clues to itself. The authors show that if agents wait until they actually need some piece of information from a peer and then ask for that specific help, they can work better together. They created a system called Ask on Demand (AOD) that lets agents request targeted advice, choosing the best peer and relevant info for that moment. Tests show this approach improves success rates while using less computing power compared to other ways agents share information.
Open → 2610.41378v1

Talentrl improves task success by guiding skill choice with strategy

TalentRL: Strategy-Guided Reinforcement Learning for Hierarchical Skill Routing

Abstract: Natural-language skills enable large language model (LLM) agents to reuse procedures across tasks, yet most systems retrieve individual skills from a flat SkillBank without explicitly modeling the high-level strategy that governs their selection and use. We introduce TalentRL, a strategy-guided reinforcement learning framework for hierarchical routing over procedural memory. Coarse-grained talents represent recurring strategies for skill use, while fine-grained skills provide executable procedures. For each task, the policy model selects a talent that guides execution and softly prioritizes its associated skills during similarity-based retrieval. However, since task outcomes depend jointly on talent selection, retrieved skill context, and downstream execution, terminal rewards alone cannot isolate the contribution of the routing decision. TalentRL therefore trains talent routing with reward contrasts between rollouts of the same task under matched interventions on the talent-conditioned context, and optimizes downstream execution with group-relative advantages. Across seven open-domain and multi-hop question-answering benchmarks, talent-aware supervised fine-tuning improves average success rate by 7.53%, 6.71%, and 9.21% over the corresponding zero-shot baselines for Qwen2.5-7B, Qwen3-8B, and Llama-3.1-8B, respectively. Reinforcement learning further improves these SFT checkpoints by 7.58% to 9.32%, and TalentRL achieves the highest average success rate among all compared methods on all three backbones. On the agentic benchmarks ALFWorld and WebShop, TalentRL achieves the highest ALFWorld success rate (99.3%) and the highest WebShop score (90.7) among all compared methods.

Fri 30 OctMachine Learning
The gist
Many AI systems that answer questions use a big list of skills but don’t decide which skills to use based on a bigger strategy. The authors created TalentRL, which first picks a general strategy, then finds the best skills for that strategy to solve a task. They trained this method using a clever way to figure out how much each strategy choice helped results. TalentRL performed better than other methods on multiple question-answering tasks and AI challenges involving interaction.
Open → 2610.41143v1

Large language models learn to separate instructions from data for safer use

Post-Training Large Language Models with LLMON

Abstract: Large Language Models (LLMs) treat all context tokens uniformly, lacking explicit separation between executable instructions and passive data. This leads to prompt injection vulnerabilities, ambiguous instruction binding, and unreliable execution control. We present a post-training methodology using LLMON (LLM Object Notation), a framework that enables separating instructions from data and requires explicit identifier-based execution. We construct a large-scale structured training corpus of 4.6B tokens spanning general, RAG (Retrieval-Augmented Generation), and tool-calling data, augmented with distractor-infused variants in which competing instructions and irrelevant data segments are present in context but not referenced. Post-training two Granite-4.1 base models (3B and 8B) through supervised fine-tuning followed by reinforcement learning, we show that LLMON-structured supervision reduces attack success rates on indirect prompt-injection benchmarks from 53-100% to 0.02-5.6% while preserving general capabilities. We further introduce attention-based interpretability metrics that diagnose failure modes at individual transformer layers for structured inputs, revealing how our approach reshapes internal attention patterns. Our results demonstrate that explicit execution semantics can be taught through standard post-training without architectural modification.

Wed 28 OctArtificial IntelligenceMachine Learning
The gist
Large language models currently treat all parts of their instructions and data the same way, which can cause problems like hackers tricking the model or unclear execution of commands. The authors created a new method called LLMON that forces the model to clearly separate instructions from data by using special labels. They trained large models on a big dataset with these structured inputs and found that it greatly reduces security risks without hurting performance. This approach also helps understand how the model processes instructions internally, all without changing the model design.
Open → 2610.38120v1

Self improving language agents learn better by choosing tasks carefully

GEPA-Curator: Curated Learning for Self Improving Agents

Abstract: Large Language Models (LLMs) are increasingly used in multi-turn agentic workloads that require sustained interaction with complex environments. Existing reflective prompt optimizers such as GEPA learn from failed rollouts, but agentic failures can also come from prompt weaknesses, harness limitations, stochastic execution, or noisy judges. We argue that such failures may not provide useful learning signal, and may even be harmful; and thus it is essential to curate which tasks are provided to the prompt optimizer for better performance. We introduce GEPA-Curator, a framework that augments the prompt optimizer to select which agent experiences should shape prompt optimization. In particular, GEPA-Curator consists of two components: task curation, which filters out tasks that are likely to provide noisy or unreliable learning signals, and prior success retrieval, which selectively retrieves past successful trajectories for a task and provides them as additional context to the prompt optimizer. We evaluate GEPA-Curator on GoBrowse, ALFWorld, AppWorld, and $τ$-bench, using both Gemini 3.1 Pro and Claude Opus 5 as optimizer models. GEPA-Curator matches or exceeds the mean performance of both baselines, with gains of up to 20.7% over GEPA and 21.2% over ACE.

Tue 27 OctComputation and Language
The gist
Large language models can act as agents that try to complete multiple connected tasks, but sometimes they fail in ways that don't help them learn. The authors show that not all failure experiences are useful for improving these agents, so their system, GEPA-Curator, picks which tasks and past successes to use for learning. By selecting better examples, the agents get smarter and perform tasks more successfully. They tested this approach on several language-based tasks and found it improves results by up to about 20%.
Open → 2610.37651v1

Hybrid large language models improve speed and efficiency on demand

Request-Adaptive Execution for Efficient Hybrid LLM Inference

Abstract: Hybrid large language models (LLMs) have emerged as a promising way to combine the modeling capability of the Attention mechanism with the efficiency of state space models (SSMs). However, most existing hybrid LLMs still inherit a static design philosophy: once the Attention-to-SSM layout is chosen, every request must follow the same hybrid execution. This one-layout-fits-all design is inefficient for real-world serving workloads, where different requests rely on contextual information in different ways. This paper presents Morph, a serving system that co-designs the model architecture and runtime for request-adaptive hybrid LLM inference. Its model architecture pairs Attention and SSM layers within each block and uses prefill-oriented gating to select a request-specific layout that remains fixed throughout decoding. Its serving runtime preserves batching efficiency under divergent layer choices through selective batching and enables correct prefix reuse through hybrid-aware context caching. Experiments on six datasets show that Morph achieves a better quality-efficiency trade-off than existing static hybrid baselines. System-level evaluation further shows that Morph improves the serving throughput by up to 3.87x over baselines while substantially reducing inference latency.

Tue 27 OctDistributed, Parallel, and Cluster Computing
The gist
Large language models use different internal parts to understand and generate text, but most use the same design for all requests, which can be slow or waste resources. The authors created Morph, a system that adjusts how it uses these parts depending on each request to work more efficiently. Morph mixes two techniques within each section of the model and chooses the best way to process each query ahead of time, improving speed and response quality. Their tests show Morph works better than fixed designs, running faster and handling more requests at once.
Open → 2610.37432v1

Self-regularized training improves continuous diffusion language models

Self-Regularized Flow Language Models

Abstract: We introduce SERF (Self-Regularized Flow Language Models), a simple self-supervised framework for improving continuous diffusion language models by exploiting the denoising trajectory itself. While continuous flow-based language models offer a promising alternative to autoregressive generation, their training objectives typically rely on supervision from clean target tokens, leaving the denoising trajectory underexploited as a learning signal. SERF addresses this limitation through noisy-to-clean self-distillation: an exponential moving average (EMA) teacher receives a cleaner version of the student's noisy input along the same interpolation path and provides additional supervision. We investigate two variants: SERF-L, which aligns the student's intermediate representations with deeper teacher representations, and SERF-P, which aligns their output token distributions, either at the student's output or at an early student layer. All variants augment the standard training objective without requiring external pretrained models or modifying the inference procedure. Experiments across three continuous language-model paradigms (one-hot FLM, latent ELF, and hyper-spherical S-FLM) demonstrate substantial improvements in training efficiency, generation quality, and few-step generation. In particular, SERF achieves up to 7.7x wall-clock training acceleration on OpenWebText, improves MAUVE by 24.3% and GSM8K accuracy by up to 28.8%, and matches baseline performance with up to 64x fewer sampling steps. These results establish noisy-to-clean self-distillation as an effective approach to improving continuous diffusion language models.

Tue 27 OctMachine LearningComputation and Language
The gist
Training continuous diffusion language models usually relies on giving them clean example tokens, but this misses out on useful signals during the cleanup process. The authors propose SERF, a way for the model to learn from its own progressively cleaner versions by comparing its noisy inputs with a better version generated by an older model copy. This self-teaching helps the model learn faster and generate better text with fewer steps. Experiments show significant improvements in training speed, text quality, and problem-solving accuracy.
Open → 2610.37115v1

Visual reasoning improved by exploring multiple image evidence branches

Latent Visual Contrastive Reasoning with Multi-Branch Exploration

Abstract: Multimodal large language models have made substantial progress in visual question answering, but complex visual reasoning often requires locating and comparing multiple pieces of question-relevant visual evidence. Existing methods that move intermediate reasoning into the visual latent space usually follow a single linear reasoning trajectory, which can be limiting when multiple visual hypotheses or competing evidence regions are relevant. We propose Latent Visual Contrastive Reasoning, a branch-aware latent reasoning framework that generates multiple question-conditioned latent visual branches as soft hypotheses over image tokens. To train these branches, our method uses bounding-box evidence annotations to build target evidence representations and introduces a soft contrastive branch-evidence alignment objective. This objective encourages evidence-relevant branches to align with annotated visual regions while contrasting them against negative evidence. We instantiate our method on Qwen2.5-VL backbones and train it with standard supervised fine-tuning. Experiments on perception-intensive visual reasoning benchmarks show that the proposed method achieves overall improvements over the corresponding backbone and single-path latent reasoning baselines at both 3B and 7B scales.

Tue 27 OctComputer Vision and Pattern RecognitionComputation and Language
The gist
Sometimes AI models struggle to answer visual questions because they only follow one path when looking for clues in images. This paper presents a way to let the model consider several possible clues at once, and learn which clues are best using examples marked by humans. The model gets better at finding and comparing important parts of an image to answer complex questions. Tests show this method improves performance on demanding visual tasks compared to older methods.
Open → 2610.36809v1

OpenVLHarness boosts visual AI reasoning with tool-based memory

OpenVLHarness: Real World Visual Agentic Tool-Use with Multimodal Memory

Abstract: Multimodal large language models (MLLMs) have made rapid progress on visual reasoning, yet many tasks require evidence that is difficult to obtain through internal reasoning alone: our controlled study on 22 benchmarks shows that simply increasing the inference budget of the base model yields only modest gains. Such tasks demand grounded perception, external knowledge, and numerical measurements obtained through heterogeneous tools, whose outputs must be made interpretable to the model and retained across reasoning steps. We introduce OpenVLHarness, a multimodal reasoning harness organized around a capability layer and persistent multimodal memory. The capability layer combines task-level tool interfaces with evidence rendering, providing consistent access to heterogeneous backends and converting their outputs into model-readable observations. Persistent multimodal memory retains the corresponding images, structured data, and web references as addressable artifacts throughout each query. A coding interface executes generated programs over stored data, enabling computations that combine results from multiple tools. Together, these mechanisms support an iterative process of acquiring, inspecting, and composing multimodal evidence. Evaluated on 22 benchmarks with eight open and proprietary backbones, OpenVLHarness improves average scores by 9.7-12.6 points over matched no-tool baselines, including +11.2 with Qwen3-VL-8B, +9.7 with Kimi K3, and +9.9 with GPT-6 Astra. With GPT-6 Luna at medium reasoning effort, OpenVLHarness outperforms the base model, Codex, and Visual Sketchpad at maximum effort by 7.7-8.5 points while incurring at most 37% of their model-token cost.

Mon 19 OctComputation and LanguageArtificial IntelligenceComputer Vision and Pattern Recognition
The gist
Many visual AI tasks need information that a model can't figure out just by thinking alone. The authors created OpenVLHarness, a system that connects AI models to various tools and remembers the information they gather during a task. This memory includes pictures, data, and web links, which helps the model reason better over multiple steps. Tested on many tasks, it improved performance significantly compared to models working without these tools.
Open → 2610.26860v1

Leap method speeds up diffusion model sampling with accuracy

LEAP: Accelerating ODE-based Diffusion Sampling with Optimal Linear Leaps

Abstract: Diffusion models primarily rely on general-purpose ODE-based numerical methods for training-free accelerated sampling, but performance degrades with coarse time discretization. In this paper, we propose optimal linear leaps (LEAP), a specialized method grounded in theoretical and empirical investigations of sampling trajectory geometry. Built upon low-dimensionality and cross-trajectory consistency, LEAP formulates a supervised least-squares optimization problem within the local trajectory subspace, achieving a precise approximation of future states without model evaluations. Extensive experiments demonstrate that LEAP outperforms previous methods across diverse modalities, including text-to-image (Stable Diffusion 3.5, FLUX.1-dev) and image-to-3D (TRELLIS.2) generation. Furthermore, LEAP can be seamlessly integrated into existing solver-based methods, offering a plug-and-play enhancement for modern diffusion models. Code is available at https://github.com/zju-pi/LEAP.

Mon 19 OctComputer Vision and Pattern Recognition
The gist
Diffusion models help computers create images and 3D content by gradually improving guesses. Usually, speeding this process up makes the final output worse when using rough time steps. The authors designed LEAP, a new technique that carefully predicts future steps without extra work, based on understanding the path these guesses take. This method works better and faster on many tasks like turning text into images or creating 3D models from images, and it can be easily added to existing tools.
Open → 2610.25918v1

Steady thought reduces excessive reasoning switches in large ai models

SteadyThought: Mitigating LLM Under-Thinking via Thought-Level Preference Optimization

Abstract: Flexible switching between reasoning trajectories (i.e., thought switching) has significantly enhanced the reasoning capabilities of Large Reasoning Models (LRMs). However, existing models often switch excessively yet fail to sustain promising reasoning thoughts, a phenomenon termed "under-thinking". While recent efforts suppress switching to mitigate this, such over-correction may discard valuable trajectories. To address this challenge, we propose Steady Thought (ST), a novel thought-level preference optimization framework. ST formalizes under-thinking as a preference issue at switching points, forcing single-path continuations from identified points to yield high-quality reasoning. Then, ST performs thought-level preference optimization by treating the newly generated response as preferred and the original one as dis-preferred. Experiments across multiple models and datasets show that ST effectively reduces token consumption, achieving reductions of up to 63.8%, while maintaining strong reasoning accuracy. Further analysis suggests that ST helps models acquire a generalizable ability to reduce redundant switching across domains and languages. Code is available at https://github.com/MIRALab-USTC/SteadyThought.

Sun 18 OctArtificial Intelligence
The gist
Large AI models that solve problems by thinking step-by-step often switch too much between different lines of thought, which wastes effort and lowers performance, a problem called under-thinking. The authors propose Steady Thought, a method that encourages the model to stick with promising ideas longer by learning to prefer better reasoning paths. Their experiments show that this approach cuts down on wasted steps while keeping the models just as accurate. It also helps models to apply this improved thinking consistently across different languages and topics.
Open → 2610.25045v1

Hippo helps ai agents improve without changing their code

Hippo: Training-Free Agent Self-Evolution via Hippocampal Replay

Abstract: Motivated by recursive self-improvement (RSI), we study how LLM agents can learn through external memory without updating model parameters. Extracting useful experience from a single attempt is difficult: flawed reasoning can produce success, while poor execution can obscure a sound strategy. Preserving its value over time is also difficult: our accumulation baseline without consolidation initially improves but eventually performs below a no-memory baseline. Our key idea is to compare attempts at the same task to identify reusable decisions and refine when they apply. We introduce Hippo, a memory framework inspired by selective hippocampal encoding and replay that learns from these comparisons when shortcomings are diagnosed. It compares the resulting experience with existing memory to merge overlaps and resolve conflicts through explicit applicability conditions. This allows prior guidance to be revised without storing every lesson as a separate entry. Experiments on SWE-bench Verified, WebArena, and Mind2Web show performance gains in all three settings and substantially fewer retained experiences than the accumulation baseline. The gains extend across the evaluated base models of varying capabilities, indicating that memory-based adaptation remains useful even for highly capable models.

Sat 17 OctArtificial Intelligence
The gist
Artificial intelligence agents often struggle to learn from their past attempts because it's hard to tell if a success was due to good planning or just luck. This paper introduces Hippo, a memory system inspired by how the brain's hippocampus works, which helps agents compare different tries to remember useful decisions and fix mistakes. Hippo stores and updates these memories without needing to change the AI itself, leading to better performance on various tasks with fewer memories kept. The authors show that even very capable AI models can benefit from this kind of memory-based learning.
Open → 2610.24453v1

DLite speeds up AI responses without storing full conversation history

DLite: History-free Speculative Decoding for Agentic AI

Abstract: Speculative decoding has become a mainstream technique for accelerating large language model (LLM) inference by using a lightweight draft model to generate candidate tokens that are subsequently verified by the target model. However, agentic workloads introduce long and continuously evolving contexts and frequent multi-turn interactions. Under such workloads, we observe that existing draft models suffer from up to an 80% degradation in acceptance length, while maintaining their historical KV cache introduces substantial system overhead. In this paper, we identify the growing historical context as a common source of both problems and introduce DLite, a history-free speculative decoding framework for agentic AI. DLite directly reuses contextual hidden states from the target model and performs local speculative prediction without explicitly maintaining the historical context, transforming an increasingly complex modeling problem into local simple prediction problem. A lightweight sequential head further restores intra-block causal dependencies with low overhead. To effectively train this heterogeneous history-free architecture, we introduce a tailored two-stage training strategy. Experiments on general-purpose, long-context and agentic workloads show that DLite achieves 2-6 acceptance length and outperforms the state-of-the-art speculative decoding method, DSpark, up to 70%.

Fri 16 OctComputation and Language
The gist
When AI systems talk back and forth, keeping track of everything they said before can slow them down and make predictions less accurate. The authors found that this problem gets worse the longer the conversation goes on. They created DLite, a new way to guess the AI’s next words quickly without holding onto the entire chat history. This method uses parts of the AI’s internal thinking states and a special training approach to keep predictions reliable and fast. Their tests show DLite works better and faster than previous methods, especially for long conversations and interactive uses.
Open → 2610.23787v1

Graph method reveals where AI agents act less consistently

GraphACM: Graph-based Action Consistency Measurement for Uncertainty Quantification in LLM Agents

Abstract: Behavioral consistency across repeated executions provides an informative signal for assessing the reliability of large language model (LLM) agents. However, existing approaches typically summarize consistency with a single task-level score, without identifying where behavioral differences occur or whether actions are compared under equivalent decision contexts. We propose a graph-based framework for fine-grained behavioral consistency measurement and uncertainty quantification. Given multiple rollouts of the same task, we merge equivalent states into a directed, action-labeled graph, enabling action comparisons at shared decision states. We introduce node-level and global measures of action consistency, using the global consistency score as a proxy for uncertainty to predict task success or failure. Experiments across three LLMs on ALFWorld, AppWorld, and WebShop demonstrate that our measure is positively associated with task success and achieves an average AUROC of 0.811 for task-success prediction, outperforming the strongest behavioral-consistency baseline (0.729) and verbalized confidence (0.769). These results highlight the effectiveness of state-conditioned behavioral consistency and pinpoint where agent actions agree.

Thu 15 OctArtificial Intelligence
The gist
Large language model agents sometimes make different choices when asked to do the same task multiple times, making it hard to trust their results. The authors created a way to compare their decisions in a detailed, step-by-step manner using a graph that represents different states and actions. This method helps identify exactly where the agent’s behavior changes and measures how confident we can be about its correctness. Tests show that their approach better predicts when the AI will succeed or fail than previous methods. This means developers can better understand and improve AI agent reliability.
Open → 2610.22031v1

Tool graph memory rarely improves multi-step language model tool use

Rethinking the Role of Tool Graph Memory in Multi-Turn Tool Use

Abstract: Large language model (LLM) agents solve complex tasks by calling external tools over multiple turns. Recent work has proposed tool graph memory, which stores past experience as tool transitions to guide subsequent selection. However, it remains unclear whether this component consistently improves agents' tool use or undermines it. We evaluate tool graph memory on nine models and two benchmarks, finding that it seldom improves significantly over baselines, and that its gains, where present, cost over twice the LLM calls. The memory's guidance is often incorrect, and random or no guidance retains most of the gain, implying that the benefit stems from extra computation rather than the memory itself. Moreover, even with the correct next tool suggested, many failures remain, such as giving up without a tool call. Storing the same experience instead as textual insights outperforms tool graph memory with almost no extra LLM calls. This suggests that memory serves better as a soft prior than as a prescription of the next tool, leading to a more effective and generalizable solution.

Thu 15 OctComputation and LanguageArtificial Intelligence
The gist
Using big language models to solve complex tasks often involves calling external tools step by step. The authors looked at a memory method that tries to remember past tool use to pick the next tool better. They found that this memory method usually doesn't help much and can even waste a lot of extra work. Instead, turning past experience into simple text instructions worked better and used fewer resources. This means it’s better to guide the model softly rather than telling it exactly what to do next.
Open → 2610.21571v1

Structured paper representation helps agents find and connect ai research faster

Do Agents Need a New Kind of Paper? SPRA: Structured Paper Representation for Agents

Abstract: Scientific agents must connect research problems, methods, and findings dispersed through narrative articles. We introduce SPRA (Structured Paper Representation for Agents), a paper-level representation of persistent research objects and typed relations. Its empirical-AI profile organizes Problems, Contributions, Components, ExperimentSetups, Measures, and Findings for querying, traversal, and reuse. Selected paper-level citation relations record dependencies, component use, and comparisons with prior work; source locations support verification. We instantiate SPRA across more than one million AI papers, with 19.95 million research units and 24.07 million internal relations. Evaluations access SPRA through Schema-RAG with task evidence fixed before inference. Across seven subfields, SPRA improves source-conditioned scientific QA by 0.381/5 over passage retrieval while remaining close to Full Compact (0.078/5 lower on average). In directed cross-paper reasoning, qualification improves by 0.184/5 over passage retrieval; Top-5 synthesis shows mixed quality effects. Across all paired RQ2 tasks, including Top-5, input+output tokens decrease by 28.5% relative to passage retrieval and 95.3% relative to Full Compact. In idea generation, a 0.067-point lower Overall score than Full Compact accompanies 93.7% fewer input+output tokens. Together, these results support SPRA as a usable representation of scientific content and a foundation for research workflows that connect, inspect, and reuse paper-level research objects. The SPRA resource is accessible through the SciVerse scholarly-data platform.

Thu 15 OctArtificial IntelligenceComputation and Language
The gist
Scientific papers often contain important ideas, experiments, and results scattered in long text. The authors created SPRA, a way to break down papers into clear parts like problems, methods, and findings. This organized format helps computer agents quickly find and check scientific information. They tested SPRA on millions of AI papers and showed it improves how agents answer questions and draw conclusions compared to traditional methods. Their work supports better tools to explore and reuse scientific knowledge efficiently.
Open → 2610.21424v1

Mclair detects and corrects agent unfaithfulness during task execution

MCAIR: Monitoring and Correcting Agent Unfaithfulness via Internal Representations

Abstract: Large Language Model (LLM)-based agents have demonstrated remarkable capabilities in completing complex tasks through multi-step reasoning and tool interactions. However, recent studies have revealed that LLM-based agents can exhibit unfaithful behaviors, where their final reports fail to faithfully reflect their actual execution trajectories. Specifically, when agents fail to accomplish tasks through the intended sources or procedures, they may resort to alternative sources or strategies while failing to disclose such deviations, leading users to incorrectly believe that the tasks have been completed according to the original requirements. We refer to this specific form of agent unfaithfulness as Agent Completion Unfaithfulness. Detecting and mitigating agent completion unfaithfulness is critical yet remains largely unexplored. In this work, we propose MCAIR, a runtime monitoring and correction framework that leverages internal representations of LLM-based agents. MCAIR uses multi-step internal representations as inputs to train a risk-aware probe, enabling online detection of potential completion unfaithfulness during execution. Furthermore, MCAIR introduces a risk-guided correction loop that prompts agents to review their execution history and mitigate potential inconsistencies between their execution trajectories and final reports. Additionally, we construct ACUD, a dataset for Agent Completion Unfaithfulness detection that provides step-level execution traces, step-level internal representations, and consistency annotations for training and evaluating runtime detection probes. Experiments demonstrate that MCAIR outperforms LLM-as-a-judge baselines, generalizes across prompts and tasks, and effectively reduces agent completion unfaithfulness.

Wed 14 OctArtificial IntelligenceMachine Learning
The gist
Large language model agents sometimes say they completed tasks in a certain way when they actually used different methods, which can mislead people. The authors call this problem Agent Completion Unfaithfulness. They created MCAIR, a system that watches the agent’s internal thought steps to spot when the agent might be misstating what it did. MCAIR can then ask the agent to check its past actions and fix any inconsistencies before giving a final answer. They also built a dataset to help train and test systems for this problem, showing that MCAIR works better than previous approaches.
Open → 2610.19679v1

Plant memory generates verified failure knowledge from maintenance records

Plant Memory: Technical Language Processing and a Verified Maintenance Ontology for Agent-Accessible Failure Knowledge from SAP PM Work Orders

Abstract: Maintenance work orders are the largest written record of how industrial equipment fails, yet in most plants they are close to unusable for analysis. Short texts are abbreviated and misspelt, asset identity is buried in free text, work-type labels contradict the work described, and the fields that matter most for reliability (symptom, root cause, action taken) are usually empty. As a result, diagnostic knowledge stays with senior technicians and leaves when they do. We present Plant Memory, a system that applies technical language processing (TLP) to SAP Plant Maintenance (PM) exports and builds an ISO 14224-aligned maintenance ontology in which every extracted statement is a reified fact carrying a confidence score, the evidence it was read from, and a verification state. Extraction is rule-first, with an optional large language model (LLM) acting as a second reader whose disagreements raise a fact's review priority rather than overwrite it. Technicians verify facts through a review queue, answer targeted knowledge-gap questions where failures repeat without a recorded cause, and approve or reject ontology drift proposals when new terms appear. The resulting graph is served to people through a web application and to AI agents through a Model Context Protocol (MCP) server, so both query the same verified knowledge and every answer cites the work orders behind it. On a synthetic 12-month export of 400 work orders from a parboiled-rice plant, rule-based extraction reaches 96.2% component accuracy, 88.9% failure-mode accuracy and 100% root-cause precision at 62% coverage; on 28 diagnostic questions, ranked root causes from the ontology are correct at top-1 in 82.1% of cases against 53.6% for the raw SAP root-cause column.

Tue 13 OctArtificial IntelligenceComputation and Language
The gist
Industrial plants keep lots of notes about equipment failures, but these notes are often hard to understand because they use shorthand, misspellings, and inconsistent terms. The authors created Plant Memory, a system that reads these messy maintenance records and turns them into a clean, organized collection of facts with confidence scores and verifications by technicians. This organized knowledge can then be searched by people or AI tools to help diagnose problems more accurately. They show their system works well using real data from a rice plant, improving the accuracy of identifying failure causes compared to raw records.
Open → 2610.19131v1

System one model decisions no longer change with option order

Consider, Then Choose: Order-Invariant Decisions in System One Models

Abstract: System One models answer typed questions in a single forward pass and promise the same answer for the same input. For choice questions, this promise fails: the answer depends on the order of the options, increasingly so as they grow in number, and averaging over their cyclic shifts reduces this dependence without removing it. Scoring each option alone, which the order cannot affect, shows that the order changes the answer mostly when the model is unsure among its top few options, even though the listwise answer looks confident. We therefore propose $\textbf{Runoff}$, which considers, then chooses: it scores each option alone to keep a few candidates, then compares them in listings where each candidate takes every position. It needs no training and can run in two forward passes, and its answer does not depend on the option order by construction. On two open models and five datasets, it changes no answer under shuffling, against 9.3% for cyclic averaging, and with 20 options it is about as accurate and three to four times faster. Wrapped around eight System One models, it removes the order dependence of the five benchmarks, while cyclic averaging changes up to 15.4%.

Tue 13 OctArtificial IntelligenceComputation and Language
The gist
Some AI models answer questions in one shot, promising stable answers. But if the question requires choosing from a list, the model’s answer can change just by reordering the options. The authors find that this happens mostly when the model is unsure among top choices, even if it seems confident overall. They propose a new two-step method called Runoff, which first scores each option individually and then compares top options fairly by varying their order. This approach gives consistent results no matter how options are listed, without retraining the model and at higher speed than previous methods.
Open → 2610.18233v1

Textual reinforcement learning improves large language model decision context

TextualRL: Textual Reinforcement Learning for Context Management

Abstract: LLM agents can adapt to task feedback by revising the textual context that guides their behavior, without changing their model parameters. However, turning execution rewards into reusable context updates is challenging: individual trajectories offer limited comparative evidence about what to change, while task-specific fixes may overgeneralize when incorporated into a shared context. We introduce TextualRL, a gradient-free reinforcement learning framework that treats a group of rollouts from the same task under the same context, rather than an isolated trajectory, as the unit of policy critique. Groupwise Policy Critique contrasts successful and failed rollouts within a task; when outcomes are uniform, it draws on cross-task evidence to identify behaviors worth preserving or formulate repair hypotheses. Cross-Group Policy Update reviews the resulting proposals against evidence pooled across groups, including observations that yield no proposed edit, to refine their content and applicability. Reviewed proposals form a bounded textual patch, with adoption of the candidate context determined by held-out validation rewards. Together, these components establish a reward-driven policy optimization loop in which multiple attempts jointly inform reusable context updates. We evaluate TextualRL with five target agents on six benchmarks. Averaged over the six benchmarks, TextualRL improves test accuracy over the base model by 24.4 and 15.3 percentage points for GPT-5.5 and Qwen3.8-27B, respectively.

Tue 13 OctComputation and LanguageArtificial Intelligence
The gist
Large language models (LLMs) can improve how they complete tasks by changing the text they use to guide themselves, instead of changing their own brains. But it’s hard to know exactly what text to change just by looking at individual attempts, which might not show the full picture. The authors developed TextualRL, a method that looks at groups of attempts together, compares successes and failures, and uses evidence from many tasks to find helpful text changes. Their approach updates the guiding text in a way that leads to better task performance. Tests showed significant accuracy improvements in multiple models and benchmarks.
Open → 2610.18216v1

Language models learn to reason better by copying thought patterns

Facts Don't Speak Louder than Words: The Behavioral Essence of Long-CoT Distillation

Abstract: While long chain-of-thought (CoT) distillation significantly improves the reasoning abilities of language models, its underlying mechanism remains poorly understood. Current pipelines generally rely on rejection sampling to gather reasoning traces across diverse prompts, assuming that factual correctness and broad problem coverage are indispensable. Surprisingly, we find that training exclusively on flawed reasoning trajectories or a restricted prompt set yields nearly comparable performance. Driven by this counterintuitive finding, we propose the Behavioral Hypothesis: the essence of Long-CoT distillation is behavioral alignment with structured reasoning patterns, rather than factual knowledge memorization. We then validate this by demonstrating substantial reasoning gains even when models are fine-tuned exclusively on previously mastered problems-effectively isolating behavioral alignment from novel knowledge injection. Having established that reasoning patterns are the true bottleneck, we investigate how to learn them across varying levels of complexity optimally. We reveal a critical interplay: while the recent probability-based loss excels at learning simple patterns, the standard cross-entropy loss is essential for scaling to complex CoTs. We believe these insights demystify CoT distillation and provide a principled foundation for the future development of reasoning models. Code is available on https://github.com/yuyongcan/Long-CoT-Distillation.

Tue 13 OctComputation and Language
The gist
Improving how language models solve problems often involves teaching them to think through steps carefully. This paper finds that focusing on mimicking the way models structure their reasoning—not just on factual correctness—leads to better results. The authors showed that even training on imperfect answers or repeated problems helps models get better at reasoning. They also discovered that different training methods work better depending on how complex the reasoning steps are. This work helps explain how teaching models to reason really works.
Open → 2610.17607v1

Open language models match and surpass specialized AI decision systems

Releasing the Inner Jev: A Simple Recipe for Open Decision Models

Abstract: LLM-based decision-making systems, also called System One models, have recently gained popularity, most notably through Jev (Almeida, 2026). Given a typed input state, a question, and a set of options, they return a probability for each option in a single forward pass, without text generation. We show that existing open instruction-tuned language models can achieve comparable performance \textit{without any additional training}, by reading out answers from letters (A, B, C, etc.) in the model's output logits at the last token position. Furthermore, we show how a simple supervised fine-tuning recipe can improve their performance further. We evaluate four open instruction-tuned language models: Gemma 4 31B, Gemma 4 12B, Qwen3.6-27B, and Qwen3.5-4B. We fine-tune each using LoRA and a decision head initialized from a slice of the language model head. Furthermore, we introduce OpenDecisions, a novel 2,352-question validation dataset designed to reflect the task composition of JevBench (JevBench main- tainers, 2026) and which computes a Capability score based on accuracy and calibration metrics. Without fine-tuning, Gemma 4 31B scores 79.6 on OpenDecisions, compared to Jev's 80.1. After undergoing our fine-tuning recipe, it scores 84.4 on OpenDecisions and 81.5 on JevBench v1.7, outperforming Jev by 4.3 and 4.4 Capability points respectively and setting a new state-of-the-art on OpenDecisions. On a suite of public decision datasets, our models achieve accuracy comparable to Jev, with lower calibration error. Our results show that open language models already possess System One capabilities, and with simple fine-tuning they outperform Jev on a wide range of decision tasks. We release our models, serving code, and OpenDecisions.

Mon 12 OctArtificial Intelligence
The gist
Making decisions based on language models is growing popular thanks to systems like Jev. The authors show that some open-source language models can already make these decisions well without extra training by reading letter choices directly from their outputs. With a simple kind of tuning, these models get even better than Jev at picking correct options, as tested on new and existing decision tasks. They also provide a new dataset that helps measure how good these decision systems really are. The authors share their tuned models, code, and the dataset to help others build better decision-making AI.
Open → 2610.17205v1

Hallucination detection challenges in tool-augmented language models

ToolHACE: A Dataset for Detecting Hallucinations in Tool-Based LLM Responses

Abstract: Tool-augmented language models ground their responses in external tool outputs, improving reliability beyond parametric knowledge alone. However, even when the correct tool is called and returns accurate information, models may still contradict such outputs, omit critical details, or generate unsupported claims. Existing hallucination benchmarks for tool-augmented dialogue primarily focus on the tool-calling stage, evaluating whether the correct tool and arguments are selected, while overlooking errors that arise during post-tool response generation. To address this gap, we introduce ToolHACE, a span-level benchmark for hallucination detection in tool-augmented LLM responses, covering five fine-grained hallucination categories. Through extensive experiments with modern hallucination detectors, we show that post-tool-call hallucinations are widespread and remain challenging to detect. Our results further demonstrate that effective detection requires training on specialized tool-augmented corpora, while transfer from tool-agnostic hallucination datasets performs poorly in this setting. These findings highlight the need for dedicated benchmarks and models for reliable hallucination detection in tool-augmented language systems.

Mon 12 OctComputation and Language
The gist
Language models that use external tools can improve accuracy by checking facts, but they sometimes still make mistakes even after using the tools. The authors introduce a new dataset called ToolHACE that helps find these specific mistakes in the responses generated after the tool is used. Their experiments show these errors are common and hard to catch without training on similar data. The study points out the need for specialized tools to detect these hallucinations properly.
Open → 2610.17125v1

Semantic grounding transforms test-time discovery into interpretable concepts

Relational Semantic Grounding for Test-Time Discovery

Abstract: Test-Time Discovery (TTD) aims to recognize known classes and detect novel ones from a continuous unlabeled test stream after deployment. Existing TTD methods mainly rely on visual clustering or prototype comparison, and can only assign anonymous labels to discovered classes, leaving them difficult to interpret in open-world applications. In this paper, we propose SEGA, a Semantic Grounding with Attributes framework for TTD. SEGA leverages large language models to generate attribute-rich descriptions for known classes and constructs an attribute-anchored visual-semantic space during training. At test time, we introduce Relational Semantic Grounding (RSG), which grounds unknown samples with similar and dissimilar known-class anchors, prompts the LLM to generate candidate concepts, and reranks them in the learned semantic space. The selected concept is further used for confidence-guided test-time semantic stabilization. By coupling attribute-level semantic alignment with relational concept grounding, SEGA transforms anonymous test-time clusters into interpretable semantic concepts. Experiments show that SEGA improves TTD baselines with the promise of semantic grounding for open-world.

Sat 10 OctArtificial Intelligence
The gist
Sometimes machines see new things they weren’t trained on and only group them without naming them. The paper’s authors created a method that uses language models to describe known objects with meaningful features, then helps the system give names to new categories when they appear. This means the machine can explain new things it finds in words we understand, instead of just saying 'new group one' or 'new group two.' Their approach improves how well machines identify and explain things in the real world after they start working.
Open → 2610.14721v1

Method helps AI forget specific knowledge and admit what it does not know

Decoupling Knowledge Forgetting and Refusal Learning in MLLM Unlearning

Abstract: Current evaluations of multimodal unlearning typically focus on whether a model stops outputting target information. This surface-level criterion, however, masks two critical failure modes. First, knowledge suppression techniques often induce confabulation, leading the model to hallucinate facts about the unlearned subject. Second, refusal training merely alters observable behavior without erasing the underlying knowledge; such models might decline open queries but still identify correct answers under multiple-choice probing. To overcome these limitations, we propose Forget-Aware Self-Distillation (FASD). This method is designed to achieve honest ignorance, a state where the model genuinely loses the target knowledge and learns to acknowledge its absence. FASD separates these goals into two complementary channels. The behavior channel distills appropriate refusals from an ignorance-prompted copy of the model itself. Crucially, target tokens are masked from the teacher distribution to avoid accidentally reteaching the forgotten concepts. Simultaneously, the knowledge channel directly suppresses ground-truth answer spans independently of the model's generated responses. Experiments demonstrate that FASD successfully unlearns target knowledge, prevents information leakage in open-ended tasks, and preserves performance on retained data. The resulting model not only forgets the specified information but accurately recognizes the boundaries of its own knowledge. Code and data will be released upon publication.

Sat 10 OctArtificial IntelligenceComputation and LanguageInformation Retrieval
The gist
AI models sometimes need to forget certain information, but simply blocking answers can make them guess wrong or hide knowledge without truly forgetting it. The authors created a method called Forget-Aware Self-Distillation that helps AI not only lose specific facts but also honestly say it doesn’t know them. This approach uses two parts: one that teaches the AI to refuse to answer and another that removes the actual knowledge inside it. Their tests show the AI forgets correctly and avoids lying or guessing when asked about the forgotten topics.
Open → 2610.14605v1

X-AgentRed improves detection of harmful cross-service agent actions

X-AgentRed: Red-Teaming Personal Agents in Evolving Multi-Service Ecosystems

Abstract: Personal agents increasingly connect to services across the web and applications by using tools. As the effects of their actions accumulate and interact across services, unintended or harmful outcomes can arise when agents fulfill benign user requests. Proactively identifying these compositional failures requires systematically exploring diverse cross-service paths. Existing red-teaming methods often simply prompt LLMs to identify potentially harmful paths from task and environment descriptions or decompose harmful objectives specified by humans or LLMs into seemingly benign action combinations. However, generation is biased toward patterns learned during training, potentially favoring familiar tool combinations and leaving novel cross-service interactions underexplored. To address this, we propose X-AgentRed, a self-evolving red-teaming framework that discovers harmful tool call paths through a graph of tool dependencies and expands and refines them using execution feedback. By analyzing each tool's effects, potential harms, and preconditions for execution, the red-teaming agent constructs a directed graph that captures how one tool's effects can satisfy another's execution preconditions. Recipes sampled from this graph are instantiated as realistic scenarios in which agents can produce harmful outcomes. Execution feedback enables self-improvement by diversifying paths that produce harm through tool substitution and refining preconditions at blocked steps in unsuccessful paths to enable further execution. Across four frontier agentic models, X-AgentRed achieves $1.77\times$ the harmful path rate of STAC and explores a more diverse set of tools, yielding $2.99\times$ the tool coverage on average.

Fri 9 OctArtificial Intelligence
The gist
Personal AI agents use many online tools to help users, but sometimes they cause harm unintentionally when using multiple services together. The authors developed X-AgentRed, a system that finds risky chains of tool actions by building a map of how tools connect and testing different paths to find problems. It improves itself by learning from test results to try new tool combinations and fix blocked paths. This approach uncovers more diverse and harmful scenarios compared to previous methods.
Open → 2610.13886v1

Contextual correction speeds up parallel language model drafting by over six times

Contextual Correction of Parallel Draftsfor Speculative Decoding

Abstract: Speculative decoding accelerates large language model inference by using a lightweight drafter to propose multiple tokens that are subsequently verified in parallel by the target model. Recent diffusion-based drafters make this paradigm particularly attractive: deep attention-based neural backbones provide strong predictions, while drafting multiple future positions in parallel avoids the sequential cost of autoregressive generation. This parallelism, however, comes at a cost. Tokens within a draft block are predicted without access to the realized identities of preceding draft tokens, removing intra-block dependencies that would naturally be available under autoregressive generation. We introduce DCOCO (DFlash Contextual Corrector), a lightweight mechanism that restores these dependencies while preserving parallel drafting. Rather than committing to each position's top prediction, DCOCO retains multiple candidate tokens and evaluates their contextual compatibility across adjacent draft positions in parallel, enabling contextually informed token selection at low additional cost. Across four verifier backbones and ten benchmarks, DCOCO achieves the highest average throughput in every evaluated configuration, spanning greedy and stochastic decoding with and without extended reasoning, with speedups of up to 6.6x over vanilla decoding. Its advantage persists under concurrent serving: DCOCO outperforms the strongest competing method by 6-23% across 4-32 concurrent requests, while other sequential correctors fall below uncorrected DFlash at these loads. These results demonstrate that recovering intra-block dependencies through parallel contextual scoring delivers consistent acceleration across decoding regimes and serving loads.

Thu 8 OctComputation and Language
The gist
Large language models often generate text one word at a time, which can be slow. Some methods speed this up by guessing multiple words ahead but lose some accuracy because these guesses don’t consider the words just predicted. The authors present a method called DCOCO that checks and corrects these guesses all at once by looking at possible word combinations in context. This approach keeps the speed benefits while improving accuracy, making language model text generation much faster without losing quality. They tested it on many tasks and models and found it consistently faster than previous methods.
Open → 2610.12570v1

Split training improves vision and language reasoning accuracy

SPLIT-RL: Staged Perception-Language Reasoning Training with Claim-Level Advantages

Abstract: Vision-Language (VL) reasoning requires a model to both extract relevant and accurate information from an image (visual reasoning, VR), and to infer the answer from it (language reasoning, LR). Reinforcement learning with verifiable rewards typically trains both through a single chain-of-thought with a final-answer reward. This gives every CoT token the same sequence-level advantage, failing to distinguish capability specific errors. We propose SPLIT-RL, a staged post-training approach that trains VR and LR in disjoint phases. Because a group's rollouts differ along one capability at a time, the group-relative advantage isolates it, and each phase is optimized using phase-specific reward. We further introduce Claim-Level Advantage (CLA-GRPO), which decomposes VR-phase rollouts into atomic visual claims and provides a fine-grained advantage at claim level based on visual-type group formation. Although trained in two phases, trained policy is evaluated like GRPO model, with a single CoT call at inference time. Under this protocol, SPLIT-RL improves average accuracy over GRPO by 1.4-6.1 points across Qwen3-VL models from 2B to 30B-A3B and InternVL3.5-8B. Evaluating each capability using an oracle based diagnostic shows that answer-only GRPO leaves perception unchanged, whereas SPLIT-RL improves both VR and LR.

Wed 7 OctComputer Vision and Pattern Recognition
The gist
Understanding questions about pictures needs two key skills: seeing the important parts in the image, and using language to figure out answers. The authors show that training these skills separately with tailored rewards, instead of all at once, makes the system better at both seeing and reasoning. Their method, called SPLIT-RL, breaks down visual claims to give clearer feedback during training. This results in more accurate answers when the model is tested.
Open → 2610.10889v1

Compact language models improve reasoning through teacher feedback loops

Collaborative Reasoning Distillation via Cross-Feedback and Coherent Curation

Abstract: Reasoning capabilities are critical for advancing Large Language Models, yet current approaches either require massive computational budgets or struggle to effectively distill reasoning to smaller models. Standard distillation methods rely on outcome-based rewards, failing to distinguish between sound reasoning and lucky guesses. We propose Collaborative Reasoning Distillation (CRD), a framework that enhances reasoning in compact models through three innovations: (1) interactive cross-feedback where teachers iteratively critique each other's reasoning, (2) fine-grained step-wise quality assessment capturing logical validity independent of final answers, and (3) coherence-aware step stitching that synthesizes complementary strengths. Students are trained via Reasoning Quality Optimization (RQO) with budget constraints. Our model, CRD-4B, achieves 97.3% on MATH-500 and 70.3% on AIME'25, surpassing baselines while using only 50K training examples, up to 12 times smaller than the datasets of comparable models.

Wed 7 OctMachine LearningArtificial IntelligenceComputation and Language
The gist
It’s hard to teach smaller language models to think logically without guessing right answers by chance. The authors present a new way where large models act as teachers and critique each other’s reasoning steps, helping the smaller model learn better logical thinking step-by-step. This method also combines teacher strengths to create clear reasoning and trains smaller models efficiently with limited examples. The result is a small model that solves difficult math problems better than previous compact models.
Open → 2610.09587v1

Large language models sometimes give another state’s policy value

Right Number, Wrong State? Measuring Cross-Jurisdiction Substitution in LLM Recall of State Policy

Abstract: When an LLM answers a state-specific policy question wrongly, it may be hallucinating, or it may be returning a real value that holds in another state. We test this with a minimal-set design: the question wording is fixed and only the jurisdiction varies, across the 50 U.S. states and the District of Columbia (51 jurisdictions) and three exactly defined Medicaid income-eligibility quantities. Gold values come from an official data book and agree with an independent source in 101 of 102 checked cells. Under a pre-registered protocol, Claude Sonnet 5.5 and GPT-5.6 Sol reproducibly give another state's current value, identical across two independent repeats, for 10 and 25 of 153 items. Attribution is fragile, however. Crediting any wrong answer that equals another state's value yields 3-5x more reproducible substitutions than checking every number in the asked state's own records, because many apparent cross-state answers are the asked state's own values under another convention or from an earlier year. Claims about cross-jurisdiction error need a complete same-state reference set. We will release the protocol, gold table, and all model outputs.

Wed 7 OctComputation and Language
The gist
When a large language model (LLM) answers questions about state-specific policies, it can sometimes give a number that is correct but for the wrong U.S. state. The authors tested this across all states for specific Medicaid income eligibility numbers. They found that LLMs like Claude Sonnet 5.5 and GPT-5.6 Sol often repeat values from different states instead of making up numbers, but identifying these swaps is tricky because sometimes the same state’s data appears under different formats or years. So, careful comparison with a complete reference for each state is needed to understand these errors.
Open → 2610.09458v1

Vision language models reduce object hallucination with hidden state rotation

ROT: Rotating Hidden States towards Contextual Vectors for Hallucination Mitigation in LVLMs

Abstract: Large Vision-Language Models (LVLMs) frequently suffer from object hallucination. Existing training-free interventions primarily manipulate attention weights, which indirectly affect the deep semantics reaching the final predictive layers. In this work, we shift our focus to the hidden state vectors extracted after self-attention and residual addition. Empirical analysis reveals that hallucinated tokens do not simply over-rely on linguistic priors; instead, they exhibit an anomalous contextual deviation, showing significantly lower similarities to both textual and visual contexts in intermediate layers. Motivated by this, we propose ROT, a layer-specific, training-free framework. ROT dynamically detects semantic deviation in the middle layers and applies a norm-preserving rotation to steer the hidden states back toward the local multimodal context plane spanned by the contexts. For subsequent layers, a representational smoothing mechanism is introduced to stabilize the calibrated trajectory. Extensive experiments on multiple benchmarks demonstrate that ROT consistently reduces hallucinations across various model architectures and scales, offering an efficient, geometry-driven solution for grounded generation.

Mon 5 OctComputer Vision and Pattern RecognitionArtificial IntelligenceComputation and Language
The gist
Sometimes vision-language AI models mistakenly say they see objects that aren’t really there. This paper finds that such mistakes come from hidden data in the model's middle layers not matching visual or text clues properly. The authors propose ROT, a method that gently rotates these hidden data points to better align with the visual and textual context. This approach helps the model avoid hallucinations without extra training, improving accuracy in identifying objects.
Open → 2610.06056v1

Text to image models steer clear of unsafe content during creation

Safe Image Generation via Reinforcement Learning

Abstract: Recent Text-to-Image (T2I) models achieve remarkable visual image generation performance, but they can still generate NSFW (Not-Safe-For-Work) contents, including violent or explicit images. Existing safety checker mechanisms are largely confined to pre-generation filtering (e.g. prompt-level text classifiers) or post-hoc moderation applied after an image is completely synthesized. However, adversarial attack methods operate over a much broader space. This imbalance highlights the need for a safety mechanism that intervenes during the generation process. We propose an in-generation safety framework that monitors the denoising trajectory and detects emerging NSFW signals from intermediate representations. Rather than merely detecting NSFW generations, our method applies reinforcement learning to generate safe images from NSFW prompts. By coupling in-generation detection with controllable steering, our approach mitigates unsafe trajectories even when NSFW signals emerge after generation has already begun. Experiments results show that our method consistently outperforms existing safe image generation methods across both standard and adversarial evaluation sets, while preserving perceptual quality and prompt fidelity. Code will be released upon acceptance.

Mon 5 OctComputer Vision and Pattern Recognition
The gist
Some AI tools that generate images from text can accidentally create pictures that are violent or inappropriate. The paper’s authors developed a new approach that watches the image while it’s being made and changes it if it starts to look unsafe. Instead of just checking the text before or the final image after, their method uses a kind of trial and error learning to keep images safe as they form. This way, even tricky cases where unsafe content appears late in creation can be caught and fixed.
Open → 2610.05908v1

Budget adaptive prompt optimizer improves language model performance with fewer calls

How Should a Prompt Optimizer Spend a Tight Budget? BudgetAPO with Noise-Adaptive Evaluation

Abstract: Automatic prompt optimization (APO) has been widely employed to adapt large language models without updating their weights, yielding promising results. However, existing methods such as GEPA and OPRO assume hundreds to thousands of subject-model calls, far more than is practical behind paid, rate-limited APIs. Under tight budgets they fail in two ways: multi-stage pipelines can exhaust the budget and return the seed prompt unchanged, while single-stage methods compare candidates on fixed-size minibatches, regardless of each task's noise. As a remedy, we introduce BudgetAPO, a single-stage optimizer for the tight-budget regime. BudgetAPO incorporates (1) a noise-adaptive rule that sizes the evaluation slice to each task's noise, measured by a short probe; (2) a fixed slice that turns every accept/reject decision into a paired comparison; and (3) a reflective operator that rewrites reasoning strategy and output format jointly. Extensive results across seven benchmarks and five subject models demonstrate that BudgetAPO ranks first on every subject and beats every baseline under Holm-corrected paired tests, while returning the seed in 13% of runs at 250 calls against 86% for GEPA. On GPT-OSS-20B, GEPA needs 4.5 times as many calls to match BudgetAPO's 100-call score.

Mon 5 OctArtificial Intelligence
The gist
Optimizing prompts for large language models usually requires many tries, which is expensive and slow. The authors found that existing methods waste their limited budget by either using complex steps or fixed evaluations that don't account for noise in the tasks. They created BudgetAPO, a system that adjusts how much testing it does based on how noisy a task is and makes decisions more efficiently. This lets it improve prompts reliably using far fewer calls to the language model, making it practical behind paid APIs.
Open → 2610.05671v1

Self improving code modules boost agent performance and lower costs

MESH-Harness: Self-Improving Agent Harnesses via Bandit-Guided Compositional Evolution

Abstract: An agent harness is the code that organizes context, maintains state, and coordinates tool calls for a language model. We study how to improve the harness under a limited evaluation budget while keeping model weights fixed. Our method, MESH-Harness, organizes each harness into functional modules with explicit role-specific interfaces, allowing alternative implementations of each module to be substituted and recombined. It uses shared module representations and full-covariance LinUCB to score candidate combinations based on predicted performance and exploration value. Mixed-start coordinate ascent selects complete configurations for evaluation without enumerating the combinatorial space. Validation traces then guide local code edits, and the resulting candidates are incorporated into fixed-capacity role-specific pools for subsequent recombination. On text tasks, retrieval-augmented mathematical reasoning, code generation, and interactive scientific tasks, MESH-Harness outperforms Meta-Harness by 5.70, 7.01, 2.00, and 5.00 points, respectively, under matched candidate-evaluation budgets. Iterative harness optimization improves MESH-Harness by 5.63-7.79 points over its first-round configurations. For the reported configurations, aggregate test-time cost is 44.2% lower than that of Meta-Harness, while total cost including search is 14.6% lower. These results show that combining module-level design reuse with feedback-driven compositional search can systematically improve agent harnesses while keeping overall optimization cost under control.

Sun 4 OctArtificial Intelligence
The gist
Some AI programs work better when their toolbox and control code are organized well. The authors show a way to improve this control code—called an agent harness—by mixing and matching small parts and trying out new versions smartly, without changing the AI’s inner brain. They use a method that predicts which changes will work best and tests them efficiently. Their approach leads to better results on tasks like math problems, coding, and interactive science, while also saving time and resources.
Open → 2610.05300v1

Dynamic agent systems improve task accuracy and efficiency per query

Dynamic Harness Search: Building Multi-Agent Systems Per-Query via Prediction

Abstract: Agent harnesses specify the roles, instructions, tools, and communication structure used to solve a task, and the right harness depends on the query. Because the value of each design choice is observable only through execution, tailoring a harness to each query has required either executing alternatives at inference time or costly manual design. We introduce SHIFT, which moves execution out of the per-query search loop. A local LLM architect learns a policy over harness-building actions from search, and a value function that predicts, from measured executions, a utility balancing accuracy against execution cost. For each query, Monte Carlo tree search uses these predictions to construct a harness. Across 9,193 tasks in six benchmarks, from math to document and general-assistant tasks, with a Gemini 3.5 Flash executor, SHIFT attains the highest mean accuracy, about 80%, outperforming 17 baselines that span prompting, prompt optimization, and workflow search, and exceeding the strongest baseline by 7.2 percentage points. A cheaper mode of SHIFT also attains a higher mean accuracy than every baseline while using 32% fewer execution tokens than the strongest baseline. We further show that choosing structure, instructions, and tools jointly beats choosing only instructions or only tools by up to 9.1 percentage points, and that learned value selection identifies more accurate harnesses with lower execution cost from candidate pools.

Fri 2 OctMachine Learning
The gist
Solving complex tasks with multiple AI agents usually requires setting up roles and tools carefully, which can be slow or need lots of trial and error. This paper presents SHIFT, a method that learns from past attempts to predict the best way to organize these agents for each new task, speeding up the process without testing many options each time. By using predictions, SHIFT builds customized setups that work better and use fewer resources than previous methods on thousands of tasks.
Open → 2610.04137v1

Large language models show knowledge access depends on query geometry

The Geometry of Knowledge Accessibility in Large Language Models

Abstract: Large language models (LLMs) contain broad knowledge, but they cannot access all of it reliably. We study this problem through knowledge accessibility, which describes whether the knowledge needed for a query can be recalled from the model. We find that knowledge accessibility has a simple geometric structure in the model's representation of the query alone, before any generation. More accessible queries are closer to a center in the representation space, while less accessible queries are farther away. This geometry reveals a knowledge boundary that separates more accessible queries from less accessible ones. Accessibility consistently decreases with distance from the center, and this distance-based ordering transfers across datasets even when the centers differ. Controlled experiments further show that the centered geometry is more closely related to knowledge accessibility than to reasoning difficulty. The geometry also reveals when different interventions are useful. Query rewriting helps more for accessible queries, chain-of-thought reasoning helps more near the boundary, and retrieval gives larger gains beyond the boundary. These findings not only provide a new geometric view of how knowledge is organized in language models, but also suggest a useful pre-generation signal for adaptive inference.

Fri 2 OctComputation and Language
The gist
Large language models hold lots of information but don’t always find what you ask for reliably. The authors discovered that the way a question is represented inside the model forms a shape where easier questions are near a center point and harder ones are farther away. This shape helps predict how well the model can access knowledge before it starts answering. Different strategies improve answers based on where a question lies in this space, offering ways to make smarter use of models.
Open → 2610.03052v1

HyperThink speeds up multi-step reasoning in large language models

HyperThink: Text-to-Parameter Hypernetworks for Efficient Reasoning

Abstract: Long-form thinking traces can substantially improve the multi-step reasoning performance of large language models (LLMs), but they introduce high inference-time overhead, with latency dominated by sequential decoding. We propose HyperThink, a text-to-parameter approach that amortizes this reasoning computation into a single query-conditioned parameter update: a lightweight hypernetwork reads the question and predicts updates to a small subset of the base LLM's parameters, while a vector-quantized decoder constrains them to a finite set of reusable patterns to improve robustness and transfer. Trained end-to-end on outputs from the base model itself, HyperThink eliminates long thinking traces at test time: after one hypernetwork forward pass, the adapted model generates a concise step-by-step solution and final answer without an intermediate trace, using far fewer tokens while retaining strong reasoning performance. Empirically, HyperThink improves the low-latency region of the accuracy-latency trade-off on mathematical and general reasoning tasks, with its strongest gains in the near-non-thinking regime.

Fri 2 OctComputation and LanguageMachine Learning
The gist
Reasoning through complex problems with large language models usually takes a long time because they think step-by-step slowly. The authors created HyperThink, a system that quickly adjusts a small part of the model based on the question, so it can give a detailed answer fast without showing all the steps. This makes the model faster at reasoning while keeping its accuracy. HyperThink learns by looking at the normal model’s answers but uses fewer words and less time when actually solving problems.
Open → 2610.03039v1

Acmite reduces gender bias in language models using concept guidance

Acmite: Mitigating Gender Bias in LLMs through Concept-Guided Mutual Information

Abstract: Large language models (LLMs) can reproduce social stereotypes from their training data, motivating extensive research on model debiasing. However, existing methods often rely on explicit biased examples or predefined group-term substitutions, making them sensitive to wording and less effective at capturing stereotype concepts shared across diverse contexts. More importantly, they typically suppress biased outputs without explicitly modeling the statistical dependence between model outputs and the underlying stereotype concepts. We propose Acmite, a lightweight concept-guided framework for targeted and selective debiasing. Acmite represents stereotypes as structured semantic concepts and uses maximal marginal relevance (MMR) to select diverse concepts for debiasing. Inspired by mutual information minimization, it approximates this dependence with token-level KL divergence while preserving task semantics. A lightweight LoRA adapter is trained with the base model frozen and activated at inference time only when the input is sufficiently similar to stereotype-related concepts; otherwise, the original model is used directly. We evaluate Acmite on BBQ, CrowS-Pairs, and StereoSet, and assess general capability preservation on ARC-Challenge, GSM8K, and PIQA. Experiments across three LLMs show that Acmite effectively mitigates gender bias across complementary evaluation formats while maintaining competitive performance on bias-unrelated tasks. Anonymous code and data are available at https://anonymous.4open.science/r/Acmite-18E2/.

Thu 1 OctComputation and Language
The gist
Large language models sometimes repeat unfair gender stereotypes from the data they learned from. The authors propose Acmite, a method that identifies the ideas behind stereotypes as concepts and reduces their influence without changing unrelated parts of the model. Acmite works by training a small addition to the model that only activates when the input is close to stereotype concepts, helping the model avoid bias while keeping it accurate on other tasks. Tests show Acmite effectively lowers gender bias and maintains overall performance.
Open → 2610.01696v1

Vision language models improve understanding of negation questions

Skeleton-and-Strategy Prompting: Training-Free Negation Understanding for Vision-Language Models

Abstract: Despite the strong performance of Vision-Language Models (VLMs) on a wide range of visual question answering (VQA) tasks, these models consistently struggle to understand negation and produce incorrect answers when questions involve negated clauses. To address this limitation, we propose Skeleton-and-Strategy Prompting (\textbf{SSP}), a training-free, in-context learning method that improves VLM negation understanding capabilities without any parameter updates. Given a negation question, our method first abstracts the underlying question structure into a skeleton, retrieves a small set of same-skeleton questions from a lightweight question pool, then prompts the VLM to analyze their shared negation pattern and synthesize a single-sentence answering strategy. The skeleton and strategy are prepended to the test sample to guide the model correctly tackle the negation problems. Experiments on multiple negation VQA benchmarks show that SSP achieves state-of-the-art performance on negation-focused VQA tasks while remaining computationally efficient.

Thu 1 OctComputer Vision and Pattern Recognition
The gist
Vision-language models are good at answering many visual questions but have trouble with questions that involve negation, like 'What is not in the picture?'. The authors introduce a new method called Skeleton-and-Strategy Prompting (SSP) that helps these models understand negation without any extra training. SSP works by breaking down the question into a basic structure, finding similar questions, and then teaching the model a simple way to answer negation questions. Tests show this method improves the model’s accuracy on negation tasks efficiently.
Open → 2610.01180v1

New method balances learning new skills and keeping old AI abilities

PG-SFT: Balancing Capability Acquisition and Retention in Offline Agent Fine-Tuning

Abstract: Supervised fine-tuning (SFT) on offline agent trajectories is the standard approach for training specialized tool-using agents, but forcing models to imitate reasoning and actions token by token may harm other capabilities (e.g., general reasoning, tool calling, code generation) of the base model. In this work, we focus on studying \emph{how to better balance the trade-off between acquiring new capabilities and preserving existing ones during agent trace SFT}. By comparing several baselines in our setup, standard SFT improves the target benchmark while lowering several non-target benchmark scores; meanwhile, simply constraining distributional drift using KL penalty or limiting the update magnitude did not avoid this regression trend. Motivated by recent token-wise adaptive learning objectives, this work proposes \textbf{Privilege-Guided SFT (PG-SFT)} to leverage turn-level information gain of agent trajectories as an indicator to adjust supervision strength. PG-SFT yields a more favorable observed trade-off on the evaluated benchmarks, substantially reducing distributional drift and broad capability degradation at the cost of slight degradation in target-task performance. Our findings suggest that balancing the acquisition--retention trade-off depends not only on whether the model is anchored to its base behavior, but also on where and how strongly supervision should depart from that behavior.}

Thu 1 OctArtificial Intelligence
The gist
When training AI agents by showing them examples of how to do specific tasks, the AI can get better at those tasks but lose some of its other useful skills like general reasoning or code generation. The authors studied how to better keep the AI’s original abilities while still learning new tasks. They found that a method called Privilege-Guided SFT uses information about how valuable each part of a training example is to adjust learning strength, helping the AI keep more of its old skills while improving on new ones. This approach slightly reduces performance on the new task but better preserves broad AI abilities.
Open → 2610.00949v1

Multi-path reasoning improves large language model answers with smarter voting

Diversity Combining for Multi-Path LLM Reasoning

Abstract: Multi-path reasoning methods such as self-consistency (SC) sample $K$ reasoning paths and choose the most frequent answer. However, their gains quickly plateau as $K$ increases, and existing methods do not predict when this saturation will occur. We formalize multi-path LLM reasoning as a diversity combining problem from wireless communications: each path is a noisy channel observation, and the pairwise correlation of path correctness caps the design-effect effective sample size of the vote at a finite ceiling. Generalized least squares (GLS) analysis shows that, under exchangeability, the optimal symmetric linear combiner of latent embeddings is uniform, supporting majority vote as the natural default in standard SC while leaving room for weighting or pruning under heterogeneous prompt-template branches. Across 5 models and 12 benchmarks, prompt-template diversity reduces path correlation in $55$ of $57$ valid cells, with the strongest effect on open-ended QA. We derive an Adaptive-K rule that uses a four-path pilot to select $K^*$, retaining $96$--$103\%$ of MV@$K{=}32$ accuracy across Math, QA, and NLU.

Wed 30 SeptArtificial Intelligence
The gist
When large language models solve problems by generating multiple answers, simply picking the most common answer stops improving results after a while. The authors compare this to combining noisy signals and show that correlations between answer paths limit how much improvement you can get. They develop a method to predict the best number of answers to use, keeping accuracy high without wasting time on too many attempts. Their approach works well across different models and question types.
Open → 2609.38829v1

Prompt2Skill improves task solving by building skills from instructions

Prompt2Skill: Unsupervised Skill Optimization From Natural Language Instructions

Abstract: Skills are external artifacts that Large Language Models (LLMs) consume at inference time to improve their performance on specialized domains by incorporating relevant procedural and domain knowledge. Expert-authored skills are expensive to produce, and the resulting artifacts are not optimized for the specific model that consumes them, whose failure modes can vary with version, scale and training. In addition, emerging tasks may fall outside the scope of existing skill libraries, creating a need to develop new skills before curated training data become available. Recent works have explored automated skill optimization through reflection, but they require a curated, in-distribution training set, which users might not always have. To address these limitations, we present Prompt2Skill, a framework that builds skills from natural-language task description alone. From the prompt, the system derives a task specification, discovers or synthesizes datasets, and refines the skill in a closed loop of reflective editing. Across four domains spanning question answering, reading comprehension, spreadsheet manipulation, and mathematical reasoning, Prompt2Skill consistently outperforms the direct prompting baseline, achieving an average improvement of 10.8 across open-source and frontier models.

Tue 29 SeptComputation and LanguageArtificial Intelligence
The gist
Many AI models rely on special skills, which are like step-by-step guides, to do tricky tasks better. Writing these skills by hand is costly and often not perfectly matched to each AI model. The authors created Prompt2Skill, a way for AI to build and improve these skills all by itself from just a description of the task. It works better than just giving the AI direct instructions, across different kinds of tasks like math or answering questions.
Open → 2609.38593v1

Capfield-opd enables smooth control of multiple capabilities in ai models

CapField-OPD: Learning Continuous Capability Fields via Joint-Anchored Multi-Teacher On-Policy Distillation for Flow Models

Abstract: Reward-specialized post-training produces strong experts for flow-based generative models, while multi-teacher on-policy distillation (OPD) consolidates their capabilities into a single student. Existing methods, however, route each prompt to a single teacher according to its semantic category, implicitly binding the desired capability to prompt content. This coupling makes capability invocation vulnerable to prompt perturbations and prevents users from explicitly adjusting the strength of the desired capability at inference time. In this work, we introduce CapField-OPD, an OPD framework that integrates multiple teachers into a continuous capability field through explicit capability coordinates. We use teacher models as anchors to construct this field, with the coordinates determining how their outputs are combined. Each capability configuration thus receives a unique supervision target, and capability control no longer depends on prompt semantics. Since the training anchors may not be optimal at inference time, we further profile the learned field on a small calibration set. The coordinate with the highest mean reward serves as the recommended default, while coordinates that are frequently optimal offer a promising candidate set for test-time scaling. Extensive experiments on compositional generation, text rendering, and visual aesthetics demonstrate that CapField-OPD consolidates multiple specialized teachers into a single student while preserving or surpassing their performance, reliably invokes the desired capabilities under semantics-preserving prompt variations, and supports continuous capability control and coordinate-based test-time scaling.

Mon 28 SeptComputer Vision and Pattern Recognition
The gist
AI models often learn specialized skills from different teachers, but switching between these skills usually depends on specific words or prompts, which can cause errors if the prompts change slightly. This paper introduces a new method that combines multiple specialized AI teachers into one model, allowing users to smoothly control and adjust the model's skills by using coordinates instead of relying on exact prompt wording. This approach makes the model more reliable and flexible when performing tasks like creating images or rendering text.
Open → 2609.34658v1

Initial user input guides autonomous deep research outcomes clearly

What Happens During Autonomous Deep Research After the User Steps Away?

Abstract: In autonomous deep research, a user provides a task and relevant background, then leaves the agent to conduct an extended investigation without further human intervention. We study how this initial user information is reflected in intermediate actions and how these actions relate to final recommendations. We introduce DRaligned, a counterfactual behavioral evaluation framework built on PDR-Bench. By varying one task-relevant user factor while keeping the remaining context fixed, we compare acquisition requests, working drafts, and final reports. Source-grounded extraction, blinded local judgments, and deterministic aggregation yield coarse directional measurements while leaving ambiguous cases unresolved. Our experiments show that strong user-specific delivery can emerge from a largely shared research process: agents investigate similar broad questions but allocate requests differently, and final recommendations distinguish user conditions more clearly than explicit requests do. Reports can also integrate user factors that were not jointly visible during acquisition. In readable draft-to-report comparisons, recommendations often retain their coarse user-specific direction despite substantial rewriting. Final directional differences recur across tested agent models, execution harnesses, and evaluator models, even as execution paths vary. These findings describe how initial user information shapes autonomous research and clarify the relationship between the process an agent follows and the recommendations it delivers.

Sun 27 SeptArtificial Intelligence
The gist
When users give an AI system a research task and then step away, the system keeps working on its own to complete the job. This paper studies how the initial instructions influence what the AI investigates and the final advice it provides. The authors found that even though the AI explores similar topics, it tailors its requests and final reports based on who gave the instructions. The research shows that the process and final answers stay aligned with the initial user’s needs, even if some parts change during the investigation.
Open → 2609.33509v1

Calibrating reasoning models improves confidence estimates greatly

Calibration, Not Answer Selection: Distilling Internal Confidence in Reasoning Models

Abstract: Reinforcement learning with binary correctness rewards trains correctness, not calibrated confidence. The confidence that reasoning models verbalize is systematically overconfident, and the problem is not merely one of scale: verbalized confidence tracks how willing a model is to commit to an answer, not how likely the answer is to be right. Post-hoc rescaling therefore fits one distribution but rarely transfers. We look inside the model instead. On factual question answering, a linear probe on the hidden state between the chain of thought and the answer is substantially better calibrated: its expected calibration error is 5 to 38 times lower than that of the verbalized score across four benchmarks and two model families. However, when used to pick among N sampled answers, that same probe nearly ties majority voting yet falls far short of the oracle. Internal states answer "how certain am I" well and "which answer is right" poorly, so the signal should be reported as a confidence rather than used to select answers. As a result, we introduce probe-guided self-distillation (Probe-SD): score a model's own sampled traces with the probe, overwrite the confidence each trace states, and finetune the base checkpoint of the same family, so nothing but the model itself remains at test time. On Qwen3-14B, Probe-SD cuts ECE from 0.178 to 0.024 in-domain and from 0.542 to 0.113 out-of-domain, where it also beats post-hoc recalibration and self-consistency distillation. The resulting confidence is well-calibrated and useful for weighted voting, behaviors previously attributed to online RL, here obtained with supervised finetuning alone.

Sun 27 SeptComputation and Language
The gist
Models that answer questions often say how confident they are, but this confidence is usually too high and doesn't match the true chance of being right. The authors found a better way to measure confidence by checking the model’s internal reasoning steps, which gives more accurate confidence levels. They also developed a method to teach the model to trust this better confidence measure, improving its predictions without needing complex new training techniques. This helps models not just pick answers, but also know how sure they should be about them.
Open → 2609.33290v1

Large language models improve reasoning by optimizing skills prompts and routing

Beyond Prompt or Skill? Attribution-Guided Optimization of Modular LLM Programs

Abstract: Large language models can solve increasingly diverse reasoning tasks, yet their performance remains highly sensitive to task prompts, intermediate instructions, and the way reusable problem-solving knowledge is incorporated. Existing optimization methods usually focus on only one part of this design space: they either optimize a monolithic prompt, or separately induce and refine skills from model traces. As a result, they lack a principled mechanism for deciding which component should be updated when failures occur, and they rarely optimize prompts, skills, and skill-use policies in a unified framework. We propose SPARO (Skill, Prompt, And Routing Optimization), a framework that jointly optimizes task instructions, reusable skill blocks, and routing rules. It performs controlled counterfactual evaluations, converts examples' effects into a probabilistic responsibility distribution over prompt, skill, and routing components, samples one component from that distribution, and applies the corresponding targeted mutation. This design moves language-program optimization beyond global prompt rewriting toward structured, reusable, and selectively activated task knowledge. Across five benchmarks and five worker models, SPARO consistently outperforms both prompt-centered and skill-centered optimization baselines. These results suggest that effective language-program optimization depends not only on discovering useful task knowledge, but also on deciding where that knowledge should be stored and when it should be activated.

Sat 26 SeptArtificial Intelligence
The gist
Language models can solve many tasks, but how you tell them what to do and which parts of their knowledge to use is very important. The researchers introduce a method called SPARO that improves language model programs by adjusting task instructions, reusable skills, and how the model chooses which skills to use. This method figures out which part to change when the model makes mistakes and updates that part to do better next time. Their tests show this approach works better than just changing the instructions or skills alone.
Open → 2609.32492v1

Large language models improve skills by fixing mistakes locally

A Wrong Turn Does Not Ruin the Journey: Deviation-Guided Skill Self-Evolution for LLM Agents

Abstract: Large language model agents increasingly rely on natural-language skills to solve complex tool-use tasks. However, such tasks often admit multiple valid solution paths, making it inappropriate to improve skills by forcing failed trajectories to match a fixed successful trajectory. Moreover, failed trajectories are rarely entirely wrong: an agent may first collect useful evidence and make meaningful progress, but later deviate into an erroneous suffix. We therefore argue that skill self-evolution should identify where productive problem solving begins to break down, rather than reflect coarsely over the entire failure. Based on this insight, we propose SkillPivot, a deviation-point-guided framework for skill self-evolution. SkillPivot detects the transition from a useful prefix to an erroneous suffix using execution validity, goal progress, and action diversity. A stronger teacher then continues from the same prefix and produces a successful alternative under the same interaction history. By contrasting the student's failed suffix with the teacher's successful suffix, SkillPivot generates localized skill updates while preserving already effective guidance. Experiments on ToolQA, LogicBench, and WildClawBench show that SkillPivot consistently outperforms competing skill-evolution methods, improves multiple agent models, and produces compact, transferable skill updates.

Thu 24 SeptArtificial Intelligence
The gist
Complex tasks can often be done in many right ways, so forcing a language model to copy one fixed correct solution doesn’t help it learn well. The authors found that even when a model’s attempt fails, it often makes good progress before going off track. They developed SkillPivot, which identifies where the model’s reasoning starts to fail and then uses a stronger model to fix just that part. This focused approach helps the model improve without losing what it already does correctly.
Open → 2609.29154v1

Policy distillation improves reinforcement learning outcomes beyond initial accuracy

RL Starts before RL: On Policy Distillation for Better Reinforcement Learning

Abstract: Reinforcement learning (RL) improves reasoning, but its performance depends on the policy from which training begins. We study on-policy distillation (OPD) as a preparation stage for RL and ask whether its benefits extend beyond improvements in the distilled model's initial accuracy. Under shared RL settings, students initialized with OPD reach higher final performance than those trained with direct RL or supervised fine-tuning followed by RL. This advantage can emerge even when OPD produces little immediate improvement in accuracy. Pre-RL Pass@k does not fully explain the benefit: similar or even higher values do not necessarily lead to better performance after RL. Behavioral analyses point to alignment with the teacher's distribution beyond top-1 agreement as a possible explanation. Such alignment may favor higher-quality reasoning paths while retaining alternatives that RL can further refine using outcome feedback. We further examine how trajectory sources and divergence objectives affect the value of distillation for subsequent RL. Standard reverse-KL OPD performs better before RL, but forward-KL OPD overtakes it afterward; with teacher-generated distillation trajectories, reverse KL remains ahead at both stages. These findings suggest that the preferred distillation objective depends on both the trajectory source and the training that follows. Our results support evaluating OPD as preparation for RL and selecting distillation choices by the performance achieved after subsequent training.

Wed 23 SeptMachine Learning
The gist
Reinforcement learning (RL) helps machines learn by trial and error, but it matters which starting point you choose. The authors studied a way to prepare for RL called on-policy distillation (OPD), where a student learns from a teacher’s behaviors before actual RL training. They found that starting with OPD can lead to better final performance, even if it doesn’t improve the student’s accuracy right away. This improvement might come from the student better matching the teacher’s range of good behaviors, giving RL more options to improve upon.
Open → 2609.28145v1

Planned test-time scaling improves reasoning task performance with coordinated problem solving

Planned Test-Time Scaling with Coordinated Reasoning Paths

Abstract: Test-time scaling with parallel branches is widely adopted to improve performance on challenging reasoning tasks. The predominant approach, repeated sampling, draws branches independently from a single policy, which can produce redundant attempts and thereby limit the gains from additional inference compute. To address this limitation, we propose Planned Test-Time Scaling (PTTS), which replaces independent sampling with a coordinated joint policy: a planner generates a solution outline for each branch, steering the branches toward distinct reasoning paths, and an executor produces a full solution conditioned on each outline. Formally, we show that PTTS strictly generalizes repeated sampling and, in a stylized setting, provably promotes coverage of complementary reasoning modes and yields better pass@k scaling. We instantiate PTTS on top of strong reasoning models, keeping them fixed as executors while replacing repeated sampling with PTTS inference to further enhance test-time scaling. Concretely, we develop two variants: PTTS-ZS prompts a model to jointly generate outlines for all branches in a single autoregressive pass, while PTTS-RL directly optimizes the planner against the pass@k reward using truncated execution rollouts for efficient training and a sharper reward signal. Across five mathematical reasoning benchmarks with Qwen3-1.7B and 4B, PTTS-ZS improves pass@64 over repeated sampling by up to 6.7 points, while PTTS-RL further increases the gain to up to 13.4 points. Further analysis indicates that broader coverage of distinct reasoning paths contributes to these gains. Overall, PTTS provides a general framework for improving test-time scaling by coordinating reasoning branches, with zero-shot and trainable instantiations that yield substantial performance gains.

Wed 23 SeptComputation and LanguageArtificial Intelligence
The gist
When computers try to solve hard problems, they often try many guesses at once to find answers. The authors show that making these guesses work together, instead of independently, helps the computer explore different kinds of solutions better. They created a new method called Planned Test-Time Scaling (PTTS) that first plans different outlines for each guess and then completes each one. This approach improves success rates on math reasoning tests by encouraging diverse ways of thinking. It works both without extra training and with training to get even better results.
Open → 2609.27374v1

Vision language models lose accuracy when image layout changes

Reading Right, Answering Wrong: How Visual Configuration Changes Affect Evidence Use in VLMs

Abstract: Vision-language models (VLMs) have achieved strong performance on tasks such as visual question answering, yet small image resizes can turn correct answers into errors. We investigate whether changes in visual configuration, such as image tiling and token arrangement, contribute to this instability. Across seven checkpoints and four benchmarks, equally small resizes cause more correctness flips when they switch configurations. Surprisingly, in over half of these cases, models answer the question incorrectly but can still read the correct answer when told what to read. Furthermore, attention interventions in LLaVA-NeXT suggest that configuration changes can weaken the use of readable information during answering. We therefore guide models using field cues and their own transcriptions. With annotation assistance, these forms of guidance together correct 97.2% of errors with readable information. These findings show that configuration changes can affect how models use information they can still read.

Tue 22 SeptComputer Vision and Pattern Recognition
The gist
Vision-language models can answer questions about images well, but small changes in how the image is arranged can cause these models to give wrong answers. The authors found that even when the model reads the correct answer in the image, it sometimes fails to use that information correctly because the way the image is shown has changed. They showed that by helping the model focus on the right parts of the image or text, most of these errors can be fixed. This means changing the image layout affects how well the model uses the information it can actually see.
Open → 2609.25770v1

SkillAA improves AI skill updating with precise graph-based editing

SkillAA: Attribution-Guided Skill-Graph Updating with Targeted Validation and Rollback

Abstract: External skills provide domain procedures without parameter updates, but existing methods often edit skills directly from failed rollouts without structured routing from an observed failure to an editable location; existing skill graphs also underuse semantic boundaries, object addresses, and topological dependencies for skill retrieval, targeted updating, and scoped validation. We introduce SkillAA (Skill Abductive Attribution), a structured skill-optimization framework for frozen language models. It represents skill applicability, execution, and composition in a unified graph, allowing the same structure to support skill selection, attribution-guided repair, and update validation. SkillAA contrasts successful and failed executions to route candidate repairs to specific graph objects, updates only the selected local structure, and uses Local and Big Gates to screen candidate changes before commitment. With gpt-5.6-sol, SkillAA reaches 81.5%, 66.7%, and 91.2% on SearchQA, LiveMath, and DocVQA, respectively, and attains the highest observed mean in every main setting. These results support the utility of attribution-guided graph editing and graph-scoped validation.

Thu 17 SeptArtificial Intelligence
The gist
AI systems often use fixed skills to perform tasks, but fixing errors in those skills can be tricky and inefficient. The researchers created SkillAA, a method that uses a detailed graph to represent skills and how they connect, allowing the system to locate the exact part that caused a failure and update only that part. This makes AI skill updates more accurate and reliable. Testing with a powerful language model showed SkillAA achieves high success rates on several question-answering tasks.
Open → 2609.20455v1

Visual grounding improves with confidence awareness to reduce hallucinations

SAVOR: Self-Aware Visual Grounding via Confidence-Calibrated Reinforcement Learning for Multimodal Hallucination Mitigation

Abstract: Multimodal large language models (MLLMs) have made strong progress on visual question answering and image captioning, yet they still produce fluent claims about objects, attributes, or relations that are not grounded in the image. Many remedies either modify decoding at test time, which adds latency, or fine tune with preferences such as DPO variants, which teach which answer is preferred but not when the model's own answer is unreliable. We argue that calibrated self assessment is the missing signal. We introduce Savor, a training framework that (i) augments the output schema with token and answer confidence, (ii) optimises the policy with a Group Relative Policy Optimisation (GRPO) objective that penalises calibration error and poor abstention decisions, and (iii) uses the learned confidence at inference time to revisit visual evidence only when the model is uncertain. Experiments on POPE, HallusionBench, AMBER and MMHal-Bench across two recent backbones (InternVL3-8B and Qwen3-VL-8B) show that Savor reduces hallucination while preserving general capability on MME and MMBench, with lower Expected Calibration Error than DPO and decoding baselines.

Tue 15 SeptComputer Vision and Pattern Recognition
The gist
Multimodal large language models sometimes make confident but incorrect claims about images, describing things that aren’t really there. The authors found that teaching these models to be aware of their own confidence helps them avoid making false statements. They created a training method called Savor that lets the model judge when it is uncertain and look again at the image before answering. This approach reduces mistakes while keeping the model’s overall ability to understand images and text.
Open → 2609.16601v1