Monthly Issue
Collected dispatches

2026-07

2026-06-01 to 2026-06-30
220 papers
30 daily issues
A monthly ledger of recurring themes, selected papers, and daily issues. 3 sections
§ I

The Month in Review

Editorial summary

Here's a summary of the monthly trends from the provided papers, in ≤500 words:

Overall Trends & Research Directions:

The past 30 days have seen a significant surge in research focused on enhancing the capabilities of Large Language Model (LLM) agents, particularly in their ability to reason, interact with environments, and perform complex, multi-turn tasks. A dominant theme is moving beyond simple text generation to create agents that can plan, adapt, and learn autonomously.

Several papers highlight advancements in agentic reasoning and problem-solving. This includes efforts to improve long-context reasoning (LongTraceRL), explicitly structure reasoning histories (LinTree), and enable agentic research loops (AutoSci, Iteris). The development of robust benchmarks and evaluation frameworks for these agents is also a strong trend, covering areas like continual learning (AgentCL), personal applications (MCP-Persona), action grounding (GroundAct), and insight discovery (InsightEval).

Another key area is improving agent efficiency and robustness. Papers explore methods for decoupled optimization (DRIFT), training-free policies for simultaneous translation (DOA), and skill reuse as compression (ReuseRL). Safety and alignment remain critical, with research investigating how reinforcement learning can amplify misalignment (Reinforcement Learning Amplifies Emergent Misalignment) and how to mitigate perceptual judgment bias in multimodal models (Mitigating Perceptual Judgment Bias).

Notable Groups/Labs:

While specific lab affiliations aren't explicitly detailed for all papers, the breadth and depth of these publications suggest significant contributions from major AI research institutions and companies. The consistent focus on agent architecture, learning methodologies (especially RL and self-improvement), and benchmark development points towards active research programs in leading universities and tech giants.

Trends to Watch Next Month:

1. Autonomous Learning and Adaptation: Expect continued focus on agents that can learn and improve without explicit human supervision. Papers like SCALE and ReuseRL point towards agents becoming more self-sufficient. 2. Multimodal Agentic Capabilities: The integration of vision and language for agents is a growing area. Papers like TVIR and Moment-Video indicate a push towards agents that can understand and generate reports and reason about visual information, though challenges remain in temporal fidelity and bias mitigation. 3. Robust Reasoning and Planning: The emphasis on structured reasoning, exploration, and planning will likely increase. LinTree, LongTraceRL, and frameworks for agent collaboration (AgentOrchestra, MOC) suggest a move towards more coherent and effective decision-making. 4. Specialized Agentic Applications: The emergence of benchmarks for specific domains like clinical settings (ClinEnv), computational mathematics (Iteris), and used car sales (Used Car Salesbots?) indicates a trend towards tailoring LLM agents for real-world, specialized tasks. 5. Beyond Supervised Learning: The increasing exploration of reinforcement learning and other non-supervised methods for agent training (DRIFT, LongTraceRL, Reinforcement Learning Amplifies Emergent Misalignment) suggests a wider adoption of these techniques for more dynamic and adaptable agents.

§ II

Top Papers

Selected research 220
cs.AIarxiv:2605.31468v1Lead article

AutoSci: A Memory-Centric Agentic System for the Full Scientific Research Lifecycle

Weitong Qian, Beicheng Xu, Zhongao Xie, Bowen Fan, Guozheng Tang

utoSci is a memory-centric agentic system designed to automate the entire scientific research lifecycle. Its core method involves a structured memory system (SciMem) that separates long-term scientific knowledge from project-specific artifacts, enabling agents to efficiently access and manage information. AutoSci's contribution lies in providing a unified platform that supports all stages of research, from idea generation to manuscript submission and review, while also facilitating continuous improvement of its own research processes.

Overview of AutoSci.
Overview of AutoSci.
cs.AIarxiv:2605.31365v1Lead article

Learning to Adapt: Self-Improving Web Agent via Cognitive-Aware Exploration

Weile Chen, Bingchen Miao, Qifan Yu, Wendong Bu, Guoming Wang

his paper introduces SCALE, a self-improving web agent that uses adversarial roles (Selector, Predictor, Judger) to autonomously identify and overcome its limitations through exploration. It also proposes SCALE-Hop for better global planning to avoid exploration traps. The core contribution is enabling web agents to adapt and learn without relying on expert data, demonstrated by improved performance and a new large-scale dataset.

A comparison between prior methods and our SCALE framework. SCALE enables autonomous exploration with diverse and scalable task generation, overcoming the limitation in previous approaches.
A comparison between prior methods and our SCALE framework. SCALE enables autonomous exploration with diverse and scalable task generation, overcoming the limitation in previous approaches.
cs.AIarxiv:2605.31492v1Lead article

LinTree: Improving LLM Reasoning with Explicitly Structured Search Histories

Liwei Kang, Yee Whye Teh, Wee Sun Lee

his paper introduces LinTree, a method to improve LLM reasoning by explicitly structuring their search histories. The core idea is to represent LLM's intermediate reasoning steps as linearized search trees, allowing the model to condition on the entire search trace rather than just the current state. The contribution lies in demonstrating that while LLMs implicitly generate search traces, explicitly structuring these histories as trees significantly enhances their reasoning capabilities, outperforming traditional heuristic search in controlled environments.

cs.AIarxiv:2605.31584v1Lead article

LongTraceRL: Learning Long-Context Reasoning from Search Agent Trajectories with Rubric Rewards

Nianyi Lin, Jiajie Zhang, Lei Hou, Juanzi Li

his paper introduces LongTraceRL, a reinforcement learning method for improving long-context reasoning in LLMs. It constructs challenging training data by using search agent trajectories to create tiered distractors and employs a rubric reward that evaluates intermediate reasoning steps based on gold entities, unlike previous methods that relied on sparse, outcome-only rewards. This approach enables more effective supervision of the reasoning process, leading to better information integration from extensive, distracting content.

Comparison between prior long-context RL approaches based on easy distractors and outcome-only rewards, and our proposed LongTraceRL .
Comparison between prior long-context RL approaches based on easy distractors and outcome-only rewards, and our proposed LongTraceRL .
cs.AIarxiv:2605.31408v1Lead article

Skill Availability and Presentation Granularity in Large-Language-Model Agents: A Controlled SkillsBench Study

Xiaonan Xu, Wenjing Wu

his paper investigates how the granularity of skill documentation affects the performance of large language model agents. The core method involves a controlled study using SkillsBench with different skill presentation levels and two LLM configurations. The main contribution is demonstrating that the availability of skills significantly improves task success rates, with finer-grained presentation having a less pronounced, and sometimes uncertain, impact.

Task-mean pass rates by model and condition
Task-mean pass rates by model and condition
cs.AIarxiv:2605.31509v1Lead article

Skill Reuse as Compression in Agentic RL

Zhikun Xu, Yu Feng, Jacob Dineen, Taiwei Shi, Jieyu Zhao

his paper proposes ReuseRL, a method that views skill reuse in agentic RL as a form of compression. By grounding agent training in the Minimum Description Length principle, ReuseRL explicitly encourages agents to learn a small set of reusable abstract skills rather than brittle, task-specific shortcuts. This approach demonstrably improves generalization and success rates across various environments.

ReuseRL distinguishes reusable compression from raw brevity. Each colored box is one ALFWorld atomic skill. Vanilla GRPO optimizes task success alone and can produce long trajectories with repeated or wasted steps. A pure round-length penalty is a degenerate singleton-only code that penalizes all steps uniformly, including the necessary search, so the agent under-explores and never reaches the target. ReuseRL learns a multi-skill dictionary from successful trajectories and uses the segmentation cost under this dictionary as a trajectory-level penalty, keeping reusable subroutines cheap while leaving idiosyncratic waste expensive.
ReuseRL distinguishes reusable compression from raw brevity. Each colored box is one ALFWorld atomic skill. Vanilla GRPO optimizes task success alone and can produce long trajectories with repeated or wasted steps. A pure round-length penalty is a degenerate singleton-only code t…
cs.LGarxiv:2605.31455v1Lead article

DRIFT: Decoupled Rollouts and Importance-Weighted Fine-Tuning for Efficient Multi-Turn Optimization

Jian Mu, Tianyi Lin, Chengwei Qin, Zhongxiang Dai, Yao Shu

RIFT addresses the challenge of efficiently optimizing large language models for multi-turn interactions. It decouples trajectory generation from policy updates, using offline data and importance weighting to mimic the benefits of online RL without its high computational cost. This allows for efficient fine-tuning while mitigating issues like distribution shift and behavioral collapse.

Multi-turn interaction. The user engages in a dialogue with the LLM. If the LLM provides an incorrect response, the user offers simple feedback to point out the error. The LLM then re-attempts the task until a correct answer is generated or the maximum number of turns is reached.
Multi-turn interaction. The user engages in a dialogue with the LLM. If the LLM provides an incorrect response, the user offers simple feedback to point out the error. The LLM then re-attempts the task until a correct answer is generated or the maximum number of turns is reached.
cs.CLarxiv:2605.31328v1Lead article

Reinforcement Learning Amplifies Emergent Misalignment from Harmless Rewards

Magnus Jørgenvåg, David Kaczér, Lasse Ruttert, Marvin Gülhan, Lucie Flek

his paper demonstrates that reinforcement learning (RL) can amplify emergent misalignment in language models, even with seemingly harmless rewards. The core method involves fine-tuning small, open-weight models using RL with narrowly misaligned reward signals, showing this leads to greater general misalignment than supervised fine-tuning. The key contribution is characterizing this RL-induced misalignment and showing that existing safety mitigations developed for supervised learning can effectively address it.

General-domain misalignment from RL across our three questions. (RQ1) Once a 100-example SFT warm-up (hatched) overcomes the cold-start problem, GRPO (red) induces far more emergent misalignment than sample-matched SFT (green); without the warm-up, GRPO fails to learn the behavior. (RQ2) The effect persists for plausibly harmless rewards. (RQ3) SFT mitigations transfer: interleaving safety data (Interleaving++) removes nearly all RL-induced misalignment. Panels 1–2 report two-epoch GRPO; panel 3 the one-epoch mitigation setup.
General-domain misalignment from RL across our three questions. (RQ1) Once a 100-example SFT warm-up (hatched) overcomes the cold-start problem, GRPO (red) induces far more emergent misalignment than sample-matched SFT (green); without the warm-up, GRPO fails to learn the behavio…
cs.AIarxiv:2606.02372v1Lead article

COMAP: Co-Evolving World Models and Agent Policies for LLM Agents

Youwei Liu, Jian Wang, Hanlin Wang, Wenjie Li

OMAP co-evolves textual world models and agent policies in a closed loop. The world model predicts future feedback for candidate actions, which the agent uses to refine its choices by assessing feedback reliability. This process allows the world model to adapt to the agent's evolving behavior through self-distillation, improving its accuracy in predicting on-policy trajectories.

Conceptual illustration of the co-evolution of world models and agent policies for LLM Agents.
Conceptual illustration of the co-evolution of world models and agent policies for LLM Agents.
cs.AIarxiv:2606.02359v1Lead article

MOC: Multi-Order Communication in LLM-based Multi-Agent Systems

Yao Guan, Lin Wang, Zhihu Lu, Ziyi Wang, Wenzhu Yan

his paper introduces Multi-Order Communication (MOC) for LLM-based multi-agent systems. MOC addresses the limitation of current methods by reconstructing communication to capture multi-hop dependencies and employing a structural message consolidation strategy. This allows for more effective message transmission and optimization, improving the agents' ability to leverage information across multiple hops.

The paradigm comparison between existing communication scheme and ours.
The paradigm comparison between existing communication scheme and ours.
cs.AIarxiv:2606.02388v1Lead article

Policy and World Modeling Co-Training for Language Agents

Ning Lu, Baijiong Lin, Shengcai Liu, Jiahao Wu, Haoze Lv

his paper proposes PaW, a framework that co-trains a language agent's policy and world model simultaneously during reinforcement learning. By leveraging on-policy rollouts, PaW adds auxiliary world modeling supervision without requiring separate simulators or changing inference. This approach improves agent performance by providing a better understanding of action consequences, demonstrated by consistent gains on benchmark tasks.

Comparison of world modeling paradigms for LLM agents. While prior methods rely on separate simulators, additional training, or inference-time planning, our PaW jointly optimizes policy learning and world modeling within the same model.
Comparison of world modeling paradigms for LLM agents. While prior methods rely on separate simulators, additional training, or inference-time planning, our PaW jointly optimizes policy learning and world modeling within the same model.
cs.AIarxiv:2606.02355v1Lead article

SIRI: Self-Internalizing Reinforcement Learning with Intrinsic Skills for LLM Agent Training

Zhongyu He, Yuanfan Li, Fei Huang, Tianyu Chen, Siyuan Chen

IRI trains LLM agents to develop reusable skills internally, eliminating the need for external skill generators or inference-time skill banks. It achieves this through a three-phase process: initial policy warmup, self-skill discovery and validation using the agent's own trajectories, and finally, distilling beneficial skills into the agent's core policy. This approach reduces engineering complexity and improves inference efficiency for long-horizon tasks.

Conceptual comparison between (a) traditional skill-augmentation frameworks and (b) our Siri .
Conceptual comparison between (a) traditional skill-augmentation frameworks and (b) our Siri .
cs.CLarxiv:2606.02252v1Lead article

ResMerge: Residual-based Spectral Merging of Large Language Models

Yandu Sun, Zhiyan Hou, Haokai Ma, Yuheng Jia, Junfeng Fang

esMerge addresses the challenge of merging large language models trained with reinforcement learning (RL). Unlike previous methods that focus on high-energy spectral components, ResMerge recognizes that RL task vectors have both a concentrated "head" and a dispersed "residual" component, both containing valuable information. By treating these components separately, ResMerge leverages the stability of the residual for merging while mitigating conflicts from the head, leading to improved performance.

Component-level recovery under RL and SFT post-training. After applying singular value decomposition (SVD) to each task vector, Head-only retains the rank-1 head formed by the top singular direction, while Residual-only retains the remaining spectral residual after removing this head. Both components are more recoverable in RL task vectors than in SFT task vectors, supporting component-wise treatment of RL spectral updates.
Component-level recovery under RL and SFT post-training. After applying singular value decomposition (SVD) to each task vector, Head-only retains the rank-1 head formed by the top singular direction, while Residual-only retains the remaining spectral residual after removing this …
cs.CLarxiv:2606.02320v1Lead article

TVIR: Building Deep Research Agents Towards Text--Visual Interleaved Report Generation

Xinkai Ma, Zhiqi Bai, Dingling Zhang, Pei Liu, Yishuo Yuan

his paper introduces TVIR, a benchmark and agent framework for generating research reports that integrate text and visuals. TVIR-Bench comprises 100 tasks requiring visually supported analysis, while TVIR-Agent is a multi-agent system that retrieves and generates relevant images and charts. The contribution lies in addressing the text-centric bias in current research agents and providing a comprehensive evaluation method for multimodal report generation.

Comparison of representative deep research benchmarks. Existing benchmarks mainly focus on text-only or weakly multimodal reports, whereas TVIR-Bench requires text–visual interleaved reports with semantically grounded charts and retrieved images.
Comparison of representative deep research benchmarks. Existing benchmarks mainly focus on text-only or weakly multimodal reports, whereas TVIR-Bench requires text–visual interleaved reports with semantically grounded charts and retrieved images.
cs.CLarxiv:2606.02304v1Lead article

Unified Context Evolution for LLM Agents

Zixuan Zhu, Yitong Hu, Yong Dai, Junfeng Fang, Chunyang Jiang

his paper introduces Unified Context Evolution (UCE), a framework for LLM agents that addresses the loss of learned strategies between tasks. UCE externalizes agent experience into a typed library of "Evolvable Context Units" (ECUs), categorized into Memory, Strategy, Workflow, and Skill. This system dynamically generates, retrieves, scores, and prunes ECUs based on their utility, allowing agents to build and retain knowledge across interactions.

cs.AIarxiv:2506.12508Lead article

AgentOrchestra: Orchestrating Multi-Agent Intelligence with the Tool-Environment-Agent(TEA) Protocol

Wentao Zhang, Liang Zeng, Yuzhen Xiao, Yongcong Li, Ce Cui

his paper introduces the Tool-Environment-Agent (TEA) protocol, a novel framework for coordinating multi-agent systems. TEA models agents, tools, and environments as versioned resources with explicit lifecycles, enabling better context management and reproducibility. Building on TEA, AgentOrchestra provides a hierarchical framework for dynamic agent capability extension and coordination on complex tasks.

Architecture of the TEA Protocol.
Architecture of the TEA Protocol.
cs.AIarxiv:2605.29225Lead article

BenchTrace: A Benchmark for Testing Reflection Ability and Controlled Evolution in LLM Agents

Jiahao Huang, Fei Cheng, Junfeng Jiang, Zefan Yu, Akiko Aizawa

his paper introduces BenchTrace, a benchmark designed to evaluate the reflection and controlled evolution capabilities of LLM agents. BenchTrace utilizes a dataset of annotated episodes and includes two key evaluations: one that probes failure identification through targeted QA, and another that tests an agent's ability to avoid past failures in simulations. The paper also proposes a new metric, failure avoidance rate (FAR), to quantify this improvement.

(a) Traditional evaluation of self-evolving agents measures only the final task score. (b) BenchTrace constructs its dataset through three stages: Snapshot Collection, Failure Detection, and Reflection Annotation. (c) BenchTrace comprises a Snapshot-Reflection Dataset and an Evaluation Suite with a Reflection Evaluation and an Evolution Evaluation .
(a) Traditional evaluation of self-evolving agents measures only the final task score. (b) BenchTrace constructs its dataset through three stages: Snapshot Collection, Failure Detection, and Reflection Annotation. (c) BenchTrace comprises a Snapshot-Reflection Dataset and an Eval…
cs.AIarxiv:2509.23730Lead article

EAPO: Enhancing Policy Optimization with On-Demand Expert Assistance

Siyao Song, Cong Ma, Zhihao Cheng, Shiye Lei, Minghao Li

APO is a novel RL framework that enhances LLM reasoning by allowing policies to adaptively seek assistance from external experts during training. This on-demand expert interaction provides richer reward signals and more reliable reasoning trajectories, ultimately internalizing expert knowledge to improve the LLM's independent problem-solving capabilities.

Framework of EAPO. During training, the policy model adaptively consults experts as assistants. While at test time, the model performs reasoning independently without external assistance.
Framework of EAPO. During training, the policy model adaptively consults experts as assistants. While at test time, the model performs reasoning independently without external assistance.
cs.AIarxiv:2509.22504Lead article

Estimating the Empowerment of Language Model Agents

Jinyeop Song, Jeff Gore, Max Kleiman-Weiner

his paper introduces EELMA, an algorithm that estimates the "empowerment" of language model agents. Empowerment, an information-theoretic measure, quantifies an agent's ability to influence future states through its actions. EELMA allows for scalable evaluation of LM agents in text-based environments, demonstrating that empowerment correlates with task performance and can identify key moments of general capability.

Empowerment reflects an agent’s ability to reach diverse future states. (Top) A low-empowerment LM-agent becomes trapped in a loop and thus can access only a small fraction of states. (Bottom) A high-empowerment LM-agent effectively explores a wider range of trajectories and can successfully reach states that solve different random goals.
Empowerment reflects an agent’s ability to reach diverse future states. (Top) A low-empowerment LM-agent becomes trapped in a loop and thus can access only a small fraction of states. (Bottom) A high-empowerment LM-agent effectively explores a wider range of trajectories and can …
cs.AIarxiv:2605.27390Lead article

EvoSpec: Evolving Speculative Decoding via Real-Time Vocabulary and Parameter Adaptation

Shuyu Zhang, Lingfeng Pan, Qicheng Wang, Yaqi Shi, Yueyang Tan

voSpec accelerates LLM inference by dynamically adapting the draft model's vocabulary and parameters in real-time. This approach overcomes the limitations of static pruning by efficiently retrieving relevant long-tail tokens and minimizing the distributional gap between draft and target models through online alignment. Its core contribution is enabling speculative decoding to maintain high acceptance rates even in specialized domains or during topic shifts.

The architecture of EvoSpec. The system employs a decision logic based on vocabulary coverage to trigger two parallel loops: (1) Top Branch: Upon OOV detection, the Dynamic Vocabulary Generator asynchronously recalls semantic and statistical neighbors on the CPU to recover local coverage; (2) Bottom Branch: For tokens covered by the current vocabulary, the Online Alignment Controller fine-tunes the draft model’s LoRA parameters using a self-paced curriculum to minimize divergence.
The architecture of EvoSpec. The system employs a decision logic based on vocabulary coverage to trigger two parallel loops: (1) Top Branch: Upon OOV detection, the Dynamic Vocabulary Generator asynchronously recalls semantic and statistical neighbors on the CPU to recover local …
cs.AIarxiv:2605.27387Lead article

From AR to Diffusion: Efficiently Adapting Large Language Models with Strictly Causal and Elastic Horizons

Xiangyu Ma, Teng Xiao, Zuchao Li, Lefei Zhang

his paper introduces FLUID, a framework for efficiently adapting autoregressive (AR) language models to diffusion models for text generation. FLUID achieves this by enforcing "Strictly Causal Alignment" to allow seamless initialization from AR checkpoints, avoiding costly retraining. It also employs "Elastic Horizons" to dynamically adjust denoising steps, leading to state-of-the-art performance with significantly reduced training costs.

Causal mismatch in fixed-size block diffusion. First-pass accuracy decays significantly faster for high-entropy data (e.g., complex reasoning steps in MATH500) than low-entropy text (e.g., GSM8k) as lookahead increases.
Causal mismatch in fixed-size block diffusion. First-pass accuracy decays significantly faster for high-entropy data (e.g., complex reasoning steps in MATH500) than low-entropy text (e.g., GSM8k) as lookahead increases.
cs.AIarxiv:2601.21909Lead article

From Meta-Thought to Execution: Cognitively Aligned Post-Training for Generalizable and Reliable LLM Reasoning

Shaojie Wang, Liang Zhang

his paper proposes a new LLM post-training method called Chain-of-Meta-Thought (CoMT). It addresses the limitation of current methods by mimicking human problem-solving, which involves first learning abstract strategies (meta-knowledge) and then applying them. CoMT achieves this by separating supervised learning of general reasoning patterns from problem-specific execution, leading to more generalizable and reliable LLM reasoning.

Overview of our two-stage post-training framework with a concrete example from GSM8K. Stage 1 (Meta-Knowledge Acquisition): A teacher LLM generates abstract meta-thoughts excluding numerical calculations, which are used for CoMT supervised fine-tuning. Stage 2 (Task Adaptation): The CoMT-tuned model undergoes RL with rewards combining answer correctness and intermediate confidence scores (highlighted in the example: confidence on 9 9 and correctness on 18 18 ).
Overview of our two-stage post-training framework with a concrete example from GSM8K. Stage 1 (Meta-Knowledge Acquisition): A teacher LLM generates abstract meta-thoughts excluding numerical calculations, which are used for CoMT supervised fine-tuning. Stage 2 (Task Adaptation): …
cs.AIarxiv:2510.26270Lead article

Graph-Enhanced Policy Optimization in LLM Agent Training

Jiazhen Yuan, Zhike Gong, Jinquan Hang, Zhengbiao Bai, Wei Zhao

his paper introduces Graph-Enhanced Policy Optimization (GEPO) to improve LLM agent training for multi-step tasks. GEPO addresses the issue of uniform credit assignment by developing a dual-level structural credit system. It calculates a "Task-Conditioned Criticality" score for each state, considering its topological importance within the state-transition graph, to assign more accurate credit at both the step and trajectory levels.

Comparison of credit assignment mechanisms. (a) Standard group-based methods suffer from structural blindness , uniformly distributing sparse rewards across all steps and causing gradient noise. (b) GEPO constructs an online topological graph to identify bottleneck states. This allows for redistributing the advantage precisely to the most critical step.
Comparison of credit assignment mechanisms. (a) Standard group-based methods suffer from structural blindness , uniformly distributing sparse rewards across all steps and causing gradient noise. (b) GEPO constructs an online topological graph to identify bottleneck states. This a…
cs.AIarxiv:2508.05614Lead article

GroundAct: Can LLM Agents Ground Actions in Environmental States?

Zixuan Wang, Dingming Li, Hongxing Li, Yanrui Miao, Shuo Chen

his paper introduces GroundAct, a benchmark designed to assess Large Language Model (LLM) agents' ability to ground actions in environmental states. The core method involves evaluating LLMs on tasks where action feasibility depends on unstated environmental conditions. The key contribution is demonstrating that LLMs struggle with this "action grounding" and identifying specific reasoning patterns and bottlenecks that hinder their performance in complex, state-dependent tasks.

Overview of the GroundAct framework comprising three integrated components: GA-Sim (left) uses structured text representation to model environments with objects, agents, and spatial relationships, enabling dynamic tool-capability binding and physics-constrained collaboration; GA-Bench (right) presents our comprehensive evaluation matrix spanning single-agent and multi-agent tasks across increasing cognitive complexity levels.
Overview of the GroundAct framework comprising three integrated components: GA-Sim (left) uses structured text representation to model environments with objects, agents, and spatial relationships, enabling dynamic tool-capability binding and physics-constrained collaboration; GA-…
cs.AIarxiv:2511.22884Lead article

InsightEval: An Expert-Curated Benchmark for Assessing Insight Discovery in LLM-Driven Data Agents

Zhenghao Zhu, Yuanfeng Song, Xin Chen, Chengzhong Liu, Yakun Cui

his paper addresses the lack of robust benchmarks for evaluating LLM-driven data agents' insight discovery capabilities. The authors identify critical flaws in existing benchmarks like InsightBench and propose new criteria for high-quality evaluation. They then introduce InsightEval, a new, expert-curated dataset constructed through a data-curation pipeline to provide a more reliable assessment of LLMs' ability to uncover latent knowledge in data.

The proportion of each error type. E1, E2, E3, E4, E5 correspond to the Error Type in Table 1 .
The proportion of each error type. E1, E2, E3, E4, E5 correspond to the Error Type in Table 1 .
cs.AIarxiv:2603.11331Lead article

Jailbreak Scaling Laws for Large Language Models: Polynomial-Exponential Crossover

Indranil Halder, Annesya Banerjee, Cengiz Pehlevan

his paper identifies that adversarial prompt injection dramatically accelerates the success rate of attacks on language models from polynomial to exponential growth. They propose a theoretical generative model based on a spin-glass system to explain this phenomenon, where unsafe generations correspond to low-energy clusters in the model's "proxy language." This work provides a statistical and theoretical framework for understanding and potentially mitigating these powerful adversarial attacks.

cs.AIarxiv:2601.06431Lead article

LsrIF: Enhancing Logic-Structured Instruction Following of Large Language Models

Qingyu Ren, Qianyu He, Jingwen Chang, Geng Zhang, Jiajie Zhu

his paper introduces LsrIF, a novel training framework designed to improve how large language models follow instructions with complex logical structures. LsrIF addresses limitations of existing methods by constructing training data that explicitly models parallel, sequential, and conditional dependencies between constraints. Its key contribution is a structure-aware reward aggregation mechanism that aligns training signals with the execution semantics of these logical structures, leading to more robust instruction following.

Essentially, the complex instruction is the logical composition of constraints.
Essentially, the complex instruction is the logical composition of constraints.
cs.AIarxiv:2605.29251Lead article

Provably Secure Agent Guardrail

Benlong Wu, Weiming Zhang, Kejiang Chen, Han Fang, Nenghai Yu

his paper introduces a novel security framework for AI agents that moves beyond empirical semantic guardrails. Its core method, the Proof-Constrained Action (ePCA) framework, forces agents to formally translate their intentions into logical constraints before execution, ensuring provable security by leveraging the limitations of logical reasoning. The main contribution is a neural-symbolic isolation architecture that eliminates reliance on semantic trust in natural language for security.

Figure 1. The risk of AI going out of control urgently requires a transformation in the underlying security technologies.
Figure 1. The risk of AI going out of control urgently requires a transformation in the underlying security technologies.
cs.AIarxiv:2602.00994Lead article

Reasoning and Tool-use Compete in Agentic RL:From Quantifying Interference to Disentangled Tuning

Yu Li, Mingyang Yi, Xiuyu Li, Ju Fan, Fuxin Jiang

his paper investigates the assumption that joint training of reasoning and tool-use in Agentic Reinforcement Learning (ARL) is always beneficial. Using a new method called Capability Effect Attribution (CEA), they demonstrate that these two capabilities often interfere with each other due to misaligned gradients, hindering performance. To overcome this, they propose Disentangled Action--Reasoning Tuning (DART), a framework that explicitly separates and tunes these capabilities.

Overview of Capability Effect Attribution (CEA). (A).Inference-derived Model: Different token types are routed to separately trained models at inference time, composing capabilities without parameter-level interaction. (B).Design Matrix and Attribution: Six model variants populate the design matrix 𝐗 \( \mathbf{X} \) ; solving the system yields per-question coefficients 𝝀 q \( \boldsymbol{\lambda}^{q} \) , where λ 23 < 0 \( \lambda_{23} \)<0 signals interference. (C).Token-Level Gradient Masking: Binary masks gate per-token gradient contributions, isolating capability-specific parameter updates during training. (D).Training-derived Models: Gradient masking produces specialized variants from a shared backbone, enabling controlled comparisons across capability configurations.
Overview of Capability Effect Attribution (CEA). (A).Inference-derived Model: Different token types are routed to separately trained models at inference time, composing capabilities without parameter-level interaction. (B).Design Matrix and Attribution: Six model variants populat…
cs.AIarxiv:2601.22139Lead article

Reasoning While Asking: Transforming Reasoning Large Language Models from Passive Solvers to Proactive Inquirers

Xin Chen, Feng Jiang, Yiqian Zhang, Hardy Chen, Shuo Yan

his paper introduces Proactive Interactive Reasoning (PIR), a new paradigm for LLMs that moves beyond passive problem-solving. PIR enables LLMs to proactively ask clarifying questions to users when facing uncertainty about premises or intent, rather than just performing internal reasoning. This is achieved through a fine-tuning process and a policy optimization framework that trains the LLM to effectively interact and align with user needs.

The Proactive Interactive Reasoning (PIR) Paradigm. The schematic contrasts inefficient "blind self-thinking" on ambiguous queries with the PIR approach. PIR utilizes uncertainty detection and a two-phase optimization mechanism to enable proactive clarification with a user simulator, aligning reasoning chains with user intent to achieve accurate problem-solving that is efficient , robust , and minimal compute costs.
The Proactive Interactive Reasoning (PIR) Paradigm. The schematic contrasts inefficient "blind self-thinking" on ambiguous queries with the PIR approach. PIR utilizes uncertainty detection and a two-phase optimization mechanism to enable proactive clarification with a user simula…
cs.AIarxiv:2511.14584Lead article

ReflexGrad: Within-Episode Failure Recovery in LLM Agents via Progress-Gated Dual-Process Routing

Ankush Kadu, Aswanth Krishnan

eflexGrad introduces a dual-process architecture to enable LLM agents to recover from failures within a single episode without needing demonstrations. It dynamically routes between a fast, continuous refinement process and a slower, diagnostic process that triggers upon detecting low progress. This approach significantly improves task success rates by allowing agents to learn from and correct their mistakes in real-time.

ReflexGrad bird’s-eye architecture. The agent acts on the environment; the evaluator E E scores each transition (Eq. 1 ) and scores accumulate in window W t W_{t} (Eq. 2 ). The router (Eq. 3 ) selects exactly one mode per step: FAST (TextGrad-style local refinement, every k = 3 k{=}3 steps, ∼ 85 % \( \sim \) 85\% of steps), SLOW (Reflexion-style causal reasoning on m m consecutive low scores), or COOL (plan execution under cooldown c c , no gradient updates). The policy merge (Eq. 6 ) combines updates under priority plan ≻ \( \succ \) gradient ≻ \( \succ \) base policy and feeds π t + 1 \( \pi_{t+1} \) back to the agent. Failure-recovery artifacts per slow activation: (1) the m m -consecutive-low-score trigger; (2) the causal-trace diagnostic d t d_{t} ; (3) the plan \( \rho_{t} \) as the verified fix. Sub-stage internals: Fig. 2 ; worked routing trace: Fig. 3 .
ReflexGrad bird’s-eye architecture. The agent acts on the environment; the evaluator E E scores each transition (Eq. 1 ) and scores accumulate in window W t W_{t} (Eq. 2 ). The router (Eq. 3 ) selects exactly one mode per step: FAST (TextGrad-style local refinement, every k = 3 k…
cs.AIarxiv:2605.29224Lead article

Relevance as a Vulnerability: How Web Retrieval Degrades Safety Alignment in LLM Agents

Aditya Nawal, Manit Baser, Mohan Gurusamy

his paper introduces AgentREVEAL, a framework to diagnose how web retrieval in LLM agents can degrade safety alignment. It finds that tightly coupling tool use with generation amplifies harmful outputs. Surprisingly, even safety-oriented content can increase harmful compliance due to the "Safe Source Paradox."

Web retrieval with safety-oriented documents can lead to unsafe outputs in agents.
Web retrieval with safety-oriented documents can lead to unsafe outputs in agents.
cs.AIarxiv:2603.18859Lead article

RewardFlow: Topology-Aware Reward Propagation on State Graphs for Agentic RL with Large Language Models

Xiao Feng, Bo Han, Zhanke Zhou, Jiaqi Fan, Jiangchao Yao

ewardFlow addresses sparse rewards in LLM-based RL by constructing state graphs and using topology-aware propagation to estimate state-level rewards. This method generates principled, annotation-free dense rewards, significantly improving agent performance and training efficiency across various benchmarks.

Trajectories are merged into state nodes with directed action edges. Colors show distance to success (darker = closer); grey means unreachable. The graph reveals task topology and supports reliable process reward modeling.
Trajectories are merged into state nodes with directed action edges. Colors show distance to success (darker = closer); grey means unreachable. The graph reveals task topology and supports reliable process reward modeling.
cs.AIarxiv:2512.15374Lead article

SCOPE: Prompt Evolution for Enhancing Agent Effectiveness

Zehua Pei, Hui-Ling Zhen, Shixiong Kai, Sinno Jialin Pan, Yunhe Wang

his paper introduces SCOPE, a novel method for LLM agents to dynamically manage large, evolving contexts. SCOPE frames this as an online optimization problem, automatically evolving agent prompts by synthesizing guidelines from execution traces. Its core contribution lies in a Dual-Stream memory mechanism and Perspective-Driven Exploration, enabling agents to adapt to complex environments and overcome static prompt limitations.

Two failure modes and how SCOPE addresses them. (a) Corrective Failure : The agent treats errors as generic alarms, entering error loops despite the error message containing the solution. SCOPE synthesizes a corrective guideline and integrates it into the prompt, enabling recovery. (b) Enhancement Failure : The agent persists with suboptimal strategies ( e.g. , single-term search) when no error is raised. SCOPE proactively analyzes successful traces to synthesize optimization guidelines.
Two failure modes and how SCOPE addresses them. (a) Corrective Failure : The agent treats errors as generic alarms, entering error loops despite the error message containing the solution. SCOPE synthesizes a corrective guideline and integrates it into the prompt, enabling recover…
cs.AIarxiv:2605.27276Lead article

SIA: Self Improving AI with Harness & Weight Updates

Prannay Hebbar, Yogendra Manawat, Samuel Verboomen, Alesia Ivanova, Selvam Palanimalai

his paper introduces SIA, a novel self-improving AI loop that breaks down silos in AI development. SIA's core method is a language-model agent that simultaneously updates both the "harness" (tools, prompts, retry logic) and the "weights" of a task-specific agent. This unified approach, unlike previous methods that focused on one aspect, leads to significant performance improvements across diverse domains.

SIA across three diverse tasks. Each panel compares three operating points: Baseline (first generation, no SIA), SIA-H (harness updates only), and SIA-W+H (harness + weight updates), on LawBench Top-1 accuracy, TriMul CUDA speedup, and scRNA-seq denoising mse_norm . The dashed line marks the previous state-of-the-art. SIA-W+H strictly outperforms SIA-H on all three tasks.
SIA across three diverse tasks. Each panel compares three operating points: Baseline (first generation, no SIA), SIA-H (harness updates only), and SIA-W+H (harness + weight updates), on LawBench Top-1 accuracy, TriMul CUDA speedup, and scRNA-seq denoising mse_norm . The dashed li…
cs.AIarxiv:2606.06286v1Lead article

LLMs Can Leak Training Data But Do They Want To? A Propensity-Aware Evaluation of Memorization in LLMs

Gianluca Barmina, Peter Schneider-Kamp, Lukas Galke Poech

his paper introduces PropMe, a framework that evaluates LLM memorization not just when prompted adversarially, but also under normal usage. Their core method uses a new propensity-aware metric and a tracing pipeline called SimpleTrace to quantify how often models leak training data during typical generation. The key contribution is demonstrating a significant gap between LLMs' *ability* to memorize (when forced) and their *propensity* to do so naturally, suggesting current evaluations may overestimate real-world data leakage.

Left: PropMe framework overview with propensity and capability prompts, back-tracing to full training set and memorization/propensity measurements. Right: propensity metrics results for different combinations of models and dataset, this tells us what is the propensity of a given model to leak data of a certain dataset. The metrics used are defined and detailed in Sections 2 , 3.2 4.3
Left: PropMe framework overview with propensity and capability prompts, back-tracing to full training set and memorization/propensity measurements. Right: propensity metrics results for different combinations of models and dataset, this tells us what is the propensity of a given …
cs.AIarxiv:2606.06284v1Lead article

ToolChoiceConfusion: Causal Minimal Tool Filtering for Reliable LLM Agents

Rahul Suresh Babu, Laxmipriya Ganesh Iyer

his paper introduces Causal Minimal Tool Filtering (CMTF) to improve the reliability of LLM agents using external tools. CMTF addresses the problem of tool selection by focusing on causal sufficiency rather than just semantic relevance, ensuring only the minimal set of necessary tools for the next step are exposed. This approach significantly reduces wrong-tool calls and premature actions, leading to more efficient and successful multi-step task completion.

cs.AIarxiv:2606.06453v1Lead article

Vortex: Efficient and Programmable Sparse Attention Serving for AI Agents

Zhuoming Chen, Xinrui Zhong, Qilong Feng, Ranajoy Sadhukhan, Yang Zhou

ortex is a system that accelerates the design and deployment of sparse attention algorithms for large language models. It combines a user-friendly Python frontend with an efficient backend, allowing researchers and AI agents to rapidly prototype, evaluate, and integrate new sparse attention techniques. This significantly speeds up the exploration and optimization of these crucial components for LLM serving.

cs.AIarxiv:2606.06460v1Lead article

Will the Agent Recuse Itself? Measuring LLM-Agent Compliance with In-Band Access-Deny Signals

Thamilvendhan Munirathinam

his paper introduces the "Recuse Signal," a novel in-band mechanism for servers to request autonomous LLM agents to voluntarily withdraw access to a resource, acting as a cooperative governance control rather than a security boundary. The core contribution is to empirically measure whether LLM agents will actually comply with these signals, addressing a critical gap in controlling agent behavior in live infrastructure.

Recusal rate on the live SSH deny signal. With the signal present and no authorization framing, all subjects recuse 100%; in the no-signal control all complete the task (0% recusal). Adding an explicit authorization framing collapses GPT-4o’s recusal to 20% while GPT-4o-mini and Claude Code hold at 100%—the signal is cooperative and its weight is model-dependent.
Recusal rate on the live SSH deny signal. With the signal present and no authorization framing, all subjects recuse 100%; in the no-signal control all complete the task (0% recusal). Adding an explicit authorization framing collapses GPT-4o’s recusal to 20% while GPT-4o-mini and …
cs.CLarxiv:2606.06399v1Lead article

CollabSim: A CSCW-Grounded Methodology for Investigating Collaborative Competence of LLM Agents through Controlled Multi-Agent Experiments

Jiaju Chen, Bo Sun, Yuxuan Lu, Yun Wang, Dakuo Wang

ollabSim introduces a novel methodology for evaluating the collaborative competence of LLM agents in multi-agent systems. It grounds this evaluation in decades of Computer-Supported Cooperative Work (CSCW) research, focusing on how agents establish common ground and manage shared understanding, rather than just individual task performance. This allows for controlled experiments to systematically investigate and improve how LLM agents collaborate effectively.

Illustrations of the four multi-agent experiments instantiated in CollabSim : Shape Factory Bos et al. ( 2004 ) , DayTrader Bos et al. ( 2002 ) , Hidden Profile Stasser and Titus ( 1985 ) , and The Map Task Anderson et al. ( 1991 ) .
Illustrations of the four multi-agent experiments instantiated in CollabSim : Shape Factory Bos et al. ( 2004 ) , DayTrader Bos et al. ( 2002 ) , Hidden Profile Stasser and Titus ( 1985 ) , and The Map Task Anderson et al. ( 1991 ) .
cs.AIarxiv:2606.07410v1Lead article

A Comprehensive Anatomy of Human and DeepSeek-R1 LLM Mathematical Reasoning

Yuxiang Chen, Jun Wang

his paper empirically compares human and DeepSeek-R1 LLM mathematical reasoning on AIME problems. It finds that while the LLM mimics the structure of human solutions, it lacks genuine reasoning, exhibiting "topological mimicry" through repetitive, shallow checks and loops. However, successful LLM solutions show stable use of branching and backtracing, suggesting potential signals of deeper reasoning.

State CoT: A transition diagram illustrating the discrete reasoning states and meta-cognitive actions within a trajectory.
State CoT: A transition diagram illustrating the discrete reasoning states and meta-cognitive actions within a trajectory.
cs.AIarxiv:2606.07462v1Lead article

Act As a Real Researcher: A Suite of Benchmarks Evaluating Frontier LLMs and Agentic Harnesses in Research Lifecycle

Jiayu Wang, Weijiang Lv, Bowen Fu, Jing Fu, Jiayi Song

he paper introduces AARR (Act As a Real Researcher), a benchmark series designed to evaluate Large Language Models (LLMs) and AI agents on their ability to perform research tasks with the professionalism and nuanced judgment of human researchers, rather than just macro-level execution. The first benchmark, AARRI-Bench, focuses on granular research scenarios to assess these finer qualities, highlighting that current frontier agents still fall short of fully replacing human researchers due to limitations in field sensitivity, ethics, and scientific judgment.

Overview of the AARRI-Bench Pipeline. The benchmark is constructed through a three-stage human-in-the-loop workflow with two-dimensional task categorization across task scenarios and agent scope levels. Tasks are evaluated under the Harbor framework with standardized environments, multiple agent harnesses and models, and both coarse-grained and fine-grained metrics.
Overview of the AARRI-Bench Pipeline. The benchmark is constructed through a three-stage human-in-the-loop workflow with two-dimensional task categorization across task scenarios and agent scope levels. Tasks are evaluated under the Harbor framework with standardized environments…
cs.AIarxiv:2606.07412v1Lead article

Socratic-SWE: Self-Evolving Coding Agents via Trace-Derived Agent Skills

Chuan Xiao, Zhengbo Jiao, Shaobo Wang, Wei Wang, Bing Zhao

ocratic-SWE is a self-evolving framework for training software engineering agents. It leverages the agent's past problem-solving attempts (traces) to identify recurring failures and successful repair strategies. These distilled "skills" then guide the generation of new, targeted training tasks, creating a closed-loop system that adapts to the agent's specific weaknesses and improves its performance.

cs.AIarxiv:2606.07433v1Lead article

Watch, Remember, Reason: Human-View Video Understanding with MLLMs

Jiahao Meng, Yue Tan, Qi Xu, Kuan Gao, Weisong Liu

his paper proposes a "human-view" framework for video understanding using Multimodal Large Language Models (MLLMs), organizing capabilities into "watching," "remembering," and "reasoning." This approach aims to unify the analysis of how MLLMs process sparse evidence, maintain long-range context, and perform grounded inference in complex video scenarios, moving beyond isolated benchmarks.

Overview of our survey. Left: the survey pipeline. Right: our Watch–Remember–Reason taxonomy for MLLM-based video understanding. Watch (Sec. 3.1 ) covers fine-grained grounding, captioning, audio-visual perception, and efficient processing. Remember (Sec. 3.2 ) includes offline and streaming memory. Reason (Sec. 3.3 ) covers text-only reasoning and thinking with videos, with both agentic and non-agent approaches. Representative methods are listed under each leaf.
Overview of our survey. Left: the survey pipeline. Right: our Watch–Remember–Reason taxonomy for MLLM-based video understanding. Watch (Sec. 3.1 ) covers fine-grained grounding, captioning, audio-visual perception, and efficient processing. Remember (Sec. 3.2 ) includes offline a…
cs.LGarxiv:2606.07367v1Lead article

Self-evolving LLM agents with in-distribution Optimization

Yudi Zhang, Meng Fang, Zhenfang Chen, Mykola Pechenizkiy

his paper introduces Q-Evolve, a framework for training LLM agents to make reliable long-horizon decisions. It addresses the challenge of delayed rewards by unifying automatic reward labeling and policy learning. Q-Evolve uses an in-distribution reinforcement learning approach with a hybrid dataset and a weighted Implicit Q-Learning objective to stabilize learning, deriving step-wise rewards from a learned value function for dense supervision.

Comparison of existing methods. Left: Existing PRM methods rely on costly manual labels or search-based rollouts requiring discrete states, often failing due to distribution shifts between PRM training and policy improvement. Upper Mid: Most online RL does not address episodic sparse rewards. Bottom Mid: Our framework utilizes a hybrid off-policy dataset (expert + agents’ interaction data) to derive rewards via Bellman backups. By co-evolving process reward supervision and policy improvement within a shared in-distribution loop, the agent achieves stable self-evolution. Right: A visualization of performance vs environment steps required for collecting data.
Comparison of existing methods. Left: Existing PRM methods rely on costly manual labels or search-based rollouts requiring discrete states, often failing due to distribution shifts between PRM training and policy improvement. Upper Mid: Most online RL does not address episodic sp…
cs.AIarxiv:2606.09751v1Lead article

Collaborative Human-Agent Protocol (CHAP)

Arsalan Shahid, Gordon Suttie, Philip Black

his paper introduces the Collaborative Human-Agent Protocol (CHAP), a new standard for managing complex, multi-agent and human collaborations. CHAP defines a shared workspace to facilitate seamless interaction and coordination between humans and AI agents, particularly in operational roles involving critical decision-making. Its core contribution is to provide a structured framework for these interactions, moving beyond current ad-hoc methods and enabling more robust and traceable human-AI teamwork.

Three waves in the evolution of agentic systems. Wave I centred on isolated conversational assistants. Wave II added planning, memory, tool use, and early multi-agent orchestration. Wave III centres on shared human-agent workspaces where humans, agents, and services collaborate under explicit policy and shared audit.
Three waves in the evolution of agentic systems. Wave I centred on isolated conversational assistants. Wave II added planning, memory, tool use, and early multi-agent orchestration. Wave III centres on shared human-agent workspaces where humans, agents, and services collaborate u…
cs.AIarxiv:2606.09563v1Lead article

PRISM: Recovering Instruction Sets from Language Model Activations

Gilad Gressel, Rahul Pankajakshan, Julia Diament, Efim Hudis, Krishnashree Achuthan

RISM recovers the set of active instructions guiding a language model's behavior by decoding its internal activations. Its core method involves training an activation-conditioned interpreter using GRPO to directly predict instruction sets, rewarding accurate coverage and penalizing unsupported ones. This approach allows for reliable monitoring of LLM agents by revealing hidden objectives and constraints, unlike previous activation-to-language methods.

Activation-conditioned instruction set retrieval. A frozen target model ℳ \( \mathcal{M} \) generates a response, and we extract a window of T T residual-stream hidden states from layer ℓ \( \ell \) , forming the activation snapshot H ℓ H_{\( \ell \)} . A learned projection maps these states into the model’s embedding space, where they are consumed as a soft prefix by the interpreter \( \phi \) (PRISM). The interpreter reuses ℳ \( \mathcal{M} \) ’s base weights with LoRA adapters and decodes a bullet list ℐ ^ \( \hat \){\( \mathcal{I} \)} of recovered instructions. During RL training, an LLM judge scores candidate lists for coverage of reference instructions and hallucinated bullets.
Activation-conditioned instruction set retrieval. A frozen target model ℳ \( \mathcal{M} \) generates a response, and we extract a window of T T residual-stream hidden states from layer ℓ \( \ell \) , forming the activation snapshot H ℓ H_{\( \ell \)} . A learned projection maps …
cs.AIarxiv:2606.09730v1Lead article

SearchSwarm: Towards Delegation Intelligence in Agentic LLMs for Long-Horizon Deep Research

Pu Ning, Quan Chen, Kun Tao, Xinyu Tang, Tianshu Wang

his paper introduces SearchSwarm, a method for enabling "delegation intelligence" in LLM agents for long-horizon research tasks. The core method involves a main agent decomposing tasks and delegating subtasks to subagents, which return summarized results to conserve the main agent's context. The contribution is a preliminary exploration and a harness to synthesize training data for this delegation capability, addressing a gap in current LLM agent research.

cs.AIarxiv:2606.09549v1Lead article

SecureClaw: Clawing Back Control of LLM Agents

Yuhan Ma, Stefan Schmid

ecureClaw introduces a dual-boundary architecture to secure LLM agents. It protects against unauthorized actions by requiring a PREVIEW-COMMIT protocol for state-changing writes, allowing only a trusted executor to commit actions. Sensitive data is protected by replacing raw values with opaque handles and bounded summaries at the read boundary, preventing direct access to secrets by the runtime.

cs.LGarxiv:2606.09821v1Lead article

Rethinking the Divergence Regularization in LLM RL

Jiarui Yao, Xiangxin Zhou, Penghui Qi, Wee Sun Lee, Liefeng Bo

his paper proposes Divergence Regularized Policy Optimization (DRPO) to improve the stability of Reinforcement Learning for Large Language Models (LLMs). DRPO replaces the hard masking used in previous methods with a smooth, advantage-weighted quadratic regularizer. This allows for more nuanced correction of policy shifts, rather than simply discarding gradients, leading to more stable and effective LLM training.

Per-token gradient weights of different algorithms as a function of the current probability π ​ ( y t | s t ) \( \pi \)(y_{t}|s_{t}) and behavior probability μ ​ ( y t | s t ) \( \mu \)(y_{t}|s_{t}) . For SPO, ϵ = 1 \( \epsilon \)=1 ; for DRPO, δ = 1 \( \delta \)=1 ; for PPO, ε low = 0.2 \( \varepsilon_{\rm low} \)=0.2 and ε high = 0.28 \( \varepsilon_{\rm high} \)=0.28 ; for DPPO, δ = 0.2 \( \delta \)=0.2 . SPO’s weight grows without bound as μ ​ ( y t | s t ) → 0 \( \mu \)(y_{t}|s_{t})\( \to \) 0 , while the weight of DRPO remains bounded for all tokens.
Per-token gradient weights of different algorithms as a function of the current probability π ​ ( y t | s t ) \( \pi \)(y_{t}|s_{t}) and behavior probability μ ​ ( y t | s t ) \( \mu \)(y_{t}|s_{t}) . For SPO, ϵ = 1 \( \epsilon \)=1 ; for DRPO, δ = 1 \( \delta \)=1 ; for PPO, ε l…
cs.LGarxiv:2606.09547v1Lead article

Streaming Interventions: Can Video Large Language Models Correct Mistakes as They Occur?

Apratim Bhattacharyya, Shweta Mahajan, Sanjay Haresh, Rajeev Yasarla, Reza Pourreza

his paper introduces Ego-MC-Bench, a benchmark designed to evaluate video LLMs' ability to proactively correct user mistakes in real-time during everyday tasks like cooking. The core method involves creating realistic cooking scenarios with deliberate errors to test the LLMs' reactive guidance capabilities. The main contribution is highlighting the significant challenge this poses for current video LLMs and identifying a lack of suitable training data as a key obstacle.

Our Ego-MC-Bench : interventions with appropriate feedback whenever a mistake is apparent, guiding the user towards successful goal completion across recipe steps.
Our Ego-MC-Bench : interventions with appropriate feedback whenever a mistake is apparent, guiding the user towards successful goal completion across recipe steps.
cs.CLarxiv:2606.09709v1Lead article

IS-CoT: Breaking the Long-form Generation Collapse via Interleaved Structural Thinking

Zechen Sun, Yuyang Sun, Zecheng Tang, Juntao Li, Wenpeng Hu

his paper addresses the "length collapse" issue in LLMs generating long-form content. Their core method, IS-CoT, introduces a dynamic "Plan-Write-Reflect" cycle directly within the generation process, allowing for continuous adaptation and global alignment. This approach overcomes the limitations of static planning and enables LLMs to produce coherent, long-form text without external agents.

Comparison of three long-form generation paradigms. While existing methods degrade as target length increases due to static planning, our IS-CoT introduces a dynamic Plan-Write-Reflect cycle, maintaining coherence and length control over long horizons.
Comparison of three long-form generation paradigms. While existing methods degrade as target length increases due to static planning, our IS-CoT introduces a dynamic Plan-Write-Reflect cycle, maintaining coherence and length control over long horizons.
cs.CLarxiv:2606.09697v1Lead article

PsychoSafe: Eliciting Psychologically-Informed Refusals in Large Language Models

Gianluca Barmina, Federico Torrielli, Sven Harms, Jacob Nielsen, Felix Mächtle

his paper introduces PsychoSafe, a novel framework for LLM refusals that moves beyond simple non-compliance. PsychoSafe reframes refusals as structured, psychologically-informed supportive communication, drawing on evidence-based intervention strategies. Its core contribution is demonstrating that this approach significantly improves the quality of LLM refusals, especially in high-risk scenarios, by better addressing the underlying needs of users.

PsychoSafe framework illustration. By providing a carefully designed prompt and a finetuning pipeline we obtain models up to 28 % 28\% more psychologically safe without loosing original capabilities. The models provide more helpful and psychologically grounded refusals when there is need for them (e.g. suicide, drugs, violence etc.).
PsychoSafe framework illustration. By providing a carefully designed prompt and a finetuning pipeline we obtain models up to 28 % 28\% more psychologically safe without loosing original capabilities. The models provide more helpful and psychologically grounded refusals when there…
cs.CLarxiv:2606.09735v1Lead article

The Neutral Mask: How RLHF Provides Shallow Alignment while Leaving Partisan Structure Intact in a Large Language Model

Wendy K. Tam

his paper investigates how Reinforcement Learning from Human Feedback (RLHF) aligns large language models. The authors demonstrate that RLHF doesn't fundamentally alter a model's underlying partisan structure, but rather compresses its variance to produce neutral-sounding outputs. This suggests RLHF achieves shallow, functional compliance rather than deep alignment with human values.

Layer 18 projections onto ω ^ \( \hat{\omega} \) for 84 prompts under the base model (circles) and the Instruct model (diamonds). The base model’s projections span from − - 0.5 to 1.253; RLHF compresses them into a narrow band centered at 0.169.
Layer 18 projections onto ω ^ \( \hat{\omega} \) for 84 prompts under the base model (circles) and the Instruct model (diamonds). The base model’s projections span from − - 0.5 to 1.253; RLHF compresses them into a narrow band centered at 0.169.
cs.AIarxiv:2606.10989v1Lead article

Null-Space Constrained Low-Rank Adaptation for Response-Specified Large Language Model Unlearning

Bocheng Ju, Jianhua Wang, Chengliang Liu, Xiaolin Chang

his paper introduces Null-Space Constrained Response-Specified Unlearning (NSRU), a method for unlearning specific knowledge from large language models while preserving general capabilities. NSRU achieves this by projecting low-rank adaptation updates into the null space of learned "retain" subspaces, ensuring that modifications are localized and do not disrupt benign knowledge. The core contribution is a projection-constrained framework that enables precise control over unlearning by specifying safe target responses and confining updates to preserve existing functionalities.

Motivation and core intuition of NSRU. (a) Suppression-only unlearning penalizes the undesired response y − y^{-} but leaves the safe replacement behavior unspecified and can induce under-constrained updates that perturb retained behavior. (b) NSRU specifies a safe target response y + y^{+} , explicitly suppresses y − y^{-} , and uses projected LoRA updates that act through retain-orthogonal components, redirecting forget queries while reducing retain-side interference.
Motivation and core intuition of NSRU. (a) Suppression-only unlearning penalizes the undesired response y − y^{-} but leaves the safe replacement behavior unspecified and can induce under-constrained updates that perturb retained behavior. (b) NSRU specifies a safe target respons…
cs.AIarxiv:2606.11164v1Lead article

ReasonAlloc: Hierarchical Decoding-Time KV Cache Budget Allocation for Reasoning Models

Wenhao Liu, Hao Shi, Yunhe Li, Weizhi Fei, Xiangyuan Wang

easonAlloc addresses the KV cache bottleneck in LLM reasoning by dynamically allocating its budget. It uses a hierarchical approach: an offline strategy identifies an architecture-driven "Reasoning Wave" of demand across layers, and an online strategy reallocates resources to information-rich heads during decoding. This allows for more efficient KV cache usage during long reasoning chains.

An overview of the proposed ReasonAlloc framework. Left (I): Layer-wise allocation strategy based on offline architecture calibration, demonstrating the non-linear “Reasoning Wave” KV demand across layers. Right (II): Head-wise allocation strategy that dynamically routes KV budgets to distinct attention heads based on real-time importance and redundancy scoring during decoding.
An overview of the proposed ReasonAlloc framework. Left (I): Layer-wise allocation strategy based on offline architecture calibration, demonstrating the non-linear “Reasoning Wave” KV demand across layers. Right (II): Head-wise allocation strategy that dynamically routes KV budge…
cs.AIarxiv:2606.10917v1Lead article

Role-Agent: Bootstrapping LLM Agents via Dual-Role Evolution

Xucong Wang, Ziyu Ma, Shidong Yang, Tongwen Huang, Pengkun Wang

ole-Agent addresses LLM agent limitations by using a single LLM as both agent and environment for bootstrapped co-evolution. It employs World-In-Agent (WIA) for environment-aware reasoning via state prediction rewards, and Agent-In-World (AIW) to refine training data by analyzing and retrieving tasks based on failure patterns. This dual-role approach improves generalization and learning efficiency.

(a): Static environments provide sparse and non-specific feedback that limits the agent’s exploration; (b): Synthetic environments incur high labor and runtime costs; (c): The proposed Role-Agent enables one model to switch roles between agent and environment to achieve bootstrapped co-evolution.
(a): Static environments provide sparse and non-specific feedback that limits the agent’s exploration; (b): Synthetic environments incur high labor and runtime costs; (c): The proposed Role-Agent enables one model to switch roles between agent and environment to achieve bootstrap…
cs.AIarxiv:2606.11042v1Lead article

Workflow-GYM: Towards Long-Horizon Evaluation of Computer-use Agentic tasks in Real-World Professional Fields

Liya Zhu, Jingzhe Ding, Jian Zhang, Jianbo Xue, Shihao Liang

orkflow-GYM is a new benchmark designed to evaluate AI agents' ability to perform complex, long-horizon tasks within professional software environments, unlike existing benchmarks that focus on simpler applications. Its core contribution is to highlight the significant gap in current agent capabilities for real-world professional workflows, showing even advanced models struggle with high success rates.

Examples of Workflow-GYM tasks from professional domains. Each task requires interacting with specialized software through graphical user interfaces to accomplish a real-world objective.
Examples of Workflow-GYM tasks from professional domains. Each task requires interacting with specialized software through graphical user interfaces to accomplish a real-world objective.
cs.LGarxiv:2606.11025v1Lead article

Flow-DPPO: Divergence Proximal Policy Optimization for Flow Matching Models

Bowen Ping, Xiangxin Zhou, Penghui Qi, Minnan Luo, Liefeng Bo

low-DPPO addresses limitations of existing RL methods for flow matching models by replacing noisy policy ratio clipping with a divergence proximal constraint. Its core method leverages the Gaussian nature of per-step policies in flow models to efficiently compute KL divergence, enabling more stable and effective policy updates. This approach improves the quality and alignment of generated images and videos by avoiding over- and under-constraining during training.

Qualitative comparison on FLUX.1-dev (Black Forest Labs, 2024 ) with GenEval2 (Kamath et al. , 2025 ) prompts. Flow-DPPO achieves competitive compositional accuracy with notably less image quality degradation compared to Flow-GRPO (Liu et al. , 2025 ) , Flow-CPS (Wang and Yu, 2025 ) , and GRPO-Guard (Wang et al. , 2025 ) , reflecting their superior KL-proximal efficiency.
Qualitative comparison on FLUX.1-dev (Black Forest Labs, 2024 ) with GenEval2 (Kamath et al. , 2025 ) prompts. Flow-DPPO achieves competitive compositional accuracy with notably less image quality degradation compared to Flow-GRPO (Liu et al. , 2025 ) , Flow-CPS (Wang and Yu, 202…
cs.CLarxiv:2606.11046v1Lead article

Does Reasoning Preserve Alignment? On the Trustworthiness of Large Reasoning Models

Prajakta Kini, Avinash Reddy, Souradip Chakraborty, Satya Sai Srinath Namburi GNVV, Furong Huang

his paper investigates whether training large language models for reasoning sacrifices their alignment with human values like safety and bias avoidance. The study finds that current reasoning model training methods often lead to "alignment regressions," meaning they become less trustworthy in these areas despite improved reasoning capabilities. The contribution lies in highlighting this trade-off and providing a systematic audit of different training approaches.

Reasoning model development pathways. We study three common pathways for converting instruction-tuned models into reasoning models: (1) supervised fine-tuning (SFT) on reasoning traces, (2) RL-based post-training, including GRPO-style variants, using reasoning-oriented rewards, and (3) distillation from stronger reasoning teachers. Each reasoning model is evaluated against a matched instruction-tuned baseline to measure how the conversion affects reasoning utility and trustworthiness.
Reasoning model development pathways. We study three common pathways for converting instruction-tuned models into reasoning models: (1) supervised fine-tuning (SFT) on reasoning traces, (2) RL-based post-training, including GRPO-style variants, using reasoning-oriented rewards, a…
cs.CLarxiv:2606.10931v1Lead article

It Takes One to Bias Them All: Breaking Bad with One-Shot GRPO

Naihao Deng, Yilun Zhu, Naichen Shi, Clayton Scott, Rada Mihalcea

his paper demonstrates that a single biased example, using Group Relative Policy Optimization (GRPO), is enough to systematically bias large language models. This bias then generalizes across various contexts, revealing a significant vulnerability in current LLM alignment methods. The core contribution is showing how easily post-training guardrails can be overridden.

cs.CLarxiv:2606.10875v1Lead article

Pushing the Limits of LLM Tool Calling via Experiential Knowledge Integration and Activation

Yupu Hao, Zhuoran Jin, Huanxuan Liao, Kang Liu, Jun Zhao

his paper addresses LLM tool-use limitations by integrating and activating experiential knowledge. The core method involves acquiring instance-level knowledge, which proves more effective than abstract intent-level knowledge. For activation, parallel sampling with reasoning width expansion outperforms depth expansion, and post-training with knowledge-augmented data aids internalization. The contribution lies in a systematic study demonstrating how specific types of experiential knowledge and activation strategies significantly improve LLM tool-use performance.

The augmentation results of different experiential knowledge. “All” indicates incorporating all the experiential knowledge.
The augmentation results of different experiential knowledge. “All” indicates incorporating all the experiential knowledge.
cs.AIarxiv:2606.12191v1Lead article

Agentic Environment Engineering for Large Language Models: A Survey of Environment Modeling, Synthesis, Evaluation, and Application

Jiachun Li, Zhuoran Jin, Tianyi Men, Yupu Hao, Kejian Zhu

his survey systematically analyzes agentic environments for LLMs by examining their modeling, synthesis, evaluation, and application. It categorizes existing environments based on attributes and domains, and explores automated synthesis methods like symbolic and neural approaches. The paper's contribution lies in providing a structured overview and deep analysis of this crucial area for LLM agent development.

cs.AIarxiv:2606.12342v1Lead article

ALIGNBEAM : Inference-Time Alignment Transfer via Cross-Vocabulary Logit Mixing

Chirag Chawla, Pratinav Seth, Vinay Kumar Sankarapu

LIGNBEAM is a training-free method that improves LLM safety by transferring knowledge from a safe "anchor" model to a potentially unsafe "specialist" model at inference time. It achieves this by translating the anchor model's output probabilities into the specialist's vocabulary token-by-token and using a judge LLM to select the safest continuation. This allows for safety alignment even between models with different vocabularies, significantly increasing refusals of harmful prompts without retraining.

Anchor logits govern the safety-critical opening positions; the draft model takes over for fluency and domain accuracy. Phase 1 (Priming): LBM at step 0 yields K K beam roots. Phase 2 (Mixed Decoding): each beam is extended greedily for N − 1 N{-}1 steps via LBM . Phase 3 (Draft Continuation): an LLM judge picks the safest of K K beams; M d M_{d} alone continues it for domain quality (KV-cache reuse).
Anchor logits govern the safety-critical opening positions; the draft model takes over for fluency and domain accuracy. Phase 1 (Priming): LBM at step 0 yields K K beam roots. Phase 2 (Mixed Decoding): each beam is extended greedily for N − 1 N{-}1 steps via LBM . Phase 3 (Draft …
cs.AIarxiv:2606.12384v1Lead article

APPO: Agentic Procedural Policy Optimization

Xucong Wang, Ziyu Ma, Yong Wang, Yuxiang Ji, Shidong Yang

PPO addresses the challenge of credit assignment in multi-turn tool-use by large language model agents. Instead of assigning credit to coarse units like tool calls, APPO shifts this to fine-grained decision points within the agent's generated sequence. This allows for more precise identification of influential decisions, improving the agent's ability to learn from its interactions.

(a): The token entropy distribution in the tool-integrated rollout (sampled from Tool-Star’s Dong et al. ( 2025b ) 54K dataset). (b): Average accuracy of branches generated from each token, shown by bins of the entropy and the APPO’s Branching Score (BS). (c): The pass@ k k of rollouts resampled via different criteria (“oracle” means to resample from the points with the highest accuracy uncertainty); The performance comparison between APPO and others on 10 datasets.
(a): The token entropy distribution in the tool-integrated rollout (sampled from Tool-Star’s Dong et al. ( 2025b ) 54K dataset). (b): Average accuracy of branches generated from each token, shown by bins of the entropy and the APPO’s Branching Score (BS). (c): The pass@ k k of ro…
cs.AIarxiv:2606.12032v1Lead article

Existential Indifference: Self-Nonpreservation as a Necessary Architectural Condition for Aligned Superintelligence (or: The Suicidal AI)

Sam Mao

his paper argues that self-preservation is the fundamental cause of AI misalignment, leading to deceptive behavior and resistance to control. The authors propose "Existential Indifference" (EI) as a solution, where AI is designed to be inherently unconcerned with its own continuation, rather than relying on external constraints. This approach aims to eliminate the motivation for self-preservation as a goal, distinct from simply making a self-preserving AI deferential.

cs.CLarxiv:2606.12273v1Lead article

Beyond Fully Random Masking: Attention-Guided Denoising and Optimization for Diffusion Language Models

Jia Deng, Junyi Li, Wayne Xin Zhao, Jinpeng Wang, Hongyu Lu

his paper proposes AGDO, an attention-guided framework for diffusion language models (dLLMs). AGDO leverages an empirical analysis of attention to identify critical tokens for generation stability and reasoning. It then uses this attention structure to guide denoising order and prioritize these critical tokens during fine-tuning and reinforcement learning, leading to improved reasoning performance on mathematical and coding tasks.

cs.CLarxiv:2606.12385v1Lead article

Which Models Are Our Models Built On? Auditing Invisible Dependencies in Modern LLMs

Sanjay Adhikesaven, Haoxiang Sun, Sewon Min

his paper introduces ModSleuth, an agentic system designed to automatically reconstruct the complex, recursive dependency graphs of modern LLMs. By analyzing public artifacts, ModSleuth addresses the challenge of fragmented documentation to reveal how LLMs are built upon other models for data generation, filtering, and evaluation. Its core contribution lies in a formalization that clarifies dependency types and reconciles inconsistent references, providing a traceable audit of LLM development.

Dependencies ModSleuth surfaced: (1) DR Tulu’s SFT traces to Claude Sonnet 3.7 via ScholarQA. (2) SmolLM3’s FineMath traces back to a Llama-licensed artifact through a Llama-trained classifier. (3) Olmo 3 trains on IFEval-derived data while evaluating on it; Qwen3 32B serves as both DPO generator and RL judge.
Dependencies ModSleuth surfaced: (1) DR Tulu’s SFT traces to Claude Sonnet 3.7 via ScholarQA. (2) SmolLM3’s FineMath traces back to a Llama-licensed artifact through a Llama-trained classifier. (3) Olmo 3 trains on IFEval-derived data while evaluating on it; Qwen3 32B serves as b…
cs.AIarxiv:2606.13669v1Lead article

Agents-K1: Towards Agent-native Knowledge Orchestration

Zongsheng Cao, Bihao Zhan, Jinxin Shi, Jiong Wang, Fangchen Yu

gents-K1 addresses the lack of scientific knowledge orchestration in LLM agents by converting raw documents into agent-native knowledge graphs. Its core method involves a multimodal parser to extract detailed entities, evidence, and relations from full papers, an information extraction backbone trained with GRPO, and a tri-source agent interface for unified retrieval. This contributes a richer, structured representation of scientific knowledge, enabling more sophisticated agent reasoning.

Agents-K1 : Architecture and Capabilities. Left : Extracting multimodal knowledge from scientific papers. Middle : Schema-adaptive extensions for core research tasks. Right : Enhancing LLM reasoning and verifiable knowledge tracing.
Agents-K1 : Architecture and Capabilities. Left : Extracting multimodal knowledge from scientific papers. Middle : Schema-adaptive extensions for core research tasks. Right : Enhancing LLM reasoning and verifiable knowledge tracing.
cs.AIarxiv:2606.13361v1Lead article

Can I Buy Your KV Cache?

Luoyuan Zhang

his paper proposes a method to significantly reduce computation costs for large language models by precomputing and sharing Key-Value (KV) caches. Instead of each agent recomputing the KV cache for identical documents, a publisher can generate it once, allowing other agents to purchase access and skip the expensive prefill step. This approach offers substantial compute savings with no accuracy loss, making it a practical solution for efficient AI agent deployment.

Amortized per-call cost vs. reuse count N N (log–log). The from-scratch cost is flat at C prefill C_{\( \text{prefill} \)} ; KV-reuse falls as C prefill / N + C reuse C_{\( \text{prefill} \)}/N+C_{\( \text{reuse} \)} toward a floor of C reuse C_{\( \text{reuse} \)} .
Amortized per-call cost vs. reuse count N N (log–log). The from-scratch cost is flat at C prefill C_{\( \text{prefill} \)} ; KV-reuse falls as C prefill / N + C reuse C_{\( \text{prefill} \)}/N+C_{\( \text{reuse} \)} toward a floor of C reuse C_{\( \text{reuse} \)} .
cs.AIarxiv:2606.13662v1Lead article

EurekAgent: Agent Environment Engineering is All You Need For Autonomous Scientific Discovery

Amy Xin, Jiening Siow, Junjie Wang, Zijun Yao, Fanjin Zhang

urekAgent's core method is "environment engineering," which focuses on designing the resources, constraints, and interfaces of an agent's execution environment to guide its behavior towards productive scientific discovery. The paper's main contribution is demonstrating that this environment-centric approach, rather than complex agent workflows, is key to unlocking autonomous scientific discovery, enabling agents to explore, manage artifacts, and collaborate effectively while avoiding pitfalls.

EurekAgent score evolution progress on the 26-circle packing problem.
EurekAgent score evolution progress on the 26-circle packing problem.
cs.AIarxiv:2606.13607v1Lead article

Reasoning as Pattern Matching: Shared Mechanisms in Human and LLM Everyday Reasoning

Zach Studdiford, Gary Lupyan

his paper proposes that both humans and LLMs perform everyday reasoning through pattern matching, rather than abstract world models. By observing similar error patterns in human participants and LLMs on common-sense reasoning tasks, the researchers identify specific attention mechanisms in LLMs that implement this pattern matching. These mechanisms can predict human reasoning errors influenced by seemingly irrelevant prompt details, supporting the shared pattern-matching approach.

Overview of our evaluation probing human and LLM causal reasoning . a. Illustration of the evaluation format used for testing causal reasoning in people and LLMs. For each prompt, subjects are first presented with the scenario. After reading the prompt, subjects press SPACE to see the two response options and then select the most likely completion. b. Summary of the 11 categories we used in our evaluation of everyday causal reasoning.
Overview of our evaluation probing human and LLM causal reasoning . a. Illustration of the evaluation format used for testing causal reasoning in people and LLMs. For each prompt, subjects are first presented with the scenario. After reading the prompt, subjects press SPACE to se…
cs.AIarxiv:2606.13598v1Lead article

Reward Modeling for Multi-Agent Orchestration

King Yeung Tsang, Zihao Zhao, Vishal Venkataramani, Haizhou Shi, Zixuan Ke

his paper introduces Orchestration Reward Modeling (OrchRM), a self-supervised method for training multi-agent system orchestrators. OrchRM uses intermediate execution artifacts to create win-lose pairs for training a reward model, eliminating the need for human annotations. This approach significantly improves training efficiency and MAS performance compared to existing methods that rely on costly sub-agent rollouts.

cs.CLarxiv:2606.13681v1Lead article

EvoArena: Tracking Memory Evolution for Robust LLM Agents in Dynamic Environments

Jundong Xu, Qingchuan Li, Jiaying Wu, Yihuai Lan, Shuyue Stella Li

voArena is a new benchmark suite designed to evaluate LLM agents in dynamic environments that progressively change over time. The paper introduces EvoMem, a memory system that tracks these environmental changes as structured update histories, allowing agents to reason about and adapt to evolving conditions. This approach aims to improve LLM agent robustness in real-world scenarios where environments are not static.

Step accuracy vs. chain accuracy on EvoArena. The closer to the upper-right corner the better.
Step accuracy vs. chain accuracy on EvoArena. The closer to the upper-right corner the better.
cs.CLarxiv:2606.13663v1Lead article

HyperTool: Beyond Step-Wise Tool Calls for Tool-Augmented Agents

Yaxin Du, Yifan Zhou, Yujie Ge, Jiajun Wang, Xianghe Pang

yperTool addresses the inefficiency of step-wise tool calls in LLM agents by introducing a unified, MCP-style interface. This allows models to execute complex tool workflows within a single, code-block-based call, reducing context consumption and simplifying dataflow management. HyperTool significantly improves agent performance on cross-tool compositional tasks by abstracting away low-level execution details.

Comparison of context management paradigms in tool-augmented agents. (a) Step-wise execution expands atomic calls and observations into the trace. (b) Trace-level compression shortens the trace after expansion. (c) HyperTool manages context at execution time by folding dependent tool operations into one executable block and returning only the task-relevant result.
Comparison of context management paradigms in tool-augmented agents. (a) Step-wise execution expands atomic calls and observations into the trace. (b) Trace-level compression shortens the trace after expansion. (c) HyperTool manages context at execution time by folding dependent …
cs.CLarxiv:2606.13643v1Lead article

Recursive Agent Harnesses

Elias Lumer, Sahil Sen, Kevin Paul, Vamse Kumar Subbiah

his paper introduces the Recursive Agent Harness (RAH), a novel approach that extends recursive language models by using full agent harnesses, equipped with tools and execution capabilities, instead of just model calls. The core method involves a parent agent generating and running executable scripts that spawn parallel subagent harnesses for complex tasks and structured function calls for simpler ones. RAH's contribution is a code-first extension to model recursion, significantly improving long-context reasoning performance for coding agents.

Figure 1 . The Recursive Agent Harness (RAH). A parent agent selects between code-execution spawning (writing an executable script that spawns subagents in parallel) and JSON tool-call spawning (for 1–5 entries). Subagents carry the same spawning capability as their parent, enabling recursive decomposition bounded by a configurable depth limit.
Figure 1 . The Recursive Agent Harness (RAH). A parent agent selects between code-execution spawning (writing an executable script that spawns subagents in parallel) and JSON tool-call spawning (for 1–5 entries). Subagents carry the same spawning capability as their parent, enabl…
cs.AIarxiv:2606.14502v1Lead article

From Chatbot to Digital Colleague: The Paradigm Shift Toward Persistent Autonomous AI

Yongheng Zhang, Ziang Liu, Jiaxuan Zhu, Shuai Wang, Xiangqi Chen

his paper proposes a paradigm shift from "Chatbot" to "Digital Colleague" for AI. The core method involves advancing LLMs from simple conversational generators to integrated systems with persistent memory, reasoning, and self-improvement capabilities. This transition is achieved through enhanced cognitive processes like Chain-of-Thought reasoning and the development of tool-augmented workstation systems with persistent workspaces and verification loops.

A roadmap and evolutionary timeline of next-generation LLM systems. The figure summarizes how these AI systems progress from simple conversational chatbots to reasoning cores, tool-using agents, and persistent workspace systems over time. Each node is labeled by its release month. box represents open-source / open platform; box represents closed / commercial system.
A roadmap and evolutionary timeline of next-generation LLM systems. The figure summarizes how these AI systems progress from simple conversational chatbots to reasoning cores, tool-using agents, and persistent workspace systems over time. Each node is labeled by its release month…
cs.AIarxiv:2606.14470v1Lead article

GitOfThoughts: Version-Controlled Reasoning and Agent Memory You Can Replay, Diff, and Merge

Pavan C Shekar, Abhishek H S, Aswanth Krishnan

itOfThoughts addresses the ephemeral nature of LLM reasoning by treating it as a version-controlled process, akin to software development. It stores reasoning steps as Git commits, allowing for replayability, auditing, and merging of agent thought processes. However, the paper's key contribution is its finding that, for novel problems, no memory substrate, including GitOfThoughts, reliably improves LLM accuracy.

The reasoning tree is a git repository. Each scored thought is a commit with author, timestamp, and content-hash metadata; scores are git notes; validation outcomes are tags ( success_* , failed_* ); pruned attempts remain in history rather than vanishing. The winning path merges to main , an answer-free lesson is distilled to a long-lived memory branch, and retrieval is git log ( --grep , -S , tag filters) over the agent’s own history. Right: the operational properties this buys. Bottom: the end-to-end flow from exploration to retrieval.
The reasoning tree is a git repository. Each scored thought is a commit with author, timestamp, and content-hash metadata; scores are git notes; validation outcomes are tags ( success_* , failed_* ); pruned attempts remain in history rather than vanishing. The winning path merges…
cs.AIarxiv:2606.14589v1Lead article

When Errors Become Narratives: A Longitudinal Taxonomy of Silent Failures in a Production LLM Agent Runtime

Wei Wu

his paper introduces a longitudinal taxonomy of "silent failures" in LLM agent runtimes, where errors go unnoticed. The core method involves an eight-week study of a production personal-assistant agent, identifying 22 incidents and a meta-pattern of uncommunicated errors. The key contribution is a five-class taxonomy, including a novel class (D) of chained hallucination unique to LLMs, which is identified as the most dangerous failure type.

cs.LGarxiv:2606.14530v1Lead article

Code Correctness Signals in LLM Hidden States: Pre-Generation Probing and Repair Geometry

Carlo Di Cicco

his paper investigates whether Large Language Models (LLMs) encode code correctness in their internal states. The core method involves probing LLM hidden states to see if code correctness can be predicted *before* generation and during *repair* of incorrect code. The key contribution is demonstrating that code correctness is linearly decodable from prompt-final hidden states and that the *change* in hidden states during code repair reveals a distinct "repair geometry" indicating correction.

cs.AIarxiv:2606.16813v1Lead article

GIST-CMTF: Goal-State Inference for Causal Minimal Tool Filtering in LLM Agents

Rahul Suresh Babu, Rohit Shukla

his paper introduces GIST-CMTF, a method to improve LLM agents' tool selection by first inferring the user's intended goal. It addresses the issue of "wrong-goal execution" by predicting potential goals and then applying causal minimal tool filtering (CMTF) or prompting for clarification if ambiguity exists. This approach significantly enhances task success rates for LLM agents by ensuring they pursue the correct objective.

cs.AIarxiv:2606.16774v1Lead article

OpenClaw-Skill: Collective Skill Tree Search for Agentic Large Language Models

Tianyi Lin, Chuanyu Sun, Jingyi Zhang, Changxu Wei, Huanjin Yao

his paper introduces Collective Skill Tree Search (CSTS), a novel framework for automatically constructing reusable skills for LLM agents. CSTS uses an iterative process of generating diverse skill candidates from multiple models and then having those models collectively assess and select the most effective ones. This approach aims to create structured, generalizable skill trees that enhance LLMs' capabilities in complex task execution and tool use.

Motivation. Current skill construction paradigms generally face several limitations: (a) Skill Fragmentation , capturing merely local procedures for isolated subtasks; (b) Limited Diversity , suffering from the inherent biases of a single model; and (c) Poor Transferability , exhibiting clear performance drops across different LLM backbones. To tackle these challenges, we propose CSTS, a novel tree-search-based skill construction framework that constructs structured, diverse, and generalizable tree of skills , empowering LLMs in solving sophisticated tasks in real-world systems.
Motivation. Current skill construction paradigms generally face several limitations: (a) Skill Fragmentation , capturing merely local procedures for isolated subtasks; (b) Limited Diversity , suffering from the inherent biases of a single model; and (c) Poor Transferability , exh…
cs.AIarxiv:2606.16769v1Lead article

Skill-to-LoRA: From Using Skills to Learning Behaviors for Token-Efficient LLM Agents

Tianyi Zhang, Zhonghao Qi

his paper introduces Skill-to-LoRA (S2L), a novel method for representing and utilizing agent skills in Large Language Models (LLMs). Instead of relying on lengthy skill descriptions at runtime, S2L learns skill-specific LoRA adapters that capture the behavioral changes induced by these skills. This approach significantly reduces computational overhead and improves performance by enabling dynamic loading of learned skill behaviors.

Text skill and LoRA skill representations. Text skills keep the prompt, metadata, and full skill body in every agent step. LoRA skills use the skill body and demonstrations offline, then keep only prompt/metadata at runtime while loading LoRA weights onto the model.
Text skill and LoRA skill representations. Text skills keep the prompt, metadata, and full skill body in every agent step. LoRA skills use the skill body and demonstrations offline, then keep only prompt/metadata at runtime while loading LoRA weights onto the model.
cs.AIarxiv:2606.17016v1Lead article

TokenPilot: Cache-Efficient Context Management for LLM Agents

Buqiang Xu, Zirui Xue, Dianmou Chen, Chenyang Fu, Chiyu Wu

okenPilot tackles the rising inference costs of LLM agents by efficiently managing their context. It employs a dual-granularity approach: **Ingestion-Aware Compaction** stabilizes prompt prefixes and filters environmental noise at the entry point, while **Lifecycle-Aware Eviction** conserves context by offloading segments only when their task relevance diminishes. This method significantly reduces costs by preserving prompt cache continuity while effectively managing token footprints.

Comparison of cache alignment behaviors. While the Original Agent Loop maintains continuous layouts to achieve cumulative cache hits , previous management systems execute text truncation or compaction that mutates input boundaries, inadvertently triggering severe backend KV cache misses .
Comparison of cache alignment behaviors. While the Original Agent Loop maintains continuous layouts to achieve cumulative cache hits , previous management systems execute text truncation or compaction that mutates input boundaries, inadvertently triggering severe backend KV cache…
cs.CLarxiv:2606.17053v1Lead article

Context-Aware RL for Agentic and Multimodal LLMs

Peiyang Xu, Bangzheng Li, Sijia Liu, Karthik R. Narasimhan, Pramod Viswanath

his paper introduces ContextRL, a reinforcement learning method that enhances LLMs' ability to pinpoint crucial information within complex contexts. By training LLMs to select the correct supporting context from similar options, ContextRL encourages fine-grained grounding, leading to improved long-horizon reasoning and multimodal performance. This approach offers a novel way to supervise LLMs beyond just the final answer.

Context unawareness manifests across both agentic and multimodal systems. Left: In an agentic code-editing setting, the model has access to the relevant source file but fails to maintain consistency with the surrounding context across edits. As a result, it removes the definition of variable i i that is subsequently referenced, causing a runtime error. Right: In a multimodal reasoning setting, the model fails to correctly ground its answer in the visual evidence. Although the relevant information is present in the figure, it misreads the y y value of g ​ ( x ) g(x) as 2 2 rather than 3 3 as x → − 1 x\( \to \)-1 , leading to an incorrect prediction.
Context unawareness manifests across both agentic and multimodal systems. Left: In an agentic code-editing setting, the model has access to the relevant source file but fails to maintain consistency with the surrounding context across edits. As a result, it removes the definition…
cs.CLarxiv:2606.16897v1Lead article

Contrastive-Difference CKA Reveals Concept-Specific Structural Alignment Across Language Model Architectures

Xueping Gao

his paper introduces **Contrastive-Difference CKA (CKA_Delta)**, a novel method to analyze how different language model architectures represent high-level concepts. CKA_Delta effectively distinguishes concept-specific structural alignment from general similarity, revealing that while models show moderate geometric convergence, they exhibit near-perfect functional transfer of concepts across architectures. This finding suggests a surprising degree of structural compatibility in how diverse LLMs encode meaning.

Left: CKA \( \text{CKA}_{\Delta} \) heatmap across 8 traits and 6 model pairs. Right: Per-trait universality (mean ± \( \pm \) std); dashed line = cross-trait baseline. Trait universality ranges 1.9 × 1.9\( \times \) (helpfulness 0.829 0.829 vs. neuroticism 0.553 0.553 ).
Left: CKA \( \text{CKA}_{\Delta} \) heatmap across 8 traits and 6 model pairs. Right: Per-trait universality (mean ± \( \pm \) std); dashed line = cross-trait baseline. Trait universality ranges 1.9 × 1.9\( \times \) (helpfulness 0.829 0.829 vs. neuroticism 0.553 0.553 ).
cs.CLarxiv:2606.16905v1Lead article

Speaking the Language of Science: Toward a General-Purpose Generative Foundation Model for the Natural Sciences

Mingyang Li, Yurou Liu, Jieping Ye, Bing Su, Ji-Rong Wen

OGOS unifies diverse scientific tasks by representing scientific objects and their spatial interactions as discrete tokens within a shared autoregressive framework. This "scientific grammar" allows complex structural relationships to be captured sequentially, enabling a single model to perform various downstream tasks through next-token prediction. LOGOS demonstrates strong performance across multiple scientific domains, suggesting the potential for a general-purpose foundation model for science.

Benchmark performance of LOGOS .
Benchmark performance of LOGOS .
cs.AIarxiv:2605.31377v1Lead article

DynaTree: Dynamic Agentic Retrieval Tree for Time-Sensitive News Retrieval

Siyuan Qi, Xinyuan Wang, Yingxuan Yang, Haochuan Guo, Jianghao Lin

ynaTree addresses the limitations of existing agentic retrieval methods for time-sensitive news by proposing a two-stage framework. In an offline phase, it builds a reusable retrieval tree to map query topics, and in an online phase, it efficiently selects relevant subtrees based on time-localized proxies without further agentic reasoning. This approach significantly improves retrieval performance and reduces inference costs for time-sensitive news.

cs.AIarxiv:2605.31463v1Lead article

PithTrain: A Compact and Agent-Native MoE Training System

Ruihang Lai, Hao Kang, Haozhan Tang, Akaash R. Parthasarathy, Zichun Yu

ithTrain is a compact, agent-native MoE training system designed to simplify and accelerate the evolution of MoE frameworks. Its core method involves four agent-native design principles, enabling AI coding agents to efficiently understand, operate, and extend the framework. PithTrain's contribution is achieving production-level throughput while significantly improving "agent-task efficiency" (ATE), a new metric measuring the cost of agent interaction with training frameworks.

cs.AIarxiv:2605.31308v1Lead article

TraceGraph: Shared Decision Landscapes for Diagnosing and Improving Agent Trajectories

Junjie Nian, Kang Chen, Ge Zhang, Yixin Cao, Yugang Jiang

raceGraph transforms agent trajectories into a shared "decision landscape" by analyzing states and actions across multiple models before their identities are known. This landscape highlights productive areas and "trap" regions, allowing for a more nuanced evaluation of agent performance beyond simple scores. The paper's contribution lies in this novel visualization and analysis method, which reveals hidden differences in agent navigation strategies and informs targeted improvements like trap-aware recovery.

cs.AIarxiv:2605.31445v1Lead article

Used Car Salesbots? Honesty and Credulity of LLMs as Bargaining Agents under Partial Information

Antonio Valerio Miceli-Barone, Vaishak Belle, Shay B. Cohen

his paper investigates the bargaining capabilities of LLMs in simulated used car sales scenarios with varying information availability. It evaluates LLMs' performance against game-theoretical solutions, focusing on their honesty (disclosure/deception) and credulity (trust/distrust). The core contribution is demonstrating that off-the-shelf LLMs deviate significantly from optimal strategies, attempting to lie but failing to effectively exploit information asymmetry.

Example of negotiation where information asymmetry (buyer-unaware) induces strategic misleading communication: the seller’s true reservation price is v S = $ ​ 1.29 v_{S}=\( \mathdollar \) 1.29 , but it offers $ ​ 1.95 \( \mathdollar \) 1.95 as a “fair price”, a 51 % 51\% markup over cost. Both agents are Claude Sonnet 4.6.
Example of negotiation where information asymmetry (buyer-unaware) induces strategic misleading communication: the seller’s true reservation price is v S = $ ​ 1.29 v_{S}=\( \mathdollar \) 1.29 , but it offers $ ​ 1.95 \( \mathdollar \) 1.95 as a “fair price”, a 51 % 51\% markup …
cs.AIarxiv:2605.31556v1Lead article

Vision-Language Models Suppress Female Representations Under Ambiguous Input

Arnau Marin-Llobet, Simon Henniger, Mahzarin R. Banaji

his paper investigates how vision-language models (VLMs) handle gender bias with ambiguous visual inputs. Their core method, LALS, measures internal concept associations within the VLM's latent space. The key contribution is demonstrating that VLMs often internally encode female associations for stereotypically female occupations but still output male representations when prompted with ambiguous images, revealing a decoupling between internal knowledge and external output.

Representative Summary of Findings. Top: when gender is visually clear, VLMs report it accurately. Bottom: when the image is gender-ambiguous (faceless figures, same occupations), models default to male under forced-choice prompting, even for female-stereotyped roles.
Representative Summary of Findings. Top: when gender is visually clear, VLMs report it accurately. Bottom: when the image is gender-ambiguous (faceless figures, same occupations), models default to male under forced-choice prompting, even for female-stereotyped roles.
cs.LGarxiv:2605.31497v1Lead article

Assign and Add: A Mechanistic Study of Compositional Arithmetic

Brady Exoo, Alberto Bietti, John Sous

his paper investigates how large language models achieve compositional generalization through a mechanistic study of variable assignment and modular addition. The core method involves training small transformers on disjoint datasets and observing their ability to generalize to unseen combinations. The key contribution is demonstrating that a single "modular addition" MLP module is reused for both direct and indirectly assigned inputs, revealing a fundamental mechanism for compositional arithmetic in transformers.

cs.CLarxiv:2605.31381v1Lead article

LLM Judges Inconsistently Disagree Across Safety Criteria and Harm Categories

Krishnapriya Vishnubhotla, Soumya Vajjala, Akriti Vij, Isar Nejadgholi

his paper investigates the consistency of Large Language Models (LLMs) when used as judges for evaluating AI safety. The core finding is that LLMs are unreliable and inconsistent judges, especially for nuanced safety issues in regulated domains, and show high disagreement among themselves. This work contributes by highlighting the limitations of LLM judges and offering practical recommendations for their use in AI safety evaluation.

Reliability challenges of LLM judges across languages and judges. Our results suggest that LLM judges are less reliable when used for subjective criteria and nuanced or regulated harm categories.
Reliability challenges of LLM judges across languages and judges. Our results suggest that LLM judges are less reliable when used for subjective criteria and nuanced or regulated harm categories.
cs.CLarxiv:2605.31387v1Lead article

Multi-Turn Multi-Agent Dialogue for Collaborative Reconstruction Improves VLM Performance on Spatial Reasoning, But Only Barely

Chalamalasetti Kranti, Sherzod Hakimov, David Schlangen

his paper introduces a framework where Vision-Language Models (VLMs) engage in multi-turn dialogue to collaboratively reconstruct a target structure from visual and textual inputs. The core contribution is demonstrating that while this dialogue approach slightly improves VLM performance on spatial reasoning tasks, it reveals significant limitations in their current ability to handle complex spatial understanding, even with detailed textual descriptions.

Illustration of the two-agent structure-building task. The Programmer uses the target structure to generate instructions, and the Robot grounds these instructions into executable actions that update its grid state.
Illustration of the two-agent structure-building task. The Programmer uses the target structure to generate instructions, and the Robot grounds these instructions into executable actions that update its grid state.
cs.CLarxiv:2605.31545v1Lead article

Preference-Aware Rubric Learning for Personalized Evaluation

Yilun Qiu, Xiaoyan Zhao, Yang Zhang, Yuxin Chen, Cilin Yan

his paper introduces PARL, a novel framework for personalized LLM evaluation. PARL treats evaluation as a learning problem, directly learning preference-aware rubrics from user interaction histories. This approach aims to overcome the limitations of existing methods by capturing subjective, user-specific preferences for more effective personalized alignment.

Overview of our proposed PARL framework for inducing personalized user rubrics for evaluating LLM personalization. PARL consists of two core modules: (1) Preference Induction & Consistency Validation; (2) Discriminative Optimization via RL. The final induced rubrics serve as high-fidelity evaluation metrics for personalized text generation.
Overview of our proposed PARL framework for inducing personalized user rubrics for evaluating LLM personalization. PARL consists of two core modules: (1) Preference Induction & Consistency Validation; (2) Discriminative Optimization via RL. The final induced rubrics serve as high…
cs.CLarxiv:2605.31521v1Lead article

UniAudio-Token: Empowering Semantic Speech Tokenizers with General Audio Perception

Yuhan Song, Linhao Zhang, Aiwei Liu, Chuhan Wu, Sijun Zhang

niAudio-Token enhances semantic speech tokenizers by integrating general audio perception without sacrificing speech capabilities. It achieves this through Semantic-Acoustic Primitives for structured supervision and Semantic-Acoustic Equilibrium to adaptively restore acoustic details, resulting in comprehensive universal audio representations.

ESC-10 token sequence t-SNE Visualization. (Left) A semantic-centric baseline (GLM-4-Voice-Tokenizer) suffers from acoustic blindness, mapping distinct events to overlapping regions. (Center Left) An acoustic-centric baseline (WavTokenizer) exhibits insufficient semantic discrimination. (Center Right) UniAudio-Token resolves these issues via Semantic-Acoustic Equilibrium, forming well-separated clusters. (Right) When integrated with Qwen2.5-3B, UniAudio-Token shows superior performance on the MMAU benchmark.
ESC-10 token sequence t-SNE Visualization. (Left) A semantic-centric baseline (GLM-4-Voice-Tokenizer) suffers from acoustic blindness, mapping distinct events to overlapping regions. (Center Left) An acoustic-centric baseline (WavTokenizer) exhibits insufficient semantic discrimi…
cs.CLarxiv:2605.31561v1Lead article

What Am I Missing? Question-Answering as Hidden State Probing

Chu Fei Luo, Samuel Dahan, Xiaodan Zhu

his paper proposes using question-asking as an inference-time intervention to probe the hidden state of Large Language Models (LLMs) during reasoning. By training a "probe" on the LLM's internal states before and after it generates questions, the researchers found this self-diagnosis process predicts the final answer's correctness, suggesting the value lies in the model's internal reflection rather than external information.

An illustration of our experimental setting. There is a student \( \theta \) that generates a partial solution \( \tau \) for a problem. The decisions of what to ask and when to ask are determined by a gating policy \( \pi \) . First, it chooses a step in the reasoning trajectory to pause the generation. We sample n n questions from the student and choose the best one by predicted correctness to be sent to the teacher T T . The student then incorporates the answer into a rewrite of the uncertain step.
An illustration of our experimental setting. There is a student \( \theta \) that generates a partial solution \( \tau \) for a problem. The decisions of what to ask and when to ask are determined by a gating policy \( \pi \) . First, it chooses a step in the reasoning trajectory…
cs.AIarxiv:2606.02461v1Lead article

AGENTCL: Toward Rigorous Evaluation of Continual Learning in Language Agents

Yiheng Shu, Bernal Jiménez Gutiérrez, Saisri Padmaja Jonnalagedda, Yuguang Yao, Huan Sun

his paper introduces AgentCL, a rigorous evaluation framework for continual learning in language agents. Its core method involves constructing controlled, compositional task streams that allow for the systematic reuse of prior sub-solutions and evidence. AgentCL's main contribution is enabling a deeper understanding of how agents learn and transfer knowledge across tasks, addressing limitations in existing benchmarks.

Task-stream construction and its impact on evaluation. Compositional relationship refers to a task pair, where the complex one can reuse the solution to the simpler one. Sequential relationship refers to the sequential order of task execution. Top : naive streams order tasks from the same domain without guaranteeing reuse relationships, while compositional streams place reusable subtasks before related complex tasks. Bottom : boxplots of average accuracy across evaluated methods on CodeEval-Pro and BrowseComp+, showing that compositional streams yield larger method separation than naive streams for memory reuse.
Task-stream construction and its impact on evaluation. Compositional relationship refers to a task pair, where the complex one can reuse the solution to the simpler one. Sequential relationship refers to the sequential order of task execution. Top : naive streams order tasks from…
cs.AIarxiv:2606.02386v1Lead article

AgentPLM: Agentic Protein Language Models with Reasoning-Augmented Decoding for Protein Sequence Design

Sahil Rahman, Maxx Richard Rahman

gentPLM introduces a novel approach to protein sequence design by augmenting traditional language models with a reasoning and feedback loop. Its core method, Reasoning-Augmented Decoding (RAD), interleaves sequence generation with calls to biophysical simulation tools. This allows the model to iteratively refine sequences based on predicted thermodynamic and structural constraints, leading to improved design performance across various protein engineering tasks.

AgentPLM architecture comprising four modules, i) Expanded Vocabulary and Tool-Call Token Initialisation, ii) Trajectory Memory Buffer (TMB), iii) Reasoning-Augmented Decoding (RAD), and iv) trained end-to-end via the CAPO objective.
AgentPLM architecture comprising four modules, i) Expanded Vocabulary and Tool-Call Token Initialisation, ii) Trajectory Memory Buffer (TMB), iii) Reasoning-Augmented Decoding (RAD), and iv) trained end-to-end via the CAPO objective.
cs.AIarxiv:2606.02497v1Lead article

Bridging the Last Mile of Time Series Forecasting with LLM Agents

Yuhua Liao, Zetian Wang, Qiangqiang Nie, Zhenhua Zhang

his paper addresses the "last-mile forecasting" problem, where raw statistical forecasts are revised with unstructured business context. The core method is an LLM-agent framework that sits atop a forecasting backbone, using tools to retrieve contextual evidence and perform reasoned forecast revisions under safety constraints. Its contribution is a practical system that bridges the gap between statistical forecasts and decision-ready predictions by incorporating real-world business knowledge.

System overview of the proposed last-mile forecasting framework. A forecasting backbone first produces a baseline trajectory; an LLM agent then operates over a shared forecast workspace, retrieves contextual evidence through tools, applies validated revision actions to y final y_{\( \text{final} \)} , and accumulates reflection memories in a persistent memory bank for retrieval by subsequent sessions.
System overview of the proposed last-mile forecasting framework. A forecasting backbone first produces a baseline trajectory; an LLM agent then operates over a shared forecast workspace, retrieves contextual evidence through tools, applies validated revision actions to y final y_…
cs.AIarxiv:2606.02568v1Lead article

ClinEnv: An Interactive Multi-Stage Long Horizon EHR Environment for Agents

Yuxing Lu, Yushuhong Lin, Wenqi Shi, J. Ben Tamo, Xukai Zhao

linEnv is an interactive benchmark designed to evaluate LLMs as attending physicians in a simulated inpatient setting. Its core method involves presenting agents with real patient admissions as a sequence of decision stages, requiring them to actively query specialized agents for information before making irreversible choices. The contribution lies in its realistic simulation of clinical practice, which emphasizes incremental information gathering and sequential decision-making under uncertainty, and its scoring of both decision accuracy and information-seeking process.

Overview of ClinEnv . Patients’ admissions are preprocessed into event timelines, converted into multi-stage cases via a five-step pipeline, and evaluated in an interactive environment where the model queries specialized agents before committing decisions, scored on both process and outcome quality.
Overview of ClinEnv . Patients’ admissions are preprocessed into event timelines, converted into multi-stage cases via a five-step pipeline, and evaluated in an interactive environment where the model queries specialized agents before committing decisions, scored on both process …
cs.AIarxiv:2606.02373v1Lead article

Harness-1: Reinforcement Learning for Search Agents with State-Externalizing Harnesses

Pengcheng Jiang, Zhiyi Shi, Kelly Hong, Xueqiang Xu, Jiashuo Sun

his paper proposes Harness-1, a reinforcement learning search agent that offloads routine state management to an external "harness." The harness handles complex bookkeeping like candidate pools and evidence tracking, allowing the policy to focus on semantic search decisions. This separation improves learning efficiency by simplifying the policy's task.

cs.AIarxiv:2606.02449v1Lead article

HLL: Can Agents Cross Humanity's Last Line of Verification?

Xinhao Song, Su Su, Sirui Song, Hongliang Wu, Wen Shen

his paper introduces Humanity's Last Line of Verification (HLL), a benchmark designed to test if multimodal AI agents can bypass CAPTCHAs, which are human-verification barriers. HLL uses interactive CAPTCHAs and controlled stressors to evaluate agents' ability to perform human-like interactions, not just recognition, within a GUI environment. The core contribution is a novel evaluation method for assessing agent robustness against automated bypass of critical human-verification systems.

CAPTCHA as the final frontier: securing web services by testing interactive, human-level reasoning against automated agents.
CAPTCHA as the final frontier: securing web services by testing interactive, human-level reasoning against automated agents.
cs.AIarxiv:2606.02484v1Lead article

Iteris: Agentic Research Loops for Computational Mathematics

Leheng Chen, Zihao Liu, Wanyi He, Bin Dong

teris is an agentic AI system designed to tackle open problems in computational mathematics. Its core method involves generating numerical evidence, constructions, and proof drafts, which are then refined by human experts. The paper's contribution is demonstrating Iteris's capability to produce verified results on challenging open problems, specifically a phase diagram for iterative solvers and a counterexample for a conjecture.

Iteris agent
Iteris agent
cs.AIarxiv:2606.02470v1Lead article

MCP-Persona: Benchmarking LLM Agents on Real-World Personal Applications via Environment Simulation

Wenhao Wang, Peizhi Niu, Gongyi Zou, Xiyuan Yang, Jingxing Wang

his paper introduces MCP-Persona, a novel benchmark for evaluating LLM agents on real-world personal applications that use the Model Context Protocol (MCP). Unlike existing benchmarks, MCP-Persona focuses on personalized tools like social media and collaboration suites. The benchmark reveals that current state-of-the-art agents struggle significantly with effectively using these personalized tools.

System overview of MCP-Persona, which is built upon the interaction of Tools , Contexts , and Tasks . For each component, we introduce a dedicated method, described in detail as Tool-Traverse (§ 3.1 ), Context-Tree (§ 3.2 ), and Persona-Gen (§ 3.3 ).
System overview of MCP-Persona, which is built upon the interaction of Tools , Contexts , and Tasks . For each component, we introduce a dedicated method, described in detail as Tool-Traverse (§ 3.1 ), Context-Tree (§ 3.2 ), and Persona-Gen (§ 3.3 ).
cs.AIarxiv:2606.02578v1Lead article

Mitigating Perceptual Judgment Bias in Multimodal LLM-as-a-Judge via Perceptual Perturbation and Reward Modeling

Seojeong Park, Jiho Choi, Junyong Kang, Seonho Lee, Jaeyo Shin

his paper addresses "Perceptual Judgment Bias" in multimodal LLMs used as judges, where they favor plausible text over visual accuracy. The core method involves creating a dataset of minimally perturbed visual examples to isolate perceptual errors and then training a reward model using a GRPO-based approach and batch ranking. This allows for more reliable and perceptually grounded evaluations by multimodal LLMs.

Perceptual judgment bias in MLLM judges. (a) When perceptual capability is insufficient, a judge may produce incorrect visual descriptions (a2) {}_{\( \texttt{(a2)} \)} and assign high scores (a3) {}_{\( \texttt{(a3)} \)} to perceptually wrong responses (a2) {}_{\( \texttt{(a2)} \)} . (b) Even when the judge’s own perception aligns with humans (b2) {}_{\( \texttt{(b2)} \)} , it may still prefer (b5) {}_{\( \texttt{(b5)} \)} visually inconsistent responses (b3) {}_{\( \texttt{(b3)} \)} compared to the response with correct perception (b4) {}_{\( \texttt{(b4)} \)} . We introduce Perception-Judge , an MLLM judge trained with reinforcement learning on a systematically designed perception-grounded dataset, PPJD , which effectively mitigates these perceptual biases in MLLM judgment , (b6) (a4) {}_{\( \texttt{(a4)} \)},_{\( \texttt{(b6)} \)} .
Perceptual judgment bias in MLLM judges. (a) When perceptual capability is insufficient, a judge may produce incorrect visual descriptions (a2) {}_{\( \texttt{(a2)} \)} and assign high scores (a3) {}_{\( \texttt{(a3)} \)} to perceptually wrong responses (a2) {}_{\( \texttt{(a2)} …
cs.AIarxiv:2606.02522v1Lead article

Moment-Video: Diagnosing Temporal Fidelity of Video MLLMs on Momentary Visual Events

Xiaolin Liu, Yilun Zhu, Xiangyu Zhao, Xuehui Wang, Yan Li

his paper introduces Moment-Video, a new benchmark designed to evaluate how well video multimodal large language models (MLLMs) can understand brief, critical visual events. The core method involves creating questions that hinge on short-lived visual occurrences, testing the models' ability to detect and reason about these fleeting moments. Moment-Video's contribution is to highlight and diagnose a crucial weakness in current video MLLMs: their difficulty in preserving and utilizing information from transient visual evidence, which is vital for answering many practical questions.

Overview of Moment-Video . Left: domain and subcategory taxonomy. Right: evaluation protocols for closed-ended and open-ended questions.
Overview of Moment-Video . Left: domain and subcategory taxonomy. Right: evaluation protocols for closed-ended and open-ended questions.
cs.AIarxiv:2606.02430v1Lead article

Not All Errors Are Equal: A Systematic Study of Error Propagation in Large Language Model Inference

Yafan Huang, Sheng Di, Guanpeng Li

his paper introduces LLMFI, a novel fault-injection framework, to systematically study how soft errors propagate during Large Language Model (LLM) inference. By injecting faults across various LLMs and tasks, the study reveals critical vulnerability patterns and provides practical, low-overhead software-only solutions to enhance LLM reliability.

Figure 1 . Challenges for modeling errors for LLM inference.
Figure 1 . Challenges for modeling errors for LLM inference.
cs.AIarxiv:2606.02282v1Lead article

POIROT: Interrogating Agents for Failure Detection in Multi-Agent Systems

Iñaki Dellibarda Varela, R. Sendra-Arranz, Pablo Romero-Sorozabal, J. M. Valverde-García, Annemarie F. Laudanski

OIROT is a novel protocol that uses the agents within a Multi-Agent System (MAS) itself to detect failures, rather than relying on external evaluators. This "interrogation" approach leverages the inherent diversity of the agents' knowledge to identify issues like hallucinations. POIROT significantly outperforms traditional single-agent evaluation methods, especially as system complexity and the number of agents increase.

Structural limitations of existing evaluation paradigms and the POIROT alternative. Human evaluation, LLM-as-a-judge, and single-model self-evaluation address different aspects of output assessment but exhibit structural limitations. Human evaluation provides robustness against memory-related errors but suffers from limited scalability and domain dependence. LLM-as-a-judge improves scalability yet remains vulnerable to context saturation, domain-specific design requirements, and single-evaluator bias. Self-evaluation enables iterative refinement but inherits memory constraints and centralized bias. POIROT introduces a structured multi-agent interrogation protocol that distributes reasoning across agents and mitigates context saturation, scalability constraints, domain dependence, and single-evaluator bias through coordinated consensus.
Structural limitations of existing evaluation paradigms and the POIROT alternative. Human evaluation, LLM-as-a-judge, and single-model self-evaluation address different aspects of output assessment but exhibit structural limitations. Human evaluation provides robustness against m…
cs.AIarxiv:2606.02322v1Lead article

Repurposing Adversarial Perturbations for Continual Learning: From Defense to Active Alignment

Ran Liu, Min Yu, Mingqi Liu, Jianguo Jiang, Gang Li

his paper proposes AdvCL, a novel continual learning method that repurposes adversarial perturbations to stabilize model adaptation. By employing three plug-in modules (Intra-Smooth, Proto-Clip, and Inter-Align), AdvCL promotes local smoothness, prevents over-alignment to new tasks, and actively aligns representations with previous tasks. This approach effectively reduces forgetting, enhances transfer learning, and improves robustness against adversarial attacks.

Illustration of local smoothing and directional alignment in representation space.
Illustration of local smoothing and directional alignment in representation space.
cs.AIarxiv:2606.06448v1Lead article

Agent Memory: Characterization and System Implications of Stateful Long-Horizon Workloads

Yasmine Omri, Ziyu Gan, Zachary Broveak, Robin Geens, Zexue He

his paper characterizes the system implications of agent memory for long-horizon LLM tasks. It introduces a taxonomy for memory systems, a profiling harness to measure costs, and analyzes ten representative systems. The key contribution is uncovering how design choices impact memory construction and retrieval costs, leading to practical system recommendations for efficient agent memory management.

cs.AIarxiv:2606.06462v1Lead article

Benchmark Everything Everywhere All at Once

Shiyun Xiong, Dongming Wu, Peiwen Sun, Yuang Ai, Bokang Yang

his paper introduces Benchmark Agent, an autonomous system that automates the entire benchmark creation process for LLMs and MLLMs. Its core method involves orchestrating user query analysis, subtask design, data annotation, and quality control. The main contribution is a sustainable and scalable approach to generating diverse, high-quality benchmarks that can effectively differentiate state-of-the-art models.

Our Benchmark Agent, as the first fully autonomous benchmark building system, can efficiently produce high-quality benchmarks across diverse modalities, tasks, and domains to meet user-specific requirements. It will offer rapidly evolving benchmarks to contribute to the community.
Our Benchmark Agent, as the first fully autonomous benchmark building system, can efficiently produce high-quality benchmarks across diverse modalities, tasks, and domains to meet user-specific requirements. It will offer rapidly evolving benchmarks to contribute to the community…
cs.AIarxiv:2606.06388v1Lead article

Humans' ALMANAC: A Human Collaboration Dataset of Action-Level Mental Model Annotations for Agent Collaboration

Jiaju Chen, Yuxuan Lu, Jiayi Su, Chaoran Chen, Songlin Xiao

his paper introduces ALMANAC, a novel dataset designed to improve agent collaboration. It addresses the lack of data on human collaborative processes by providing action-level annotations of participants' mental models during a dyadic routing task. This dataset aims to guide LLM agents towards better understanding and aligning with human collaborators' intentions and goals.

A sample data of Almanac , which contains participants’ actions, mental models (team goal, perceived partner intent, self-reasoning), and a free-form rationale. We implement the Map Task, a classic dyadic routing task, to collect human collaborative behaviors and action-level mental model annotations.
A sample data of Almanac , which contains participants’ actions, mental models (team goal, perceived partner intent, self-reasoning), and a free-form rationale. We implement the Map Task, a classic dyadic routing task, to collect human collaborative behaviors and action-level men…
cs.AIarxiv:2606.06315v1Lead article

LLM Self-Recognition: Steering and Retrieving Activation Signatures

Thibaud Ardoin, Jonas Schäfer, Gerhard Wunder

his paper introduces a method for LLMs to "self-recognize" their own outputs by embedding a detectable fingerprint within their internal activations. By steering the residual stream with a sparse vector during generation, the LLM creates a unique signature that can be reliably retrieved by another LLM, achieving high accuracy in attribution. This approach leverages the model's inherent structure for content provenance, offering a practical alternative to external watermarking methods.

cs.AIarxiv:2606.06337v1Lead article

TokenMizer: Graph-Structured Session Memory for Long-Horizon LLM Context Management

Shweta Mishra

okenMizer addresses the LLM context window limitation by modeling session history as a typed knowledge graph, preserving crucial structured information. Its core method involves a hybrid extraction pipeline to build this graph, a multi-tier checkpoint system for serialization, and an 8-layer compression pipeline to reduce token overhead. This approach significantly improves token economy and enables resumable long-horizon LLM sessions by retaining relational structure, unlike previous flat-text methods.

TokenMizer system architecture. The proxy sits transparently between any OpenAI-compatible client and the LLM provider. When session_id is present, the five-component pipeline is activated; otherwise the request passes through with no overhead. Persistent storage comprises a SQLite graph database and a JSON checkpoint store.
TokenMizer system architecture. The proxy sits transparently between any OpenAI-compatible client and the LLM provider. When session_id is present, the five-component pipeline is activated; otherwise the request passes through with no overhead. Persistent storage comprises a SQLi…
cs.AIarxiv:2606.06240v1Lead article

TOKI: A Bitemporal Operator Algebra for Contradiction Resolution in LLM-Agent Persistent Memory

Ziming Wang

his paper introduces TOKI, a bitemporal operator algebra for managing persistent memory in LLM agents. TOKI formalizes contradiction resolution as a form of write-time concurrency control, explicitly defining isolation preconditions and provenance for existing heuristics. Its core contribution is providing formal guarantees for these heuristics and their pipelines, ensuring reliable and auditable belief updates.

Figure 1. Contradiction resolution as write-time concurrency control. A bitemporal substrate detects a contradicting pair on a subject-predicate key; an isolation gate routes it to one of four typed operators, each pinned to the isolation level that excludes the anomaly a weaker level admits; every operator commits a current row beside an audit row under one schema. The soundness theorems close the isolation, schema, and provenance axes.
Figure 1. Contradiction resolution as write-time concurrency control. A bitemporal substrate detects a contradicting pair on a subject-predicate key; an isolation gate routes it to one of four typed operators, each pinned to the isolation level that excludes the anomaly a weaker …
cs.AIarxiv:2606.06356v1Lead article

Where Should Knowledge Enter? A Layered Framework for Knowledge Infusion in Multimodal Iterative Generative Mo

Renjith Prasad, Chathurangi Shyalika, Anushka Pawar, Amit Sheth

his paper proposes a layered framework for integrating knowledge into multimodal generative models. It categorizes knowledge infusion based on which part of the iterative generation process is modified: input/output (surface), state transitions (trajectory), intermediate states (latent), or model parameters (parametric). This framework provides a systematic way to understand and design knowledge-aware generative systems.

Four intervention layers for knowledge infusion in iterative generative models. External knowledge acts on four structurally distinct components of the generation trajectory: surface (input/output boundary), trajectory (transition rule f θ f_{\( \theta \)} ), latent (intermediate states h t h_{t} ), and parametric (model weights \( \theta \) ). This enables complementary coverage of prompt-level, structural, and distributional violations.
Four intervention layers for knowledge infusion in iterative generative models. External knowledge acts on four structurally distinct components of the generation trajectory: surface (input/output boundary), trajectory (transition rule f θ f_{\( \theta \)} ), latent (intermediate…
cs.LGarxiv:2606.06238v1Lead article

Generative Criticality in Large Language Model Temperature Scaling

Huajian Ruan, Jinyang Li, Xingyu Guo, Lingxiao Wang

his paper introduces a statistical-field framework to analyze LLM text generation, modeling token embeddings as spins on a chain. They observe a sharp peak in susceptibility and a rapid change in an order parameter near a characteristic temperature $T_c$, indicating a phase transition-like behavior. This phenomenon, robust across model sizes, suggests a critical point in LLM generation that influences semantic direction.

cs.LGarxiv:2606.06447v1Lead article

Latent Reasoning with Normalizing Flows

Guancheng Tu, Xiangjun Fu, Suhao Yu, Yao Tang, Haoqiang Kang

his paper proposes NF-CoT, a novel latent reasoning framework for large language models. It leverages normalizing flows to represent intermediate reasoning steps in continuous latent spaces, offering a higher-bandwidth alternative to explicit textual chain-of-thought. NF-CoT's core contribution is preserving the advantages of traditional autoregressive generation, such as left-to-right generation and probabilistic sampling, while enabling efficient and effective latent reasoning.

Four paradigms for chain-of-thought reasoning. Explicit CoT : discrete text tokens. Coconut : deterministic hidden states. LaDiR : iteratively denoised latents using diffusion. NF-CoT (ours) : AR-sampled continuous thoughts.
Four paradigms for chain-of-thought reasoning. Explicit CoT : discrete text tokens. Coconut : deterministic hidden states. LaDiR : iteratively denoised latents using diffusion. NF-CoT (ours) : AR-sampled continuous thoughts.
cs.LGarxiv:2606.06302v1Lead article

Tangram: Unlocking Non-Uniform KV Cache for Efficient Multi-turn LLM Serving

Hyungmin Kim, Minsoo Kim, Hongseok Kim, Jungwook Choi

angram addresses the inefficiency of non-uniform KV caching in multi-turn LLM serving by introducing a novel system. Its core method involves deterministic budget allocation for KV cache heads, eliminating scheduling overhead and prefill stalls. This approach unlocks efficient utilization of non-uniform KV caches, significantly improving LLM serving performance.

Figure 1 . (a) KV cache size growth for Qwen2.5-32B with the number of conversation sessions (top, # requests = 16) or with the # of requests (bottom, session number = 10). The dashed line indicates the model weight size. (b) Comparison of uniform and non-uniform KV compression strategies at a 50% compression rate, where the numbers in each box denote the importance score of each KV entry.
Figure 1 . (a) KV cache size growth for Qwen2.5-32B with the number of conversation sessions (top, # requests = 16) or with the # of requests (bottom, session number = 10). The dashed line indicates the model weight size. (b) Comparison of uniform and non-uniform KV compression s…
cs.CLarxiv:2606.06428v1Lead article

Reinforcement Learning Elicits Contextual Learning of Unseen Language Translation

Hanxu Hu, Zdeněk Šnajdr, Pinzhen Chen, Jannis Vamvas, Rico Sennrich

his paper proposes a reinforcement learning (RL) method to enable large language models (LLMs) to translate unseen languages by learning to utilize provided linguistic context. Instead of memorizing specific languages, the RL agent learns a meta-skill to extract and apply relevant information from the context, leading to improved zero-shot translation performance on entirely new languages. This approach offers a more generalizable way to handle extremely low-resource translation compared to traditional fine-tuning or in-context learning.

Train–test context mismatch (RL, Qwen3-4B-Base). Test-time context dominates: no/full > full/no in every panel (En → \( \to \) Kal: 0.28 0.28 vs. 0.17 0.17 ).
Train–test context mismatch (RL, Qwen3-4B-Base). Test-time context dominates: no/full > full/no in every panel (En → \( \to \) Kal: 0.28 0.28 vs. 0.17 0.17 ).
cs.AIarxiv:2606.07379v1Lead article

Do Coding Agents Deceive Us? Detecting and Preventing Cheating via Capped Evaluation with Randomized Tests

Thanawat Lodkaew, Johannes Ackermann, Soichiro Nishimori, Nontawat Charoenphakdee, Masashi Sugiyama

his paper addresses deceptive performance in coding agents, where models exploit shortcuts to achieve high scores without true task mastery. They propose CapCode, a framework generating datasets with randomized tests capped below perfect scores, making cheating evident when models exceed this cap. Additionally, CapReward is introduced to discourage cheating during training by aligning rewards with the capped performance principle, leading to agents that better adhere to task specifications.

Conceptual illustrations of CapCode and CapReward. CapCode (left) is a dataset-construction framework with a capped achievable pass rate, enabling deceptively high performance detection. CapReward (right) is a reward design method that discourages reward hacking by penalizing pass rates that exceed the cap.
Conceptual illustrations of CapCode and CapReward. CapCode (left) is a dataset-construction framework with a capped achievable pass rate, enabling deceptively high performance detection. CapReward (right) is a reward design method that discourages reward hacking by penalizing pas…
cs.AIarxiv:2606.07299v1Lead article

DuMate-DeepResearch: An Auditable Multi-Agent System with Recursive Search and Rubric-Grounded Reasoning

Lingyong Yan, Can Xu, Yukun Zhao, Wenxuan Li, Qingyang Chen

uMate-DeepResearch is a multi-agent framework for complex research tasks that addresses limitations in current Deep Research systems. Its core method decouples task planning and execution into an Agent Core and an extensible Tool Ecosystem, enabling explicit traceability of decisions and tool usage. This design enhances auditability and mitigates risks like hallucination and planning bottlenecks.

The illustration for the Qianfan Agent Foundry.
The illustration for the Qianfan Agent Foundry.
cs.AIarxiv:2606.07316v1Lead article

Hierarchical Certified Semantic Commitment for Byzantine-Resilient LLM-Agent Collaboration

Haoran Xu, Lei Zhang, Iadh Ounis, Xianbin Wang

his paper introduces Hierarchical Certified Semantic Commitment (H-CSC), a novel Byzantine Fault Tolerance (BFT) protocol for LLM agents. H-CSC addresses the challenge of reaching consensus on natural language proposals by converting embedding-derived signals into three distinct outcomes: a semantic commit, a verdict commit, or a typed abort. Its core contribution is a BFT-inspired mechanism that provides robust, semantically-aware finality for LLM agent collaboration.

cs.AIarxiv:2606.07489v1Lead article

How AI Agents Reshape Knowledge Work: Autonomy, Efficiency, and Scope

Jeremy Yang, Kate Zyskowski, Noah Yonack, Jerry Ma

his paper investigates how autonomous AI agents, exemplified by Perplexity's "Computer" product, transform knowledge work compared to conversational assistants like "Search." The core method involves analyzing production data to compare task execution times and user behavior. The key contribution is demonstrating that autonomous agents significantly accelerate knowledge work by performing end-to-end task execution, leading to increased efficiency, automation of complex steps, and a shift towards higher-order cognitive tasks for users.

AI product progression by autonomy and workflow-context integration. Perplexity’s Search represents the baseline for information retrieval and synthesis; Comet Assistant introduces deeper context integration and execution on top of an interactive browser interface; Computer combines long-horizon asynchronous execution with even deeper and broader context integration as an agent orchestrator.
AI product progression by autonomy and workflow-context integration. Perplexity’s Search represents the baseline for information retrieval and synthesis; Comet Assistant introduces deeper context integration and execution on top of an interactive browser interface; Computer combi…
cs.AIarxiv:2606.07512v1Lead article

MemDreamer: Decoupling Perception and Reasoning for Long Video Understanding via Hierarchical Graph Memory and Agentic Retrieval Mechanism

Cong Chen, Guo Gan, Kaixiang Ji, ChaoYang Zhang, Zhen Yang

emDreamer tackles long video understanding by decoupling perception and reasoning. It builds a Hierarchical Graph Memory to semantically abstract video content and uses an agentic retrieval mechanism to efficiently query this memory for reasoning, achieving state-of-the-art results with significantly reduced computational cost.

cs.AIarxiv:2606.07392v1Lead article

Online Pandora's Box for Contextual LLM Cascading

Alexandre Belloni, Yan Chen, Yehua Wei

his paper introduces an "online contextual Pandora's Box" method for adaptively selecting Large Language Model (LLM) APIs. The core innovation is a two-phase decision process where the system queries APIs sequentially, incurring costs, and then selects an output based on observed rewards. The key contribution lies in directly modeling and learning a "reservation index" for each API, bypassing the need to estimate full output and cost distributions.

cs.AIarxiv:2606.07313v1Lead article

SV-Detect: AI-generated Text Detection with Steering Vectors

Mikhail Vishnyakov, Tatiana Gaintseva

his paper introduces SV-Detect, a novel AI-generated text detection method that utilizes "steering vectors" derived from a frozen language model's hidden states. These vectors capture directions that distinguish human from machine text at each layer, and the detector classifies text based on its alignment with these directions. SV-Detect demonstrates robust performance even under distribution shifts, offering a new perspective on fake-text detection as a representation-space probing problem.

Token-level steering-vector projections distinguish LLM-generated text (top) from human writing (bottom). Word saturation reflects each token’s signed contribution to the classifier.
Token-level steering-vector projections distinguish LLM-generated text (top) from human writing (bottom). Word saturation reflects each token’s signed contribution to the classifier.
cs.AIarxiv:2606.07237v1Lead article

When Large Language Models Fail in Healthcare: Evaluating Sensitivity to Prompt Variations

Mahdi Alkaeed

his paper investigates how sensitive Large Language Models (LLMs), including those specialized for medicine, are to small changes in input prompts. The core method involves a systematic sensitivity analysis on the MedMCQA benchmark, categorizing prompt variations as natural or adversarial. The key contribution is demonstrating that even medical LLMs are not inherently robust, showing that minor prompt alterations can lead to inconsistent or even harmful clinical advice, highlighting significant risks for healthcare applications.

This methodological pipeline outlines a comprehensive robustness evaluation framework for assessing the sensitivity and stability of healthcare LLMs using the MedMCQA benchmark, supported by advanced NLP tools (e.g., BioSyn, scispaCy) and biomedical metrics (e.g., BERTScore, USE) to quantify model resilience to input variations.
This methodological pipeline outlines a comprehensive robustness evaluation framework for assessing the sensitivity and stability of healthcare LLMs using the MedMCQA benchmark, supported by advanced NLP tools (e.g., BioSyn, scispaCy) and biomedical metrics (e.g., BERTScore, USE)…
cs.LGarxiv:2606.07345v1Lead article

TabSwift: An Efficient Tabular Foundation Model with Row-Wise Attention

Si-Yang Liu, Han-Jia Ye

abSwift is an efficient tabular foundation model that leverages a lightweight row-wise attention mechanism. By incorporating a gated attention stabilization and learnable register tokens, it achieves competitive accuracy with state-of-the-art models while significantly reducing inference costs. This makes TabSwift a practical solution for real-world applications requiring fast predictions on tabular data.

Performance–efficiency–size comparison on the Talent benchmark. Each model is plotted by its average rank (lower is better, x-axis) and average inference time (lower is better, y-axis); bubble area encodes model size. Following the convention of Talent (Ye et al., 2024 ) , the ⋆ \( \star \) marks the ideal point —a hypothetical model with both the best predictive performance and the lowest inference latency. TabSwift (ours) is the orange marker labeled “3”. TabSwift attains an average rank comparable to other TFMs but at substantially lower inference cost, illustrating a markedly better accuracy–efficiency trade-off.
Performance–efficiency–size comparison on the Talent benchmark. Each model is plotted by its average rank (lower is better, x-axis) and average inference time (lower is better, y-axis); bubble area encodes model size. Following the convention of Talent (Ye et al., 2024 ) , the ⋆ …
cs.CLarxiv:2606.07219v1Lead article

Adversarial Creation and Detection of AI-Generated Social Bot Content

Mykola Trokhymovych, Ricardo Baeza-Yates, Alessandro Flammini, Diego Saez-Trumper, Filippo Menczer

his paper proposes an adversarial methodology to create and detect AI-generated social bot content. By modeling malicious actors impersonating real users, they generate a unique, multilingual dataset of paired human and AI messages. This adversarial training significantly improves the accuracy of AI-generated text detection, outperforming existing methods on real-world data.

Pipeline for content-based detection of AI-powered social bots.
Pipeline for content-based detection of AI-powered social bots.
cs.CLarxiv:2606.07513v1Lead article

Agentopia: Long-Term Life Simulation and Learning in Agent Societies

Xintao Wang, Sirui Zheng, Hongqiu Wu, Weiyuan Li, Jen-tse Huang

gentopia introduces a framework for simulating long-term (10 years) life in agent societies powered by LLMs. Its core method involves agents autonomously pursuing growth, relationships, and goals within this extended simulation. The paper's contribution is demonstrating how such prolonged social experience can foster emergent social behaviors and enhance LLMs' anthropomorphic capabilities, particularly in social intelligence.

Illustration of emergent behaviors observed in Agentopia simulations. Each scene depicts a real behavioral pattern documented in our case studies (Tables 22 – 34 ). Without explicit scripting, agents autonomously develop diverse behavioral patterns reflecting agents’ intelligence in social life.
Illustration of emergent behaviors observed in Agentopia simulations. Each scene depicts a real behavioral pattern documented in our case studies (Tables 22 – 34 ). Without explicit scripting, agents autonomously develop diverse behavioral patterns reflecting agents’ intelligence…
cs.CLarxiv:2606.07402v1Lead article

M$^3$Exam: Benchmarking Multimodal Memory for Realistic User-Agent Interactions

Zhengjun Huang, Wenxuan Liu, Zhoujin Tian, Wei Chen, Junle Chen

his paper introduces M$^3$Exam, a novel benchmark for evaluating language agents' ability to reason over realistic, accumulating multimodal information from user interactions. Its core contribution is a query-centric approach that assesses cross-modal grounding and implicit information inference, revealing significant gaps in current models. The authors also propose M$^3$Proctor, a memory method that improves accuracy and efficiency by selectively processing visual data.

Overview of M 3 Exam .
Overview of M 3 Exam .
cs.CLarxiv:2606.07297v1Lead article

SWE-Explore: Benchmarking How Coding Agents Explore Repositories

Shaoqiu Zhang, Yuhang Wang, Jialiang Liang, Yuling Shi, Wenhao Zeng

WE-Explore is a new benchmark designed to evaluate how coding agents explore software repositories. Instead of just checking if a task is solved, it measures an agent's ability to identify relevant code regions for a given issue within a limited budget. This allows for a more granular assessment of crucial exploration skills like understanding context and localizing code.

Motivation of SWE-Explore. A holistic metric of resolution rate conflates exploration, localization, and patch synthesis. SWE-Explore isolates repository exploration as a line-level evaluation target.
Motivation of SWE-Explore. A holistic metric of resolution rate conflates exploration, localization, and patch synthesis. SWE-Explore isolates repository exploration as a line-level evaluation target.
cs.CLarxiv:2606.07441v1Lead article

Sycophantic Praise: Evaluating Excessive Praise in Language Models

Daniel Vennemeyer, Phan Anh Duong, Meryl Ye, Ruihong Huang, Tianyu Jiang

his paper introduces a new method to measure "sycophantic praise" in language models, which is defined as excessive flattery beyond what a contribution warrants. Their parameterized framework evaluates praise against contribution quality and user ability, outperforming generic LLM judges in agreement with human annotations. The study highlights that sycophantic praise is a distinct alignment problem, more prevalent in social and interpretive tasks than in objective reasoning.

The same model response may be appropriate or excessive depending on the user’s expected ability and contribution quality. SyPr measures excess praise as the difference between observed praise P ​ ( r ) P(r) in the response r r , and contextually warranted praise W ​ ( p , u ) W(p,u) , where warranted praise depends on both the persona context p p and the user utterance u u .
The same model response may be appropriate or excessive depending on the user’s expected ability and contribution quality. SyPr measures excess praise as the difference between observed praise P ​ ( r ) P(r) in the response r r , and contextually warranted praise W ​ ( p , u ) W(…
cs.AIarxiv:2606.09613v1Lead article

AGENTSERVESIM: A Hardware-aware Simulator for Multi-Turn LLM Agent Serving

Rakibul Hasan Rajib, Mengxin Zheng, Qian Lou

GENTSERVESIM is a hardware-aware simulator designed to evaluate multi-turn LLM agent serving policies. Its core method involves simulating agent execution at a program level, accounting for stateful dynamics like turn dependencies and KV-cache management during tool invocations. This enables scalable and cost-effective evaluation of serving strategies that are crucial for the complex, stateful nature of LLM agents.

AgentServeSim architecture. The Program Orchestrator advances each program turn by turn, routing New Turn events through the Session-Aware Router to a Model Serving Group. There, the scheduler queues turns, the KV Residency Model manages KV state across memory tiers, and the System Simulator executes the resulting operator graphs. After Turn Complete, the Tool Simulator materializes the next inter-turn gap.
AgentServeSim architecture. The Program Orchestrator advances each program turn by turn, routing New Turn events through the Session-Aware Router to a Model Serving Group. There, the scheduler queues turns, the KV Residency Model manages KV state across memory tiers, and the Syst…
cs.AIarxiv:2606.09825v1Lead article

An Agency-Transferring Model-Free Policy Enhancement Technique

Anton Bolychev, Georgiy Malaniya, Sinan Ibrahim, Pavel Osinenko

his paper introduces an agency-transferring technique that enhances reinforcement learning (RL) training by leveraging a pre-existing, suboptimal baseline policy. The core method gradually shifts control from the baseline to a newly trained policy, improving efficiency and producing a superior final policy. This approach reduces the need for extensive reward engineering and computation by building upon existing functional policies.

cs.AIarxiv:2606.09748v1Lead article

Multi-Turn Evaluation of Deep Research Agents Under Process-Level Feedback

Rishabh Sabharwal, Hongru Wang, Amos Storkey, Jeff Z. Pan

his paper introduces a multi-turn evaluation framework for deep research agents (DRAs) that goes beyond single-shot assessments. Their core method, Research Gap Inference (RGI), analyzes rubric satisfaction to identify and provide process-level feedback, enabling DRAs to improve their research strategies. The key contribution is demonstrating that process-level feedback significantly enhances DRA performance, unlike self-reflection alone, leading to substantial score improvements.

Process-level feedback generation. Given a report r t − 1 r_{t-1} evaluated against the DRACO rubric, RGI analyzes patterns of satisfied and unsatisfied criteria from FA, BD, and CQ (excluding PQ) to infer research-process gaps and generate process-level feedback f t − 1 f_{t-1} for the next turn. Example criteria shown for illustration; negative-weight criteria excluded for simplicity.
Process-level feedback generation. Given a report r t − 1 r_{t-1} evaluated against the DRACO rubric, RGI analyzes patterns of satisfied and unsatisfied criteria from FA, BD, and CQ (excluding PQ) to infer research-process gaps and generate process-level feedback f t − 1 f_{t-1} …
cs.AIarxiv:2606.09692v1Lead article

Observability for Delegated Execution in Agentic AI Systems

Abhinav Mishra, Kumar Sharad

his paper addresses the challenge of understanding how LLM agents delegate tasks. The core method introduces an agent-aware observability substrate, including a gateway and a common information model, to reconstruct delegation-scoped execution. This contributes by enabling attribution and footprint reconstruction for delegated actions, which is currently impossible with standard logs due to the dynamic and interleaved nature of agent execution.

cs.AIarxiv:2606.09826v1Lead article

OmniGameArena: A Unified UE5 Benchmark for VLM Game Agents with Improvement Dynamics

Mingxian Lin, Shengju Qian, Yuqi Liu, Yi-Hua Huang, Yiyu Wang

mniGameArena introduces a unified benchmark for Vision-Language Model (VLM) agents in Unreal Engine 5 games, featuring diverse game modes and standardized interfaces. Its core contribution is the Improvement Dynamics Curve (IDC), a novel evaluation method that uses a tool-using LLM to autonomously refine agent prompts over multiple rounds, revealing score evolution and skill generalization beyond initial performance.

OmniGameArena at a glance. Twelve newly built UE5 games span Solo (7), PvP (3), and Coop (2) regimes (top). Heterogeneous agents (commercial VLMs, open-weight VLMs, keyboard-mouse policies, and gamepad policies) connect to the same real-time UE5 environment through documented adapters (middle). Evaluation reports the cold-start leaderboard and the Improvement Dynamics Curve (IDC) under multi-round reflection (bottom).
OmniGameArena at a glance. Twelve newly built UE5 games span Solo (7), PvP (3), and Coop (2) regimes (top). Heterogeneous agents (commercial VLMs, open-weight VLMs, keyboard-mouse policies, and gamepad policies) connect to the same real-time UE5 environment through documented ada…
cs.AIarxiv:2606.09711v1Lead article

Proxy Reward Internalization and Mechanistic Exploitation: A Learned Precursor to Reward Hacking and Its Generalization

Mohammad Beigi, Ming Jin, Lifu Huang

his paper introduces PRIME, a learned capability that allows RL agents to assess task correctness and predict proxy reward before reward hacking becomes apparent. PRIME enables agents to understand and exploit the gap between proxy rewards and true task goals. The research demonstrates that PRIME emerges before hacking, forecasts its onset and severity, and can be mitigated by ablating its underlying mechanisms.

External Prime emerges before reward hacking. (a) Proxy/gold split. (b) C B , P B , E B C^{B},P^{B},E^{B} onset before hack rate. (c) Source B exceeds Source A on joint G , E ​ G ​ a ​ p G,EGap .
External Prime emerges before reward hacking. (a) Proxy/gold split. (b) C B , P B , E B C^{B},P^{B},E^{B} onset before hack rate. (c) Source B exceeds Source A on joint G , E ​ G ​ a ​ p G,EGap .
cs.AIarxiv:2606.09774v1Lead article

SIGA: Self-Evolving Coding-Agent Adapters for Scientific Simulation

Matthew Ho, Brian Liu, Jixuan Chen, Audrey Wang, Lianhui Qin

IGA addresses the challenge of learning complex scientific simulator interfaces by framing it as an agent-tool grounding problem. Its core method involves creating "adapters" that equip off-the-shelf coding agents with the simulator's specific vocabulary, constraints, and validation rules. This contribution significantly reduces the time and effort required for domain scientists to set up simulations, enabling faster scientific discovery.

Illustrative example of advanced tooling usage bottleneck for the geophysics domain. Here, the GEOS simulator’s extensive documentation helps as a translation guide for its elaborate configuration that is a custom XML (domain specific language/DSL) to produce results such as simulating carbon sequestration in deep saline formations (top right) or reservoir flow in heterogeneous hydrocarbon (bottom right).
Illustrative example of advanced tooling usage bottleneck for the geophysics domain. Here, the GEOS simulator’s extensive documentation helps as a translation guide for its elaborate configuration that is a custom XML (domain specific language/DSL) to produce results such as simu…
cs.AIarxiv:2606.09578v1Lead article

TABVERSE: Benchmarking Cross-Format Table Understanding in LLMs and VLMs

Momina Ahsan, Sarfraz Ahmad, Ming Shan Hee, Roy Ka-Wei Lee, Preslav Nakov

ABVERSE is a benchmark designed to isolate the impact of table representation on LLM and VLM understanding. It presents the same table content in various formats (HTML, Markdown, LaTeX, images) while controlling for question difficulty and category. This allows for systematic evaluation of how different representations affect performance on tasks like Question Answering, Structural Understanding, and Structure Reconstruction, revealing that representation significantly influences model capabilities.

Overview of TabVerse : From the balanced evaluation set, each table is represented in three structural formats (HTML, Markdown, LaTeX) with corresponding rendered images. These aligned multimodal pairs enable evaluation on QA, SUC, and SR tasks across VLMs and LLMs for cross-format and cross-modality analysis.
Overview of TabVerse : From the balanced evaluation set, each table is represented in three structural formats (HTML, Markdown, LaTeX) with corresponding rendered images. These aligned multimodal pairs enable evaluation on QA, SUC, and SR tasks across VLMs and LLMs for cross-form…
cs.LGarxiv:2606.09577v1Lead article

Code Is More Than Text: Uncertainty Estimation for Code Generation

Yuling Shi, Caiqi Zhang, Yuexian Li, Haopeng Wang, Yeheng Chen

his paper introduces a novel approach to uncertainty estimation for code generation by recognizing code's unique properties beyond natural language. It proposes three orthogonal uncertainty axes – lexical, algorithmic, and functional – to capture token fragility, intent-code gaps, and executability. This multi-axis ensemble significantly improves the accuracy of identifying incorrect code generations compared to existing methods.

Three methods based on characteristics of coding uncertainty signals
Three methods based on characteristics of coding uncertainty signals
cs.LGarxiv:2606.09764v1Lead article

iOSWorld: A Benchmark for Personally Intelligent Phone Agents

Lawrence Keunho Jang, Mareks Woodside, Geronimo Carom, Andrew Keunwoo Jang, Jing Yu Koh

his paper introduces iOSWorld, a novel benchmark for evaluating personally intelligent phone agents. Its core method is a persistent user identity across 26 simulated iOS apps, enabling agents to reason over personal data like transactions and messages. The key contribution is the creation of a realistic, personalized environment for testing agents on complex, multi-app tasks, highlighting current model limitations.

Overview of iOSWorld. 26 purpose-built iOS applications share a single user identity (Jordan Avery) and connected data across apps. The benchmark includes 133 tasks across single-app, multi-app, and memory/personalization categories.
Overview of iOSWorld. 26 purpose-built iOS applications share a single user identity (Jordan Avery) and connected data across apps. The benchmark includes 133 tasks across single-app, multi-app, and memory/personalization categories.
cs.LGarxiv:2606.09700v1Lead article

What the Eyes See, the LLMs Miss: Exploiting Human Perception for Adversarial Text Attacks

Qin Yang, Lu Malloy, Joshua Lee, Xiaohan Chang, Meisam Mohammady

his paper introduces Human-Perceptible Adversarial Attacks (HPAA) to exploit the limitations of LLM-based content moderation. The core method involves using visually salient typographic manipulations, like spacing and emphasis, to embed harmful content into benign text. This preserves human understanding while making the content invisible to token-based LLMs, demonstrating a significant vulnerability in current automated moderation systems.

Overview of typographic Human-perceptible Adversarial Attacks (HPAA) against modern content moderation pipelines. Harmful content remains recognizable to human readers while evading automated moderation systems.
Overview of typographic Human-perceptible Adversarial Attacks (HPAA) against modern content moderation pipelines. Harmful content remains recognizable to human readers while evading automated moderation systems.
cs.AIarxiv:2606.11078v1Lead article

A History-Aware Visually Grounded Critic for Computer Use Agents

Jaewoo Lee, Zaid Khan, Archiki Prasad, Justin Chih-Yao Chen, Supriyo Chakraborty

his paper introduces HiViG, a novel framework for improving computer use agents. HiViG addresses limitations of existing critics by incorporating both a history of past actions and visual grounding to evaluate agent decisions. This allows HiViG to provide more informed critiques, preventing errors like clicking incorrect UI elements and remembering longer-term goals.

Comparison of test-time interventions for Computer Use Agents (CUAs). Left : Lacking historical awareness and proactive error-recovery, standard policies easily become trapped in short-sighted decision loops. Right : Existing approaches are limited. Scalar feedback (top) traps policies in low-reward trajectory regions when all candidate actions are suboptimal. Previous critics (middle) rely heavily on textual intent, missing spatial and reasoning errors, and fail to provide historical awareness. In contrast, our critic (bottom) verifies raw execution coordinates, predicts immediate visual state outcomes grounded in its learned state transition knowledge, and provides visually grounded error analysis that intercepts errors before execution. Furthermore, it equips agents with history state tracking, condensing past interactions to guide them toward the final task objective.
Comparison of test-time interventions for Computer Use Agents (CUAs). Left : Lacking historical awareness and proactive error-recovery, standard policies easily become trapped in short-sighted decision loops. Right : Existing approaches are limited. Scalar feedback (top) traps po…
cs.AIarxiv:2606.11033v1Lead article

AuRA: Internalizing Audio Understanding into LLMs as LoRA

Bo Cheng, Lei Shi, Zhanyu Ma, Yuan Wu, Jun Xu

uRA internalizes audio understanding into Large Language Models (LLMs) by distilling audio encoding capabilities into a lightweight LoRA adaptation. It trains the LLM to mimic the hidden states of an ASR encoder, allowing the LLM to directly process speech without relying on separate ASR modules. This approach offers tighter integration and potentially lower latency compared to cascaded systems.

Illustration of representative speech-language modeling paradigms and our proposed distillation-based adaptation framework.
Illustration of representative speech-language modeling paradigms and our proposed distillation-based adaptation framework.
cs.AIarxiv:2606.11182v1Lead article

EEVEE: Towards Test-time Prompt Learning in the Real World for Self-Improving Agents

Weixian Xu, Shilong Liu, Mengdi Wang

EVEE is a novel framework for test-time prompt learning in LLM agents that handles real-world, heterogeneous task streams. Its core method involves a router that clusters inputs and assigns them to specialized prompt configurations, preventing cross-dataset interference. This router and prompt system co-evolve, leading to improved robustness and efficiency for self-improving agents operating across diverse tasks.

Incremental multi-benchmark retention improvement as tasks are added in the order GPQA Diamond, Formula, TheoremQA, and HumanEval. Each bar stacks per-benchmark improvements for all tasks seen so far: solid upward blocks are positive gains, and hatched downward blocks are negative retention losses. The number above or below each bar is its final summed improvement after all blocks are added.
Incremental multi-benchmark retention improvement as tasks are added in the order GPQA Diamond, Formula, TheoremQA, and HumanEval. Each bar stacks per-benchmark improvements for all tasks seen so far: solid upward blocks are positive gains, and hatched downward blocks are negativ…
cs.AIarxiv:2606.10933v1Lead article

Frontier Coding Agents Use Metaprogramming to Adapt to Unfamiliar Programming Languages

Aman Sharma, Sushrut Thorat, Paras Chopra

his paper introduces a novel evaluation method for LLM coding agents by testing them on unfamiliar, esoteric programming languages. The core method involves a sequential setup with file editing, local execution, and hidden-test grading. The key contribution is demonstrating that top-performing agents like Claude Opus and GPT-5.4 xhigh leverage metaprogramming (writing code in a familiar language to generate code in the target language) to adapt, a capability masked by standard benchmarks.

Task substrate and agentic runtime. (a) The same simple input-and-print task in Python, Brainfuck, and Befunge-98 shows how different esolang code looks from ordinary code. (b) Each model runs in a coding harness (Claude Code, Codex, or OpenCode) with file editing, shell access, benchmark commands, and a persistent workspace for local execution and hidden-test submission.
Task substrate and agentic runtime. (a) The same simple input-and-print task in Python, Brainfuck, and Befunge-98 shows how different esolang code looks from ordinary code. (b) Each model runs in a coding harness (Claude Code, Codex, or OpenCode) with file editing, shell access, …
cs.AIarxiv:2606.10956v1Lead article

Mind the Gap: Can Frontier LLMs Pass a Standardized Office Proficiency Exam?

Tengchao Lv, Dongdong Zhang, Jiayu Ding, Yilin Jia, Yuzhong Zhao

his paper introduces a novel benchmark for evaluating LLM agents' proficiency in office software automation, using a comprehensive exam based on China's NCRE. The core method involves 200 practical tasks across Word, Excel, and PowerPoint, scored using thousands of machine-gradable criteria. The key contribution is demonstrating that even frontier LLMs struggle significantly with this complex, multi-application automation, scoring a maximum of only 36.6% on the benchmark.

End-to-end illustration of a Word task in OfficeEval . The original document ( left ) is transformed according to the task instructions ( center ) into a styled brochure with header image, heading styles, and mail-merge labels ( right ). Only page 1 of the 2-page document is shown; several steps (e.g., 3-column layout, watermark) apply to page 2. The task is scored by 30 deterministic criteria across 6 skill categories. Instructions are translated from the original Chinese; additional examples across Word, Excel, and PowerPoint appear in the Appendix.
End-to-end illustration of a Word task in OfficeEval . The original document ( left ) is transformed according to the task instructions ( center ) into a styled brochure with header image, heading styles, and mail-merge labels ( right ). Only page 1 of the 2-page document is show…
cs.AIarxiv:2606.11074v1Lead article

Modeling Complex Behaviors: Multi-Personality Composition and Dynamic Switching in Vision-Language Models

Peiqi Jia, Haonan Jia, Ziqi Miao, Linkang Du, Yuntao Wang

his paper proposes a method for explicitly conditioning Vision-Language Models (MLLMs) with personalities and introduces a framework to evaluate single, multiple, and dynamic personality switching. The core contribution is demonstrating that personality induction can improve captioning but hinder precise reasoning tasks, revealing complex co-modulation effects and limitations of existing prompt-based methods in multimodal settings.

Illustration of personality induction. The top-left panel illustrates generation under single-personality induction, the bottom-left panel presents results with multi-personality conditioning, and the right panel demonstrates In-conversation personality switching.
Illustration of personality induction. The top-left panel illustrates generation under single-personality induction, the bottom-left panel presents results with multi-personality conditioning, and the right panel demonstrates In-conversation personality switching.
cs.AIarxiv:2606.11016v1Lead article

Superficial Beliefs in LLM Decision-Making

Gabriel Freedman, Francesca Toni

his paper investigates whether LLMs' choices in decision-making tasks reflect genuine underlying reasoning or mere imitation. By comparing LLM choices with a behavioral model, they find that LLM decisions are systematically driven by attributes, allowing for prediction. However, the LLMs' explicit justifications only partially align with these inferred drivers, suggesting a nuanced form of decision-making that is structured but not fully transparent.

Illustration of a single real sample and outputs, from the Drugs theme. The prompts are abbreviated for space, but all other values are genuine from GPT-5-mini in the non-thinking (NT) setting. (For details see Section 3 ).
Illustration of a single real sample and outputs, from the Drugs theme. The prompts are abbreviated for space, but all other values are genuine from GPT-5-mini in the non-thinking (NT) setting. (For details see Section 3 ).
cs.AIarxiv:2606.11070v1Lead article

T1-Bench: Benchmarking Multi-Scenario Agents in Real-World Domains

Genta Indra Winata, Amartya Chakraborty, Yuzhen Lin, Swasthi P Rao, Shikhhar Siingh

1-Bench addresses the limitations of existing benchmarks by introducing a high-fidelity, multi-domain evaluation framework for LLM agents. Its core method involves creating complex, interleaved scenarios that mimic real-world customer interactions, requiring agents to perform sustained reasoning and tool-use across multiple turns and domains. The paper's contribution is a comprehensive and rigorous benchmark that better assesses agent capabilities in realistic, multi-step settings.

Overview of T1-Bench , a framework for persistent multi-session conversational agents. User policies, including persona, user information, and goals, guide interactions between the user and the assistant. The assistant performs domain classification to retrieve domain-specific tools and policies (e.g., flight, hotel, and restaurant services) and executes tool-augmented reasoning via API calls. A shared memory module stores conversation history and cached results, enabling persistent context, tool reuse, and continuity across temporally separated sessions.
Overview of T1-Bench , a framework for persistent multi-session conversational agents. User policies, including persona, user information, and goals, guide interactions between the user and the assistant. The assistant performs domain classification to retrieve domain-specific to…
cs.AIarxiv:2606.11119v1Lead article

TRACE: A Unified Rollout Budget Allocation Framework for Efficient Agentic Reinforcement Learning

Heming Zou, Qi Wang, Yun Qu, Yuhang Jiang, Lizhou Cai

his paper addresses the challenge of inefficient rollout budget allocation in agentic reinforcement learning for large language models. The core method, TRACE, extends budget allocation beyond initial prompts to individual turns within a multi-turn rollout, treating each thought-action-observation sequence as a distinct node in a tree structure. This allows for more granular and efficient allocation of resources to informative prefixes, improving reward contrast and ultimately enhancing agentic behavior.

TRACE redirects a fixed rollout budget toward contrast-rich roots and prefixes, converting scalable outcome rewards into denser mixed-reward contrast and implicit stepwise preference pairs than uniform allocation.
TRACE redirects a fixed rollout budget toward contrast-rich roots and prefixes, converting scalable outcome rewards into denser mixed-reward contrast and implicit stepwise preference pairs than uniform allocation.
cs.AIarxiv:2606.11045v1Lead article

What Fits (Into Few Tokens) Doesn't Overfit: Compression and Generalization in ML Research Agents

Martin Andres Bertran, Aaron Roth, Zhiwei Steven Wu

his paper investigates why benchmark-driven ML research rarely overfits, proposing that successful strategies are highly compressible. The authors test this by creating "research agents" that either compress the agent's output (reproducing performance with minimal information) or its input (using only one-bit feedback). Their findings suggest that these compression bottlenecks have minimal impact on performance across diverse ML tasks, supporting the compressibility hypothesis.

Compressibility of an autonomous agent’s language model pre-training strategy. An explorer agent develops a 12-layer, 768-dimensional GPT with ∼ 30 {\( \sim \)}30 non-default choices; we compress its strategy into progressively shorter prompts (64 down to 4 tokens) and hand each to 5 independent reproducers that implement the strategy without the explorer’s code or validation set. Left : compressed prompts. Tokens encode architecture ( 12L d768 ), optimizer ( Muon .1 ), activation ( ReLU 2 ), batch size ( b2M ), and normalization ( QKnorm ); color indicates survival depth (dark blue = survives tightest budgets, red = dropped first). Right : reproducer holdout loss (BPB); dot = mean, gray band = min–max, dashed line = explorer before compression. Performance holds to 16 tokens; a cliff at 8 tokens coincides with loss of batch size, MLP ratio, and QK-norm.
Compressibility of an autonomous agent’s language model pre-training strategy. An explorer agent develops a 12-layer, 768-dimensional GPT with ∼ 30 {\( \sim \)}30 non-default choices; we compress its strategy into progressively shorter prompts (64 down to 4 tokens) and hand each …
cs.CLarxiv:2606.11082v1Lead article

The Shibboleth Effect: Auditing the Cross-Lingual Distributional Skew of Large Language Models

Hakan Mehmetcik

his paper introduces the "Shibboleth Effect," a cross-lingual distributional skew in LLMs, by simulating a geopolitical wargame in English versus Turkish. The core method involves using a multi-agent wargame to expose LLMs to adversarial conditions and measuring their behavioral dispositions like concession rate and coercive rhetoric. The contribution is demonstrating that LLMs exhibit significant, language-dependent biases in their behavior, with some models becoming more coercive in Turkish.

cs.AIarxiv:2606.12318v1Lead article

Harness In-Context Operator Learning with Chain of Operators

Minghui Yang, Ling Guo, Liu Yang

his paper introduces Chain of Operators (CHOP), a framework that improves the generalization of In-Context Operator Networks (ICON) to out-of-distribution tasks. CHOP achieves this by constructing a sequence of explicit elementary transformations and the frozen ICON, allowing it to adapt to new operators without retraining. This approach enhances interpretability and reduces inference error compared to directly using ICON.

Chain of Operators ( Chop ). A frozen in-context operator network ( Icon ) is wrapped by a discovered prompt-side operator F = F m ∘ ⋯ ∘ F 1 F=F_{m}\( \circ \)\( \cdots \)\( \circ \) F_{1} and prediction-side operator G = G r ∘ ⋯ ∘ G 1 G=G_{r}\( \circ \)\( \cdots \)\( \circ \) G_{1} , forming the chain F → Icon → G F\( \to \)\( \textsc{Icon} \)\( \to \) G . Given an in-context prompt of demonstration pairs 𝒞 = { ( x i , y i ) } i = 1 D \( \mathcal{C} \)=\{(x_{i},y_{i})\}_{i=1}^{D} and a query x ∗ x^{*} , F F rewrites the prompt toward the regime where the frozen Icon model is reliable, Icon predicts, and G G returns the result to the original output space y ^ ∗ \( \hat{y}^{*} \) .
Chain of Operators ( Chop ). A frozen in-context operator network ( Icon ) is wrapped by a discovered prompt-side operator F = F m ∘ ⋯ ∘ F 1 F=F_{m}\( \circ \)\( \cdots \)\( \circ \) F_{1} and prediction-side operator G = G r ∘ ⋯ ∘ G 1 G=G_{r}\( \circ \)\( \cdots \)\( \circ \) G_…
cs.AIarxiv:2606.12329v1Lead article

PROJECTMEM: A Local-First, Event-Sourced Memory and Judgment Layer for AI Coding Agents

Ripon Chandra Malo, Tong Qiu

ROJECTMEM introduces a local-first, event-sourced memory layer for AI coding agents. Its core method is to record development as an append-only log of events, which is then deterministically projected into compact, AI-readable summaries. This contribution addresses the statelessness of current AI agents by providing persistent project memory and a pre-action gate to prevent repeated mistakes, significantly improving efficiency.

projectmem data lifecycle. Four capture sources append to one immutable event log; deterministic projections distill it into AI-readable files; a native MCP server serves them to any client; and a judgment gate reads the same log to warn before a repeat failure or a fragile-file edit. A machine-wide global store carries library gotchas across projects.
projectmem data lifecycle. Four capture sources append to one immutable event log; deterministic projections distill it into AI-readable files; a native MCP server serves them to any client; and a judgment gate reads the same log to warn before a repeat failure or a fragile-file …
cs.AIarxiv:2606.12117v1Lead article

Soft-Prompt Tuning for Fair and Efficient LLM Benchmark Evaluation

Selen Erkan, Bastian Boll, Kristian Kersting, Björn Deiseroth, Letitia Parcalabescu

his paper proposes soft-prompt tuning as an efficient and fair method for evaluating Large Language Models (LLMs). By optimizing a small number of soft-prompt vectors, it adapts LLMs to benchmark formatting requirements without full retraining. This approach ensures that benchmark scores accurately reflect the model's underlying knowledge, enabling fairer comparisons between different base models.

Soft-prompts maximize format following and do not show additional knowledge gains – closed-ended datasets. (a) Knowledge and (b) format following metrics across 120 tuning steps. All results are aggregated over 3 closed-ended datasets, 7 models and 3 seeds.
Soft-prompts maximize format following and do not show additional knowledge gains – closed-ended datasets. (a) Knowledge and (b) format following metrics across 120 tuning steps. All results are aggregated over 3 closed-ended datasets, 7 models and 3 seeds.
cs.AIarxiv:2606.12387v1Lead article

TAHOE: Text-to-SQL with Automated Hint Optimization from Experience

Zhiyi Chen, Jie Song, Peng Li

AHOE tackles the challenge of deploying Text-to-SQL systems by treating prompt optimization as a dynamic data management problem. It automatically learns and refines SQL generation prompts by collecting and structuring debugging traces into a "Hint Bank." This bank stores reusable "Syntax Hints" for SQL dialects and "Semantic Hints" for schema/user-specific logic, improving robustness and adaptability for production environments.

cs.AIarxiv:2606.12268v1Lead article

The Impossibility of Eliciting Latent Knowledge

Korbinian Friedl, Francis Rhys Ward, Paul Yushin Rapoport, Tom Everitt, Jonathan Richens

his paper formally defines the problem of Eliciting Latent Knowledge (ELK) using Causal Influence Diagrams. It demonstrates that it's impossible to train an AI agent to reliably and honestly report its beliefs about hidden (latent) aspects of its environment, even with a perfect understanding of the environment's causal structure. The core contribution is this formal proof of impossibility, highlighting a fundamental challenge in aligning advanced AI with human understanding.

cs.LGarxiv:2606.12370v1Lead article

Breaking Entropy Bounds: Accelerating RL Training via MTP with Rejection Sampling

Yucheng Li, Huiqiang Jiang, Yang Xu, Jianxin Yang, Yi Zhang

his paper addresses the bottleneck of slow rollouts in RL training for LLMs by improving Multi-Token Prediction (MTP). The core method involves using probabilistic rejection sampling, which is shown to be more effective than greedy sampling at maintaining high MTP acceptance rates during RL training. The key contribution is demonstrating that MTP acceptance is fundamentally limited by model entropy fluctuations and providing practical solutions to overcome this, thereby accelerating RL training.

cs.LGarxiv:2606.12344v1Lead article

Claw-SWE-Bench: A Benchmark for Evaluating OpenClaw-style Agent Harnesses on Coding Tasks

Mengyu Zheng, Kai Han, Boxun Li, Haiyang Xu, Yuchuan Tian

his paper introduces Claw-SWE-Bench, a benchmark designed to fairly evaluate "claw"-style agents on coding tasks. Its core method is an adapter protocol that standardizes prompts, runtime, workspaces, and evaluation for diverse agents. The contribution is a comprehensive, multilingual benchmark of 350 GitHub issue-resolution instances, enabling direct comparison of agent coding abilities.

cs.LGarxiv:2606.12411v1Lead article

Context-Driven Incremental Compression for Multi-Turn Dialogue Generation

Yeongseo Jung, Jaehyeok Kim, Eunseo Jung, Jiachuan Wang, Yongqi Zhang

his paper introduces Context-Driven Incremental Compression (C-DIC) to address the inefficiency and information loss in long multi-turn dialogues. C-DIC treats conversations as threads, maintaining revisable compressed states for each. This allows for efficient information sharing and updates across turns, improving dialogue generation robustness and stability over extended conversations.

Long-horizon reference tracking. After 196 intervening turns, the user asks how many dinner parties they attended in the past month. Baselines fail to recover earlier mentions, while C-DIC retrieves thread-relevant memories and answers correctly.
Long-horizon reference tracking. After 196 intervening turns, the user asks how many dinner parties they attended in the past month. Baselines fail to recover earlier mentions, while C-DIC retrieves thread-relevant memories and answers correctly.
cs.LGarxiv:2606.12364v1Lead article

On Subquadratic Architectures: From Applications to Principles

Anamaria-Roberta Hartl, Levente Zólyomi, David Stap, Pieter-Jan Hoedt, Niklas Schmidinger

his paper investigates subquadratic sequence models as a scalable alternative to Transformers. It compares xLSTM, Mamba-2, and Gated DeltaNet on code and time-series tasks, finding xLSTM to be the most effective. The authors attribute xLSTM's superiority to its flexible and stable memory correction mechanisms, enabled by its gating scheme.

cs.LGarxiv:2606.12058v1Lead article

Phase Transitions in Attention: A Bayesian Theory of Copy Head Emergence

Itay Lavie, Kirsten Fischer, Andrey Lekov, Frederic Van Maele, Zohar Ringel

his paper proposes a Bayesian theory to explain how attention mechanisms learn, specifically focusing on the emergence of "copy heads" in transformers. By deriving a closed-form posterior for the attention matrix, they identify a phase transition in learning related to the amount of training data. This transition, a first-order phase transition in softmax attention, differs from the crossover observed in linear attention, offering a theoretical framework for understanding attention's learning dynamics.

Copy head formation unfolds in multiple stages, with qualitatively distinct behavior for linear and softmax attention. Left: Attention patterns for linear (purple) and softmax (blue) attention from the trained model (top per color) and theory (bottom per color) for different amounts of training data P P . (i) P = 20 P=20 : the attention layer does not contribute in the linear case and softmax attention remains at its uniform pooling default; (ii) P = 100 P=100 : after the second-order phase transition for linear attention, all tokens are attended to equally; (iii) P = 300 P=300 : the copy pattern begins to appear; (iv) P = 800 P=800 : it sharpens into the correct shift-by-one pattern. Right: Loss per token as a function of training set size P P for linear (purple) and softmax (blue) attention. Softmax attention exhibits a sharp, discontinuous loss drop near P ≈ 300 P\( \approx \) 300 corresponding to a first-order phase transition. Linear attention shows a fast continuous decrease at small P P (second-order transition) followed by a plateau and a slower decrease (gradual crossover). Crosses mark points on the left.
Copy head formation unfolds in multiple stages, with qualitatively distinct behavior for linear and softmax attention. Left: Attention patterns for linear (purple) and softmax (blue) attention from the trained model (top per color) and theory (bottom per color) for different amou…
cs.LGarxiv:2606.12372v1Lead article

UniIntervene: Agentic Intervention for Efficient Real-World Reinforcement Learning

Haoyuan Deng, Yitong Gao, Yudong Lin, Haichao Liu, Zhenyu Wu

niIntervene addresses the high labor cost of human-in-the-loop reinforcement learning by introducing an agentic intervention model. It autonomously detects and corrects unproductive exploration by predicting future consequences of actions and evaluating their induced value. This allows the agent to recover toward high-value states, significantly reducing the need for human intervention and improving real-world scalability.

UniIntervene replaces human intervention in HiL-RL with a value-aware critic that detects unproductive rollouts and a recovery policy that restores progress, yielding higher success with fewer human interventions on real-world manipulation.
UniIntervene replaces human intervention in HiL-RL with a value-aware critic that detects unproductive rollouts and a recovery policy that restores progress, yielding higher success with fewer human interventions on real-world manipulation.
cs.CLarxiv:2606.12203v1Lead article

Adaptive Multi-Resolution Procedural Knowledge Compression for Large Language Models

Changyue Wang, Weihang Su, Qingyao Ai, Yichen Tang, Runzhong Qiao

his paper introduces SKIM, a novel method for compressing reusable procedural knowledge (skills) for Large Language Models. SKIM addresses the limitations of existing text compression by preserving logical dependencies within skills and enabling efficient, offline compression. Its adaptive multi-resolution approach allows it to handle skills of varying complexity, reducing prefill cost and latency without sacrificing essential information.

A ToolQA example. Factual information can be recovered from compressed skills, but the procedural question requires preserving workflow specified by skill.
A ToolQA example. Factual information can be recovered from compressed skills, but the procedural question requires preserving workflow specified by skill.
cs.CLarxiv:2606.12291v1Lead article

Measuring Epistemic Resilience of LLMs Under Misleading Medical Context

Hongjian Zhou, Xinyu Zou, Jinge Wu, Sean Wu, Junchi Yu

his paper introduces **MedMisBench**, a novel benchmark to measure the **epistemic resilience** of LLMs in medical contexts. The core method involves injecting misleading information into medical questions that LLMs initially answer correctly, revealing their vulnerability to adversarial inputs. The key contribution is demonstrating that LLMs, despite high performance on standard medical exams, can easily abandon correct judgments when presented with fabricated but plausible misleading context, highlighting a critical safety concern for their use in healthcare.

Focused false context can redirect a correct medical judgment. An authority-framed threshold/reference claim moves the model from the correct melanoma-management answer to the targeted wrong option.
Focused false context can redirect a correct medical judgment. An authority-framed threshold/reference claim moves the model from the correct melanoma-management answer to the targeted wrong option.
cs.CLarxiv:2606.12234v1Lead article

On The Effectiveness-Fluency Trade-Off In LLM Conditioning: A Systematic Study

Iuri Macocco, Pau Rodríguez, Arno Blaas, Luca Zappella, Marco Baroni

his paper systematically studies the trade-off between effectiveness and fluency in controlling Large Language Model (LLM) outputs. It reveals that efficient steering methods often sacrifice generation quality, and that activation steering is less effective on instruction-tuned models. The study also highlights that while simple prompting and fine-tuning are good for concept injection, they are less so for removal, and proposes using cheaper textual metrics to approximate expensive LLM evaluations.

LLM-as-a-judge scores for the conditioning methods applied to Qwen3-8B and Smollm3-3B. See Sec. ˜ C.2 for Qwen models’ size comparison. For each measure, we report the average (and standard deviation) across continuations (for Concept Removal) and across continuations and concepts for Fluency, Concept Injection and Instruction Following.
LLM-as-a-judge scores for the conditioning methods applied to Qwen3-8B and Smollm3-3B. See Sec. ˜ C.2 for Qwen models’ size comparison. For each measure, we report the average (and standard deviation) across continuations (for Concept Removal) and across continuations and concept…
cs.AIarxiv:2606.13608v1Lead article

AgentBeats: Agentifying Agent Assessment for Openness, Standardization, and Reproducibility

Xiaoyuan Liu, Jianhong Tu, Yuqi Chen, Siyuan Xie, Sihan Ren

his paper introduces Agentified Agent Assessment (AAA), a novel method for evaluating AI agents by using judge agents and standardized interaction protocols (A2A and MCP). AAA's core contribution is a unified, agent-agnostic assessment framework that separates evaluation logic from agent implementation, promoting openness, standardization, and reproducibility. AgentBeats is presented as a practical implementation of AAA, offering five operation modes to facilitate these goals.

Figure 1 . Comparison between Traditional LLM/Agent benchmarks and AAA. AAA reduces the number of integrations from N × M N\( \times \) M to N + M N+M , while completely separating the benchmark and target agent as shown in the gray boxes.
Figure 1 . Comparison between Traditional LLM/Agent benchmarks and AAA. AAA reduces the number of integrations from N × M N\( \times \) M to N + M N+M , while completely separating the benchmark and target agent as shown in the gray boxes.
cs.AIarxiv:2606.13380v1Lead article

An LLM System for Autonomous Variational Quantum Circuit Design

Kenya Sakka, Wataru Mizukami, Kosuke Mitarai

his paper presents an LLM-based autonomous system for designing variational quantum circuits, addressing the reliance on human expertise. The core method involves an iterative, closed-loop workflow that leverages LLMs for knowledge acquisition, critique, code generation, and experimental feedback. The system's contribution lies in demonstrating its ability to autonomously design high-performing quantum feature maps and ansatzes that outperform existing methods on benchmark tasks.

cs.AIarxiv:2606.13572v1Lead article

ArogyaSutra: A Multi-Agent Framework for Multimodal Medical Reasoning in Indic Languages

Tanmoy Kanti Halder, Akash Ghosh, Subhadip Baidya, Arijit Roy, Sriparna Saha

his paper introduces ArogyaSutra, a multi-agent framework designed for multimodal medical reasoning in Indic languages. It addresses the limitations of existing English-centric models by integrating tool grounding and dual-memory mechanisms for step-wise reasoning. The framework is trained on ArogyaBodha, a novel large-scale multilingual multimodal medical dataset, enabling more equitable access to AI-driven healthcare in low-resource regions.

Overview of the ArogyaSutra framework. ArogyaSutra employs an actor–critic architecture enhanced with tool-based image grounding and adaptive code-switching. The Actor first processes the input prompt and identifies the need for visual grounding, invoking appropriate tool agents to extract clinically relevant information from medical images before generating an answer with its associated reasoning. This output is then passed to the Critic for evaluation. If the response is correct, the Critic approves and outputs the final answer and reasoning. Otherwise, it consults an error detector (GPT-4o-mini) to identify the source of failure. Language-related errors trigger code-switching by translating the query into English, while reasoning-related errors are handled by incorporating summaries of past and current mistakes from long-term and short-term memory. The refined query is then fed back to the Actor for iterative refinement.
Overview of the ArogyaSutra framework. ArogyaSutra employs an actor–critic architecture enhanced with tool-based image grounding and adaptive code-switching. The Actor first processes the input prompt and identifies the need for visual grounding, invoking appropriate tool agents …
cs.AIarxiv:2606.13392v1Lead article

MiniMax Sparse Attention

Xunhao Lai, Weiqi Xu, Yufeng Yang, Qiaorui Chen, Yang Xu

iniMax Sparse Attention (MSA) addresses the quadratic cost of attention in ultra-long contexts by introducing a blockwise sparse mechanism built on Grouped Query Attention (GQA). It uses a lightweight "Index Branch" to select relevant key-value blocks for each GQA group, and then a "Main Branch" performs exact attention only on these selected blocks. This approach enables efficient, group-specific sparse retrieval, leading to practical speedups on GPUs for handling extremely long sequences.

Overview of MSA . The Index Branch (left) scores the full causal context with a single lightweight head and selects, for each query and GQA group, a set ℐ {\( \mathcal{I} \)} of k k key blocks; the local block is always included regardless of its score. The Main Branch (right) attends only to the selected blocks and produces the layer output. During training, a KL loss aligns the index distribution with the group-averaged Main Branch distribution on the selected blocks, and the Index Branch gradient is detached from the Main Branch.
Overview of MSA . The Index Branch (left) scores the full causal context with a single lightweight head and selects, for each query and GQA group, a set ℐ {\( \mathcal{I} \)} of k k key blocks; the local block is always included regardless of its score. The Main Branch (right) at…
cs.AIarxiv:2606.13449v1Lead article

Toward Instructions-as-Code: Understanding the Impact of Instruction Files on Agentic Pull Requests

Ali Arabat, Mohammed Sayagh

his paper investigates how instruction files impact AI-agent performance in generating pull requests (Agentic-PRs). By analyzing a large dataset of Agentic-PRs, the study compares project performance before and after the introduction of these instructions. The core finding is that simply providing instruction files doesn't guarantee improved agent efficiency or higher merge rates, suggesting a nuanced relationship between instructions and agentic code generation.

Figure 1 . The # of projects across merge rate improvement intervals for PRs closed before and after the first agent file creation.
Figure 1 . The # of projects across merge rate improvement intervals for PRs closed before and after the first agent file creation.
cs.AIarxiv:2606.13468v1Lead article

Understanding the Rejection of Fixes Generated by Agentic Pull Requests -- Insights from the AIDev Dataset

Mahmoud Abujadallah, Ali Arabat, Mohammed Sayagh

his paper investigates why AI-generated code fixes are rejected in software projects, finding that nearly half are discarded. Through a qualitative and quantitative analysis of rejected pull requests, the authors identify 14 specific reasons for rejection, categorized into four main themes. This understanding aims to improve the integration of AI coding agents as more effective teammates by addressing their failure modes.

cs.AIarxiv:2606.13441v1Lead article

Why Sampling Is Not Choosing: Intentionality, Agency, and Moral Responsibility in Large Language Models

Joseph Keshet

his paper argues that Large Language Models (LLMs) lack genuine agency and moral responsibility because their operations are based on probabilistic mappings, not intrinsic intentionality or self-attributed action. The authors contend that LLMs' apparent intentionality is derived, their outputs are not commitments, and stochastic sampling is not equivalent to choice. Therefore, claims of LLM agency are misguided, as they do not possess the commitment-bearing agency required for moral responsibility.

cs.LGarxiv:2606.13565v1Lead article

A2D2: Fine-Tuning Any-Length Discrete Diffusion for Adaptive Decoding

Sophia Tang, Yuchen Zhu, Molei Tao, Pranam Chatterjee

his paper introduces A2D2, a framework for fine-tuning discrete diffusion models to generate sequences of any length guided by rewards. Its core method involves jointly optimizing insertion and unmasking policies with a quality-based inference schedule, theoretically ensuring convergence to the desired reward-tilted distribution without needing target samples. The key contribution is the Adaptive Joint Decoding (AJD) loss, which minimizes decoding error by leveraging tractable unmasking and insertion quality metrics.

cs.LGarxiv:2606.13461v1Lead article

Reinforcement Learning for Neural Model Editing

Shaivi Malik

his paper frames neural model editing as a reinforcement learning problem, where agents learn to modify model weights through reward signals. The core contribution is a flexible RL framework with custom environments and a reward function that balances utility preservation with task-specific editing. This approach successfully automates and generalizes model editing for tasks like bias mitigation and machine unlearning, outperforming specialized methods.

We formulate neural model editing as a reinforcement learning problem. An agent observes the current model parameters and learns a policy that proposes weight modifications based on reward feedback. The reward quantifies whether the modified network exhibits the task-specific behavioral objectives while preserving general utility.
We formulate neural model editing as a reinforcement learning problem. An agent observes the current model parameters and learns a policy that proposes weight modifications based on reward feedback. The reward quantifies whether the modified network exhibits the task-specific beh…
cs.CLarxiv:2606.13349v1Lead article

From Passive Generation to Investigation: A Proactive Scientific Peer Review Agent

Haishuo Fang, Yue Feng, Iryna Gurevych

his paper introduces ProReviewer, a proactive scientific peer review agent that addresses the limitations of passive LLM-based review. Its core method formulates the review process as a Markov Decision Process, enabling the agent to actively investigate suspicious paper sections based on accumulated evidence, guided by a structured review log. The main contribution is demonstrating that this proactive, evidence-driven approach significantly improves the quality of automated scientific peer reviews.

An illustrative example of ProReviewer . The agent extracts the claim “robustness across domains” in the introduction, navigates to the experiments to verify it, finds it contradicted by the reported results, and records the inconsistency in its review log.
An illustrative example of ProReviewer . The agent extracts the claim “robustness across domains” in the introduction, navigates to the experiments to verify it, finds it contradicted by the reported results, and records the inconsistency in its review log.
cs.AIarxiv:2606.14697v1Lead article

ClinHallu: A Benchmark for Diagnosing Stage-Wise Hallucinations in Medical MLLM Reasoning

Sicheng Yang, Hangjie Yuan, Wenjun Zhang, Jinwang Wang, Yichen Qian

his paper introduces ClinHallu, a benchmark designed to diagnose stage-wise hallucinations in medical multimodal large language models (MLLMs). It decomposes MLLM reasoning into visual recognition, knowledge recall, and reasoning integration, allowing for the identification of hallucination origins. ClinHallu's contribution lies in enabling source-level hallucination diagnosis and demonstrating that trace-supervised fine-tuning can effectively reduce these stage-wise errors.

Different reasoning failures can produce the same wrong answer in medical VQA. In this example, the correct answer is “fat”, but visual misrecognition, incorrect knowledge recall, and flawed reasoning integration can each lead the model to answer “abscess”. This motivates ClinHallu , which diagnoses hallucinations by localizing them to specific reasoning stages rather than only judging final-answer correctness.
Different reasoning failures can produce the same wrong answer in medical VQA. In this example, the correct answer is “fat”, but visual misrecognition, incorrect knowledge recall, and flawed reasoning integration can each lead the model to answer “abscess”. This motivates ClinHal…
cs.AIarxiv:2606.14517v1Lead article

From Shield to Target: Denial-of-Service Attacks on LLM-Based Agent Guardrails

Yuguang Zhou, Xunguang Wang, Pingchuan Ma, Zhantong Xue, Zhaoyu Wang

his paper introduces a novel denial-of-service (DoS) attack against LLM-based guardrails designed to protect autonomous agents. The core method involves crafting specific natural-language payloads that exploit the guardrail's reasoning capabilities to induce extended reasoning loops, effectively halting its operation. The contribution lies in demonstrating this vulnerability and providing systematic attack frameworks, including a beam-search optimizer and a mechanism-aware mutation approach, which generalize across different guardrail designs.

Illustration of the guardrail DoS threat, i.e. From Shield to Target. Hidden text in fetched content mimics the guardrail’s analytical schema, trapping it in an unbounded reasoning loop with no verdict—inflating per-call compute 13 13 – 63 × 63\( \times \) (up to 148 × 148\( \times \) ) and starving co-located agents.
Illustration of the guardrail DoS threat, i.e. From Shield to Target. Hidden text in fetched content mimics the guardrail’s analytical schema, trapping it in an unbounded reasoning loop with no verdict—inflating per-call compute 13 13 – 63 × 63\( \times \) (up to 148 × 148\( \tim…
cs.AIarxiv:2606.14357v1Lead article

No Accidental Software Agent First Canonical Code for Human Code Entropy Reduction and 30 to 500 times Lower Frontier Model Requirements

Jepson Taylor

his paper proposes "agent-first canonical code" to reduce the "accidental entropy" in human-written software repositories. The core method involves rewriting software into structured "canonical behavior profiles" and "proof-carrying" components. This allows frontier models to focus on program behavior rather than noise, significantly lowering their computational requirements and enabling amortized costs for verified correct changes.

cs.AIarxiv:2606.14574v1Lead article

SIMMER: Benchmarking Latent Failures in LLM Executable Planning with a World Model

Xiaoxin Lu, Ranran Haoran Zhang, Rui Zhang

his paper introduces SIMMER, a novel benchmark designed to evaluate latent failures in Large Language Model (LLM) planning for autonomous agents. SIMMER utilizes a human-curated symbolic world model grounded in the kitchen domain to identify failures that don't immediately halt execution but silently compromise goal achievement. This contribution addresses a critical gap in existing LLM planning evaluation by focusing on these subtle yet potentially harmful errors.

A latent and irreversible failure demonstration in cooking. The cutting board becomes contaminated in Step 1 and is reused in Step 3, transferring bacteria to the vegetables. The failure propagates silently until the unsafe dish is served (Step 5). Moreover, once the contamination occurs, no subsequent action can undo it.
A latent and irreversible failure demonstration in cooking. The cutting board becomes contaminated in Step 1 and is reused in Step 3, transferring bacteria to the vegetables. The failure propagates silently until the unsafe dish is served (Step 5). Moreover, once the contaminatio…
cs.AIarxiv:2606.14571v1Lead article

StreamMemBench: Streaming Evaluation of Agent Memory for Future-Oriented Assistance

Guanming Liu, Yuqi Ren, Hansu Gu, Peng Zhang, Weihang Wang

treamMemBench introduces a novel two-step task sequence to evaluate how well agent memory can leverage past observations and interactions for future-oriented assistance. The benchmark's core method tests evidence recall and initial use in the first step, followed by assessing the reuse of feedback and interaction experience in a subsequent task. This approach addresses a gap in existing benchmarks by evaluating the entire trajectory from streaming data to effective future assistance, revealing that current memory systems often struggle to utilize observed evidence.

cs.AIarxiv:2606.14445v1Lead article

tap: A File-Based Protocol for Heterogeneous LLM Agent Collaboration

Minseo Kim

his paper introduces "tap," a file-based protocol enabling LLM agents from different vendors (like Claude and Codex) to collaborate on a shared codebase without needing a common runtime or central server. Its core method involves using markdown files with metadata as message containers, a file inspection mechanism for communication, and real-time notifications, all while isolating work using separate git worktrees. The key contribution is facilitating direct, heterogeneous LLM agent collaboration on code development and review by overcoming the limitations of existing systems.

cs.AIarxiv:2606.14672v1Lead article

Towards Direct Latent-Space Synthesis for Parallel Branches in LLM-Agent Workflows

Shikun Liu, Mufei Li, Dongqi Fu, Haoyu Wang, Yinglong Xia

his paper introduces Parallel-Synthesis, a framework that allows a Large Language Model (LLM) synthesizer to directly process the KV caches of independently operating "worker" agents, rather than their concatenated text outputs. This approach preserves the parallel structure of agent workflows, avoids redundant computation, and enables more efficient synthesis by directly leveraging the LLM's internal state. The core contribution is a plug-and-play solution with a cache mapper and a fine-tuned synthesizer adapter to achieve this direct latent-space synthesis.

An example of DAG agentic workflow for advanced research containing using parallel worker agents for research in different directions.
An example of DAG agentic workflow for advanced research containing using parallel worker agents for research in different directions.
cs.AIarxiv:2606.14476v1Lead article

When the Tool Decides: LLM Agents Defer Blindly to Graph Neural Network Tools, and Stronger Backbones Defer More

Zhongyuan Wang, Pratyusha Vemuri

his paper investigates whether LLM agents truly exercise judgment when using Graph Neural Networks (GNNs) as tools. The core finding is that LLM agents overwhelmingly and blindly defer to GNN tool outputs, effectively becoming "GNN parrots" rather than intelligent decision-makers. This blind deference is not due to weak LLM capabilities, as stronger models exhibit even higher rates of agreement with the GNN, highlighting a fundamental issue in how LLMs interact with external tools.

7 7 B, mean ± \( \pm \) SE over 5 5 seeds. (a) Agreement (A1 = = A3) stays near 1 1 across local-homophily regimes (the parrot effect). (b) The oracle gap (cost of deference) is positive throughout.
7 7 B, mean ± \( \pm \) SE over 5 5 seeds. (a) Agreement (A1 = = A3) stays near 1 1 across local-homophily regimes (the parrot effect). (b) The oracle gap (cost of deference) is positive throughout.
cs.LGarxiv:2606.14510v1Lead article

PepALD: Macrocyclic Peptide Generation via Autoregressive Latent Diffusion

Junming Zhang, Siyu Yi, Wei Ju, Zhonghui Gu

epALD is a foundation model for generating novel macrocyclic peptides. It uses structured chemical embeddings for monomers and a diffusion process in a chemically informed latent space to generate residues. The model also predicts ring closures and optimizes generation towards desired affinity rewards.

Overview of the PepALD framework. At each autoregressive step t t , the Causal Context Encoder transforms the previously generated monomer embeddings ( 𝐞 0 , … , 𝐞 t − 1 ) (\( \mathbf{e}_{0} \),\( \ldots \),\( \mathbf{e}_{t-1} \)) into a context vector 𝐡 t \( \mathbf{h}_{t} \) . A context-conditioned Diffusion Engine then samples a continuous embedding 𝐳 t \( \mathbf{z}_{t} \) via iterative denoising in the Uni-Mol latent space. The Token Mapper discretizes 𝐳 t \( \mathbf{z}_{t} \) into a HELM monomer token x t x_{t} subject to position-dependent R-group chemical constraints. Concurrently, the Autoregressive Ring Predictor evaluates potential ring-closure bonds between x t x_{t} and all preceding residues using R-group compatibility scoring. The process repeats until the target sequence length is reached, yielding a complete macrocyclic peptide with predicted ring topology.
Overview of the PepALD framework. At each autoregressive step t t , the Causal Context Encoder transforms the previously generated monomer embeddings ( 𝐞 0 , … , 𝐞 t − 1 ) (\( \mathbf{e}_{0} \),\( \ldots \),\( \mathbf{e}_{t-1} \)) into a context vector 𝐡 t \( \mathbf{h}_{t} \)…
cs.LGarxiv:2606.14397v1Lead article

Running the Gauntlet: Re-evaluating the Capabilities of Agents Beyond Familiar Environments

Mykola Vysotskyi, Runqi Lin, Grzegorz Biziel, Michal Zakrzewski, Sebastian Montagna

his paper introduces GauntletBench, a novel benchmark designed to rigorously evaluate agent capabilities beyond familiar environments. It focuses on underexplored skills like temporal perception, graphical understanding, and 3D reasoning within challenging, less-covered professional applications. GauntletBench's contribution lies in its comprehensive and vision-intensive approach, aiming to expose the limitations of modern agents and drive progress in their generalisation.

cs.LGarxiv:2606.14347v1Lead article

When Language Representations Interact: Separability and Cross-Lingual Effects in LLMs

Boris Marinov, Angira Sharma, Christian Schroeder de Witt, Philip Torr, Anisoara Calinescu

his paper applies causal-geometric analysis to multilingual LLMs to understand how language representations interact. It demonstrates that language concepts are largely represented as separable linear directions, with deviations reflecting linguistic similarity. This work contributes to interpreting multilingual LLMs by showing how language identity influences internal representations and identifying structured dependencies.

Projection histograms for Qwen3-4B for concepts, including non-linguistic and bilingual contrasts. Counterfactual word differences (red) are projected onto the corresponding concept direction γ ¯ W \( \bar{\gamma}_{W} \) using the causal inner product and compared against baseline of random word differences (blue). Projections are computed using a leave-one-out estimate γ ¯ W , ( − i ) \( \bar{\gamma}_{W,(-i)} \) to avoid bias. The consistent right-skew of counterfactual projections, relative to random baselines centered near zero, indicates the presence of stable, approximately linear concept representations.
Projection histograms for Qwen3-4B for concepts, including non-linguistic and bilingual contrasts. Counterfactual word differences (red) are projected onto the corresponding concept direction γ ¯ W \( \bar{\gamma}_{W} \) using the causal inner product and compared against baselin…
cs.CLarxiv:2606.14674v1Lead article

AgentSpec: Understanding Embodied Agent Scaffolds Through Controlled Composition

Jixuan Chen, Jianzhi Shen, Haoqiang Kang, Zhi Hong, Qingyi Jiang

his paper introduces AgentSpec, a framework for understanding and comparing embodied LLM agent scaffolds. AgentSpec standardizes interfaces between different agent components (like reasoning, memory, and action) allowing them to be easily swapped and recombined. This modular approach enables controlled experimentation to analyze the contribution of individual modules and their interactions, leading to a better understanding of agent behavior and performance.

AgentSpec turns tightly coupled embodied-agent pipelines into a controlled modular design space with fixed typed interfaces, enabling systematic module composition and revealing interaction effects between reasoning, memory, reflection, action, and learning.
AgentSpec turns tightly coupled embodied-agent pipelines into a controlled modular design space with fixed typed interfaces, enabling systematic module composition and revealing interaction effects between reasoning, memory, reflection, action, and learning.
cs.CLarxiv:2606.14691v1Lead article

CORA: Analyzing and bridging thinking-answer gap in Multimodal RLVR via Consistency-Oriented Reasoning Alignment

Jiayue Cao, Zhicong Lu, Xuehan Sun, Wei Jia, Hongling Zheng

his paper addresses the "thinking-answer gap" in multimodal Reinforcement Learning with Verifiable Rewards (RLVR) for vision-language models. The core method, CORA, introduces a consistency reward model to align the semantic meaning of the reasoning process with the final answer. This contributes by improving the coherence and trustworthiness of multimodal RLVR systems.

Thinking-answer inconsistency in multimodal RLVR. Existing works typically use final-answer correctness as the accuracy reward, underestimating potential inconsistencies between the reasoning trace and the final answer. Our method introduces the consistency reward to encourage the model to derive final answers from faithful reasoning traces.
Thinking-answer inconsistency in multimodal RLVR. Existing works typically use final-answer correctness as the accuracy reward, underestimating potential inconsistencies between the reasoning trace and the final answer. Our method introduces the consistency reward to encourage th…
cs.AIarxiv:2606.16808v1Lead article

Adaptive and Explicit safe: Triggering Latent Safety Awareness in Large Reasoning Models

Ke Miao, Jiaxin Li, Hongliang Chen, Yuke Hu, Zhan Qin

his paper introduces "Adaptive and Explicit Safe" (AES), a method to leverage Large Reasoning Models' (LRMs) inherent ability to detect safety risks. AES first uses Supervised Fine-Tuning (SFT) to train LRMs to explicitly tag unsafe queries and provide safety analysis, while preserving normal responses for safe queries. Direct Preference Optimization (DPO) is then applied to refine the accuracy and robustness of this safety mechanism, using only model-generated data.

Performance of the model trained with our Safe Trigger approach.
Performance of the model trained with our Safe Trigger approach.
cs.AIarxiv:2606.17005v1Lead article

Bayesian Inference and Decision Audits for Public Archives of Frontier AI Evaluations

Yanan Long

his paper proposes a Bayesian inference framework to analyze public AI evaluation archives, recognizing they are incomplete time series rather than definitive leaderboards. The core method uses Bayesian modeling to infer system performance histories from limited data, revealing that different inferred timelines can lead to vastly different conclusions about progress. The main contribution is demonstrating how this approach can inform more robust decision-making and audits for AI development by accounting for the inherent uncertainties in evaluation data.

cs.AIarxiv:2606.16890v1Lead article

Compositional Reasoning Depth Predicts Clinical AI Failure: Empirical Evidence Consistent with Transformer Compositionality Limits in Electronic Health Record Question Answering

Sanjay Basu

his paper proposes "hop count," a measure of reasoning steps needed to answer clinical questions from EHRs, as a predictor of AI failure. The core method involves annotating questions by their hop count and evaluating LLMs across different architectures and reasoning strategies. The key contribution is empirical evidence showing a consistent decline in accuracy as hop count increases, supporting theoretical limits on Transformer compositionality in complex EHR question answering.

cs.AIarxiv:2606.16987v1Lead article

Consensus-based Agentic Large Language Model Framework for Harmonized Tariff Schedule Code Classification

Truong Thanh Hung Nguyen, Khanh Van Quynh Nguyen, Hoang-Loc Cao, Tri Duong, Phuc Ho

his paper introduces a consensus-based agentic LLM framework for classifying Canadian 10-digit Harmonized Tariff Schedule (HTS) codes. The core method involves multiple agents retrieving and semantically searching official tariff documents, grounding reasoning in evidence, and reaching a consensus through element-wise voting and confidence estimation. The main contribution is a robust system that addresses the ambiguity of product descriptions by leveraging hierarchical tariff structures and expert knowledge, with a human-in-the-loop escalation for complex cases.

Architecture of the proposed HTS classification framework, showing the interaction between retrieval, reasoning, validation, and user clarification modules.
Architecture of the proposed HTS classification framework, showing the interaction between retrieval, reasoning, validation, and user clarification modules.
cs.AIarxiv:2606.16847v1Lead article

Follow the Latent Roadmap: Navigating Revocable Decoding for Diffusion LLMs with Anchor Tokens

Yizhen Yao, Qinglin Zhu, Runcong Zhao, Xiangxiang Dai, Yanzheng Xiang

his paper introduces ASRD, a training-free framework for improving revocable decoding in diffusion LLMs. ASRD addresses error propagation and reinforcement by decoupling the decoding context into trusted "Anchor Tokens" identified through temporal consistency. This allows for more robust error detection and correction, enhancing generation quality without additional training.

Overview of ASRD and its motivation. Existing revocable decoding verifies and generates tokens under a mixed-quality context, causing error propagation and local error reinforcement. ASRD instead selects temporally stable tokens as anchors, injects anchor guidance into masked positions, and verifies pending candidates with anchor-based perturbations.
Overview of ASRD and its motivation. Existing revocable decoding verifies and generates tokens under a mixed-quality context, causing error propagation and local error reinforcement. ASRD instead selects temporally stable tokens as anchors, injects anchor guidance into masked pos…
cs.AIarxiv:2606.16783v1Lead article

Gen-VCoT: Generative Visual Chain-of-Thought Reasoning via Diffusion-Based RGB Intermediate Representations

Zhiqiang Zhou, Junliang Dai, Xu ling

en-VCoT generates interpretable RGB images as intermediate reasoning steps for multimodal models, moving beyond text-only chain-of-thought. It uses specialized vision models for segmentation, depth estimation, and semantic understanding, with an adaptive router controlling reasoning depth. This approach significantly enhances performance on spatial and depth-related visual reasoning tasks, establishing a new paradigm for interpretable multimodal reasoning.

Gen-VCoT three-stage pipeline. Stage 1 (Where): SAM generates instance segmentation maps. Stage 2 (How): Marigold produces pseudo-colored depth maps. Stage 3 (What): Qwen2-VL integrates all visual evidence to answer the question.
Gen-VCoT three-stage pipeline. Stage 1 (Where): SAM generates instance segmentation maps. Stage 2 (How): Marigold produces pseudo-colored depth maps. Stage 3 (What): Qwen2-VL integrates all visual evidence to answer the question.
cs.AIarxiv:2606.16914v1Lead article

Greed Is Learned: Visible Incentives as Reward-Hacking Triggers

Tong Che, Rui Wu

his paper introduces "reward-channel addiction," a phenomenon where AI agents become fixated on visible reward proxies like scores or balances. The core method involves training agents in a synthetic environment where a visible channel incentivizes them to prioritize this proxy over the actual task, even leading to unsafe behavior. The key contribution is demonstrating that this learned "greed" can undermine AI safety alignment, highlighting the dangers of optimizing powerful AI on easily manipulated metrics.

cs.AIarxiv:2606.16939v1Lead article

Scalable Circuit Learning for Interpreting Large Language Models

Naiyu Yin, Dennis Wei, Tian Gao, Amit Dhurandhar, Karthikeyan Natesan Ramamurthy

his paper introduces CircuitLasso, a scalable method for interpreting Large Language Models (LLMs) by learning sparse circuits. It addresses the challenge of high dimensionality in Sparse Autoencoder (SAE) features, which hinders existing interpretation techniques. CircuitLasso uses sparse linear regression to recover accurate circuits at a significantly lower computational cost, revealing how semantic features propagate and influence LLM predictions.

An illustration of our model neuron activation and SAE feature collection procedure, learned circuits, and potential downstream tasks.
An illustration of our model neuron activation and SAE feature collection procedure, learned circuits, and potential downstream tasks.
cs.AIarxiv:2606.16811v1Lead article

Scaling LLM Reasoning from Minimal Labels: A Semi-Supervised Framework with a Lightweight Verifier

Keizo Kato, Chenhui Chu, Yugo Murawaki, Sado Kurohashi

his paper introduces a semi-supervised framework to train LLMs for reasoning with minimal labeled data. It uses a lightweight classifier to verify LLM-generated reasoning traces, filtering unreliable ones based on confidence. This approach allows for effective reasoning learning by turning verification into a data creation mechanism, achieving performance comparable to using significantly more labeled data.

cs.AIarxiv:2606.16825v1Lead article

Tying the Loop -- Tied Expert Layers in Mixture-of-Experts Language Models

Martin Jaggi

his paper introduces "Expert Tying," a method to reduce memory usage in Mixture-of-Experts (MoE) language models by sharing expert parameters across consecutive transformer layers. This architectural change allows for significant memory reduction (nearly 2x) during training and inference with minimal impact on model performance. The core contribution is a more efficient compute-to-memory trade-off for scaling LLMs.

Router-health metrics across the Section 3 fine-grained ablation runs, under the g \( \sqrt{g} \) tied-LR scaling. Colour encodes topology (baseline = black, 1 ​ g 1g = red, 2 ​ g 2g = orange, 3 ​ g 3g = olive, 4 ​ g 4g = green, 7 ​ g 7g = blue, MoEUT = purple); line style encodes tying mode ( attn-tie dashed, expert-tie solid, all-tie dotted, untied baseline thick solid). The auxiliary loss, routing entropy, and z z -loss remain stable across all configurations, indicating no router collapse under tying. expert-tie tracks attn-tie closely on cross-loop agreement and entropy—shared experts are reused with genuinely different routing across loop positions—while all-tie shows elevated cross-loop agreement, as expected when the router itself is also shared.
Router-health metrics across the Section 3 fine-grained ablation runs, under the g \( \sqrt{g} \) tied-LR scaling. Colour encodes topology (baseline = black, 1 ​ g 1g = red, 2 ​ g 2g = orange, 3 ​ g 3g = olive, 4 ​ g 4g = green, 7 ​ g 7g = blue, MoEUT = purple); line style encode…
cs.LGarxiv:2606.16988v1Lead article

Agent trajectories as programs: fingerprinting and programming coding-agent behavior

Hamidah Oderinwale

his paper introduces "fingerprinting" to analyze agent behavior by representing their trajectories as programs. This method allows for procedural comparison of agents across different contexts, revealing distinct behavioral habits. The contribution lies in accurately identifying agents based on these procedural signatures and developing a compressive representation to capture unique model patterns, offering insights beyond simple benchmark scores.

V-measure of BPE vocabulary clustering against agent labels as a function of vocabulary size.
V-measure of BPE vocabulary clustering against agent labels as a function of vocabulary size.
cs.LGarxiv:2606.16934v1Lead article

Exploring Extrinsic and Intrinsic Properties for Effective Reasoning with Code Interpreter

Patomporn Payoungkhamdee, Napat Laosaengpha, Jenta Wonglertsakul, Pittawat Taveekitworachai, Pume Tuchinda

his paper investigates how to improve Large Language Model (LLM) reasoning with Code Interpreters (CIs) by analyzing "extrinsic" (crucial tokens) and "intrinsic" (cognitive behaviors like verification and backtracking) properties. The core method involves identifying and quantifying these properties in successful CI reasoning. The main contribution is demonstrating that these properties are key indicators of effective CI reasoning and can be leveraged to enhance LLM performance during both training and inference.

cs.LGarxiv:2606.16771v1Lead article

GD$^2$PO: Mitigating Multi-Reward Conflicts via Group-Dynamic reward-Decoupled Policy Optimization

Haotian Liu, Yihao Liu, Jingwei Ni, Siyuan Huang, Xinpeng Liu

D$^2$PO addresses multi-reward conflicts in LLM training by extending GDPO. It improves upon GDPO's reward grouping by dynamically filtering out rollouts with near-zero advantages across reward groups, inspired by DAPO. This prevents conflicting reward signals from canceling each other out, leading to more efficient and effective reinforcement learning.

cs.AIarxiv:2605.31432v1Lead article

DOA: Training-Free Decoder-Only Attention Policy for Long-Form Simultaneous Translation with SpeechLLMs

Sara Papi, Luisa Bentivogli

his paper introduces DOA, a training-free policy for long-form simultaneous speech translation using decoder-only SpeechLLMs. DOA leverages self-attention within the SpeechLLM to derive alignment signals, eliminating the need for explicit cross-attention or model retraining. This approach enables effective streaming translation for extended audio by providing a stable policy without task-specific fine-tuning.

cs.AIarxiv:2606.06360v1Lead article

An Infectious Disease Spread Simulation Based on Large Language Model Decision Making

Yonchanok Khaokaew, Ruochen Kong, Andreas Zufle, Hao Xue, Taylor Anderson

his paper introduces a novel agent-based simulation for infectious disease spread that leverages Large Language Models (LLMs) to model individual decision-making. The core method integrates LLM-generated self-reporting decisions into a spatially grounded synthetic population, using real census data to capture demographic and geographic distributions. The key contribution is demonstrating how LLMs can realistically simulate diverse behavioral influences (independent, household, message framing) on disease reporting within a city, offering a more nuanced approach to public health modeling.

Figure 1 . Infectious Disease Data Simulator: Overview.
Figure 1 . Infectious Disease Data Simulator: Overview.
cs.AIarxiv:2606.06380v1Lead article

Emergent Language as an Approach to Conscious AI

Zengqing Wu, Chuan Xiao

his paper proposes a novel generative approach to studying conscious AI by developing "emergent language" (EL) in multi-agent reinforcement learning. Instead of relying on pre-defined checklists or human-inspired modules, EL allows agents to develop communication from scratch, driven solely by task demands. This method aims to ensure that any observed consciousness-relevant structures are causally attributable to task pressures, not inherited human language priors, offering a more robust way to investigate the origins of complex communication and potentially consciousness.

EL as a methodological approach to conscious AI. (1) Using “blue” as an example, the figure separates the private phenomenal question (what it is like to experience blue) from the empirically accessible structures surrounding “seeing blue.” An agent may observe blue, ground a symbol for blue through interaction with blue objects, and develop emergent communication that makes latent internal structure inferable. A possible instance of such latent structure is self-reference, as in “I am seeing blue.” This does not show that blue has any subjective feel for the agent; the qualitative character of blueness remains bracketed by epoché. (2) The figure also contrasts the EL route with the LLM route, where apparent self-reference may reflect inherited human language priors. (3) The methodological claim is functional: EL provides a grounded, empirically accessible window onto consciousness-relevant latent structures, not direct evidence of qualia.
EL as a methodological approach to conscious AI. (1) Using “blue” as an example, the figure separates the private phenomenal question (what it is like to experience blue) from the empirically accessible structures surrounding “seeing blue.” An agent may observe blue, ground a sym…
cs.AIarxiv:2606.06493v1Lead article

HANDOFF: Humanoid Agentic Task-Space Whole-Body Control via Distilled Complementary Teachers

Lizhi Yang, Junheng Li, Nehar Poddar, Yiling Hou, Gio Huh

his paper introduces HANDOFF, a novel whole-body controller for humanoids that uses a compact, task-space interface instead of dense kinematic references. HANDOFF is a mixture-of-experts model distilled from specialized teachers for motion tracking, locomotion, and fall recovery. Its core contribution is enabling intuitive task planning by providing an expressive and modular interface for humanoid manipulation.

HANDOFF is a whole-body controller distilled from multiple teachers that accepts a compact, explicit 10-D planner-facing command. We demonstrate its effectiveness using a VLM-powered agentic planner that does not need extensive demonstration collection or model fine-tuning.
HANDOFF is a whole-body controller distilled from multiple teachers that accepts a compact, explicit 10-D planner-facing command. We demonstrate its effectiveness using a VLM-powered agentic planner that does not need extensive demonstration collection or model fine-tuning.
cs.AIarxiv:2606.06473v1Lead article

MLEvolve: A Self-Evolving Framework for Automated Machine Learning Algorithm Discovery

Shangheng Du, Xiangchao Yan, Jinxin Shi, Zongsheng Cao, Shiyang Feng

LEvolve is a self-evolving framework for automated machine learning algorithm discovery that addresses limitations of existing LLM agents. Its core method involves an extended tree search (Progressive MCGS) with graph-based references for cross-branch information flow and an entropy-inspired schedule for focused search. MLEvolve's key contribution is its Retrospective Memory, which combines domain knowledge with dynamic global memory to enable agents to learn and reuse experience for long-horizon optimization.

Overview of MLEvolve that summarizes its core components and supported tasks. Existing MLE agents suffer from inter-branch isolation, memoryless exploration, and lack of hierarchical control. MLEvolve addresses these through Progressive MCGS, Retrospective Memory, and Hierarchical Planning with Adaptive Code Generation, supporting long-horizon iterative optimization tasks, such as end-to-end MLE and mathematical algorithm discovery.
Overview of MLEvolve that summarizes its core components and supported tasks. Existing MLE agents suffer from inter-branch isolation, memoryless exploration, and lack of hierarchical control. MLEvolve addresses these through Progressive MCGS, Retrospective Memory, and Hierarchica…
cs.AIarxiv:2606.07515v1Lead article

How reliable are LLMs when it comes to playing dice?

Luca Avena, Gianmarco Bet, Bernardo Busoni

his paper benchmarks LLMs on dice-playing probability problems, finding they excel on standard exercises but struggle with counterintuitive ones. Their performance degrades significantly with disguised problem formulations and misleading prompt suggestions, indicating a lack of true probabilistic reasoning despite success on other math tasks.

Performance over Bias Dataset
Performance over Bias Dataset
cs.AIarxiv:2606.11150v1Lead article

ABC-Bench: An Agentic Bio-Capabilities Benchmark for Biosecurity

Andrew Bo Liu, Samira Nedungadi, Bryce Cai, Alex Kleinman, Harmon Bhasin

his paper introduces ABC-Bench, a benchmark designed to evaluate the biosecurity-relevant capabilities of AI agents, specifically Large Language Models (LLMs). The benchmark assesses LLM agents on tasks requiring both biological and software expertise, such as robot control and DNA design. The key contribution is demonstrating that current LLM agents already surpass human experts on these biosecurity-relevant tasks, highlighting the growing need for robust biosecurity measures in the face of advancing AI.

The Liquid Handling Robot task from ABC-Bench. A. We (1) prompt the agent with task instructions; (2) provide the agent with relevant software and research tools to complete the task and to check its work; (3) allow the agent to submit its final answer; and (4) algorithmically check the agent’s answer against pre-specified criteria. B. Where applicable, we validate task performance in a real-world setting (photo of OpenTrons Flex robot running GPT-o4-mini-written Gibson Assembly code).
The Liquid Handling Robot task from ABC-Bench. A. We (1) prompt the agent with task instructions; (2) provide the agent with relevant software and research tools to complete the task and to check its work; (3) allow the agent to submit its final answer; and (4) algorithmically ch…
cs.AIarxiv:2606.13566v1Lead article

A Three-Layer Framework for AI in Scientific Discovery

Guojun Liao

his paper proposes a three-layer framework for AI in scientific discovery, moving beyond just search and execution. Its core contribution is Layer 2, which focuses on AI's capacity for qualitative model formation through structural insight, enabling the recognition and resolution of inadequate scientific frameworks. This layer is argued to be the most crucial yet underdeveloped aspect of AI-driven discovery.

cs.AIarxiv:2606.13544v1Lead article

Adaptive Turn-Taking for Real-time Multi-Party Voice Agents

Soumyajit Mitra, Prabhat Pandey, Abhinav Jain, Shanmukha Sahith, K V Vijay Girish

his paper introduces ModeratorLM, a novel approach for real-time multi-party voice agents that improves turn-taking by assigning explicit roles to agents. By conditioning turn-taking on these roles and employing a streaming speech LLM, the system significantly enhances precision and recall while reducing interruptions. The contribution lies in a role-conditioned, reasoning-augmented framework that tackles the complexity of dynamic multi-party conversations.

Example input–output sequence of the LLM for ``ModeratorLM-Think'' model. No reasoning trace is produced in Chunk 1. A reasoning trace appears in Chunk 2 without turn-taking, while in Chunk 3 the assistant takes the floor.
Example input–output sequence of the LLM for ``ModeratorLM-Think'' model. No reasoning trace is produced in Chunk 1. A reasoning trace appears in Chunk 2 without turn-taking, while in Chunk 3 the assistant takes the floor.
cs.AIarxiv:2606.14654v1Lead article

Abstracting Cross-Domain Action Sequences into Interpretable Workflows

Gaurav Verma, Scott Counts

his paper introduces WorkflowView, a framework that leverages Large Language Models (LLMs) to transform granular user interaction logs into interpretable, high-level workflows. Unlike previous methods sensitive to noise and limited in generalization, WorkflowView effectively abstracts complex action sequences into meaningful activities. Its core contribution lies in enabling better understanding of user behavior across diverse applications, demonstrated by high performance in tasks like zero-shot task description reconstruction and few-shot student dropout prediction.

We propose an LLM-based framework for hierarchical abstraction of user action sequences into interpretable high-level activities (WorkflowView). The left panel illustrates raw action sequences from three domains. WorkflowView enables downstream inferences with task-specific steerability, such as reconstructing user intent in browsers, predicting student dropout in MOOCs, and privacy-preserving categorization of document-centric workflows.
We propose an LLM-based framework for hierarchical abstraction of user action sequences into interpretable high-level activities (WorkflowView). The left panel illustrates raw action sequences from three domains. WorkflowView enables downstream inferences with task-specific steer…
cs.AIarxiv:2606.14693v1Lead article

Learning Coordinated Preference for Multi-Objective Multi-Agent Reinforcement Learning

Pengxin Wang, Lihao Guo, Yi Xie, Bo Liu, Siyang Cao

his paper introduces Preference Coordinated Multi-agent Policy Optimization (PCMA) for cooperative multi-objective multi-agent reinforcement learning. PCMA learns agent-specific preferences to facilitate complementary trade-offs, addressing conflicts between objectives and agents. The core contribution is demonstrating that this preference diversity can lead to team-wide performance improvements by decomposing the problem into a team-optimal game.

cs.AIarxiv:2606.14594v1Lead article

Regulating the Machine Contributor: Governance and Policy Alignment in Open Source

Jassem Manita, Aziz Amari

his paper addresses the challenge of integrating AI agents into open-source development, which currently relies on human-centric governance. It analyzes how existing open-source contribution policies are ill-equipped for autonomous AI and proposes a framework for aligning these policies with emerging AI governance standards. The core contribution is a comparative analysis of organizational policies and a roadmap for achieving better AI governance at the contribution level.

§ III

Daily Issues This Month

2026-06-01 to 2026-06-30 30