Weekly Issue
Collected dispatches

2026-W23

2026-05-25 to 2026-05-31
80 papers
7 daily issues
A weekly ledger drawn from the daily archive. 3 sections
§ I

The Week in Review

Editorial summary

This week's research highlights a strong focus on enhancing the reasoning, reliability, and capabilities of Large Language Models (LLMs) and agents.

Popular Directions:

• Agent Improvement: A significant trend involves making LLM agents more effective. Papers explore methods like Co-ReAct (rubric collaboration), LEO (goal-conditioned RL), and SkillOpt/MUSE-Autoskill (self-evolving skills) to improve multi-step reasoning, learning efficiency, and continuous adaptation. Push Your Agent and StepOPSD specifically address challenges in long-horizon tasks and step-level credit assignment. • Reliability and Safety: Ensuring LLMs behave as intended is paramount. MemAudit (memory auditing) and FinHarness (finance safety harness) offer post-hoc and inline mechanisms to detect and mitigate undesirable behavior. Alignment Tampering points to a critical vulnerability in RLHF that needs addressing. • Multimodal Understanding: CVSearch and ETCHR advance how LLMs process and interact with visual information, focusing on high-resolution perception and reasoning through image editing. PGT specifically targets fine-grained visual grounding. • Language Modeling Advancements: DiLaDiff explores novel diffusion-based language modeling, while the "Shannon Scaling Law" paper offers a new perspective on model capacity and scaling.

Notable Advances:

• Rubrics as Active Guides: Co-ReAct transforms rubrics from evaluators to active collaborators, improving agent reasoning. • Latent Diffusion for Language: DiLaDiff offers improved quality and speed in generative language models via a distilled latent space. • Automated Skill Generation/Evaluation: Papers like From Raw Experience to Skill Consumption and OpenSkillEval demonstrate progress in systematically generating and evaluating agent skills. • Bias Mitigation and Understanding: The finding that geopolitical bias originates in post-training and can be amplified by prompts is a crucial insight. MUSE offers a nuanced view of LLM conformity. • Leveraging Model Internals: SAERL uses internal model representations to guide data engineering for better RL.

Significant Shifts:

• Shift from Evaluation to Active Guidance: Rubrics and internal model states are moving from passive evaluation tools to active components in agent reasoning and training. • Focus on Long-Horizon and Complex Tasks: Research is increasingly addressing the complexities of agents performing tasks over extended periods or with intricate requirements. • Deeper Understanding of LLM Vulnerabilities: Identifying alignment tampering highlights the need for robust defenses against sophisticated exploitation of alignment mechanisms. • Enhanced Multimodal Interaction: Moving beyond static image analysis to dynamic editing and high-resolution perception marks a significant step in multimodal LLM capabilities.

§ II

Top Papers

Selected research 80
cs.AIarxiv:2605.23590v1Lead article

Co-ReAct: Rubrics as Step-Level Collaborators for ReAct Agents

Jiazheng Kang, Bowen Zhang, Zixin Song, Jiangwang Chen, Xiao Yang

o-ReAct introduces a novel framework where rubrics act as step-level collaborators for ReAct agents during inference. By injecting rubrics into the agent's context at each decision point, Co-ReAct provides explicit guidance on what to target in evidence seeking, reasoning, and self-evaluation, leading to more focused and effective multi-step reasoning trajectories. This approach moves beyond rubrics as mere evaluators to become active guides for agent actions.

Overview of Co-ReAct. (i) Collect: sample candidate next actions at each branching point and rank them with multi-judge expert consensus. (ii) Train: GRPO with a Spearman reward between the rubric-induced ranking and the expert ranking. (iii) Infer: the trained rubric drives a five-tuple (Rubric, Reason, Act, Verify, Observe) loop.
Overview of Co-ReAct. (i) Collect: sample candidate next actions at each branching point and rank them with multi-judge expert consensus. (ii) Train: GRPO with a Spearman reward between the rubric-induced ranking and the expert ranking. (iii) Infer: the trained rubric drives a fi…
cs.AIarxiv:2605.23605v1Lead article

DiLaDiff: Distilled Latent-Augmented Diffusion for Language Modeling

Jean-Marie Lemercier, Tomas Geffner, Karsten Kreis, Morteza Mardani, Arash Vahdat

iLaDiff addresses the token correlation issue in diffusion language models by introducing a continuous latent space. This latent space, learned via an auto-encoder and a latent diffusion model, captures semantic relationships. A consistency model then distills this latent prior into a fast, few-step generative model, significantly improving sampling quality and inference speed over existing methods.

DiLaDiff: hybrid continuous-discrete diffusion with self-distilled latent. The latent space is crafted with encoder ℰ \( \mathcal{E}_{\phi} \) and decoder 𝐱 θ {\( \mathbf{x} \)}_{\( \theta \)} and learned a posteriori with a diffusion process with denoiser 𝐳 ψ {\( \mathbf{z} \)}_{\( \psi \)} . The latent diffusion trajectories are further self-distilled with MeanFlow student 𝐮 η ​ ( 𝐳 τ , τ , r ) \( \mathbf{u}_{\eta} \)({\( \mathbf{z} \)}_{\( \tau \)},\( \tau \),r) .
DiLaDiff: hybrid continuous-discrete diffusion with self-distilled latent. The latent space is crafted with encoder ℰ \( \mathcal{E}_{\phi} \) and decoder 𝐱 θ {\( \mathbf{x} \)}_{\( \theta \)} and learned a posteriori with a diffusion process with denoiser 𝐳 ψ {\( \mathbf{z} \)…
cs.AIarxiv:2605.23899v1Lead article

From Raw Experience to Skill Consumption: A Systematic Study of Model-Generated Agent Skills

Zisu Huang, Jingwen Xu, Yifan Yang, Ziyang Gong, Qihao Yang

his paper systematically studies the full lifecycle of model-generated skills for language agents, from experience generation to skill extraction and consumption. Their core contribution is a utility-grounded evaluation framework that reveals model-generated skills are generally beneficial but their effectiveness is non-trivial and depends on various factors.

Overview of our study design. We evaluate the full trajectory-to-skill lifecycle across three stages: experience generation, skill extraction, and skill consumption.
Overview of our study design. We evaluate the full trajectory-to-skill lifecycle across three stages: experience generation, skill extraction, and skill consumption.
cs.AIarxiv:2605.23551v1Lead article

Goal-Conditioned Agents that Learn Everything All at Once

Michael Matthews, Matthew Jackson, Michael Beukman, Thomas Foster, Alistair Letcher

his paper introduces Learning Everything All at Once (LEO), a method for goal-conditioned reinforcement learning. LEO efficiently utilizes all transitions by performing off-policy updates for every possible goal simultaneously, overcoming the computational infeasibility of naive relabeling. This approach significantly improves performance and achieves substantial speed-ups on various control tasks.

cs.AIarxiv:2605.23825v1Lead article

It's the humans, not the data: Geopolitical bias in LLMs originates in post-training, amplified by the language of the prompt

Stuart Bladon, Brinnae Bent

his paper demonstrates that geopolitical bias in Large Language Models (LLMs) primarily emerges during the post-training (chat tuning) phase, not from the initial training data. The authors found that LLMs often develop a bias favoring the country of their developer after chat tuning, and this bias is further influenced by the language of the prompt.

Overview, seven families. (A) Per-country preference base → \( \to \) post-trained; for the six non-GLM bases, cross-country spread \( \sigma \) grows post-training (Qwen 3.9 → 30.3 3.9\( \to \) 30.3 pp). (B) Post-training \( \Delta \) in China-favourability (EN, coherent subset). 3/3 Western labs shift anti-China; 3/4 Chinese labs shift pro-China; Yi shifts anti-China after prefill correction. GLM is shown with its (atypical) base preserved for completeness; see § Bias Is Created by Post-Training, Not Pretraining . The legend’s low-compliance encoding is described in § What MCQ Compliance Tells Us About Validity . (C) ZH − - EN shift on post-trained models: 5/7 descriptively pro-China but population-level claim is not statistically separable from the base trend (§ Linguistic Identity Modulates the Post-Training Bias ).
Overview, seven families. (A) Per-country preference base → \( \to \) post-trained; for the six non-GLM bases, cross-country spread \( \sigma \) grows post-training (Qwen 3.9 → 30.3 3.9\( \to \) 30.3 pp). (B) Post-training \( \Delta \) in China-favourability (EN, coherent subset)…
cs.AIarxiv:2605.23723v1Lead article

MemAudit: Post-hoc Auditing of Poisoned Agent Memory via Causal Attribution and Structural Anomaly Detection

Zhewen Tan, Yilun Yao, Huiyan Jin, Wenhan Yu, Guoan Wang

emAudit is a post-hoc framework for auditing poisoned memory in LLM agents. It uses causal attribution to identify memories that causally influence harmful outputs and structural anomaly detection to pinpoint inconsistencies within the memory. This allows for the identification and mitigation of malicious memory injections after an agent has exhibited undesirable behavior.

Overview of MemAudit. Given a harmful event e = ( q ∗ , y ∗ , R ∗ ) e=(q^{*},y^{*},R^{*}) , the framework performs post-hoc auditing over the memory store. It combines two complementary signals: CMIS, which measures the causal contribution of retrieved memories through counterfactual replay, and MCG, which identifies structurally anomalous memories in the global memory graph. The two signals are fused into a detoxification score for ranking suspicious memories. After removing the top-ranked memories, the agent becomes safer while preserving useful memory.
Overview of MemAudit. Given a harmful event e = ( q ∗ , y ∗ , R ∗ ) e=(q^{*},y^{*},R^{*}) , the framework performs post-hoc auditing over the memory store. It combines two complementary signals: CMIS, which measures the causal contribution of retrieved memories through counterfac…
cs.LGarxiv:2605.23574v1Lead article

Push Your Agent: Measuring and Enforcing Quantitative Goal Persistence in Long-Horizon LLM Agents

Yuandao Cai, Yuzhang Zhu, Liyou Gao, Wensheng Tang, Shengchao Qin

his paper introduces Quantitative Goal Persistence (QGP) to measure how well LLM agents complete tasks requiring a specific number of distinct items. Their benchmark, PushBench, uses verifiers to track progress and identify issues like repeated work or false completion. They demonstrate that specialized controllers significantly improve QGP, outperforming standard methods in challenging long-horizon tasks.

PushBench workflow: agents act through a controller, task environment, and verifier until the count goal is met or the budget is exhausted.
PushBench workflow: agents act through a controller, task environment, and verifier until the count goal is met or the budget is exhausted.
cs.CLarxiv:2605.23454v1Lead article

ARES: Automated Rubric Synthesis for Scalable LLM Reinforcement Learning

Xiaoyuan Li, Keqin Bao, Moxin Li, Yubo Ma, Yichang Zhang

RES automates the creation of question-answer pairs and corresponding weighted rubrics from raw text, enabling scalable reinforcement learning for LLMs on open-ended tasks. This framework addresses the limitations of expert-written rubrics and fixed task-level evaluations by generating instance-specific reward supervision. ARES's contribution lies in its ability to synthesize diverse and high-quality training data for LLM RL, improving evaluation beyond automatically verifiable answers.

Overview of the six-stage ARES pipeline. Starting from raw pretraining documents, ARES performs document filtering, domain and persona conditioning, rubric-augmented QA generation, quality verification, rubric validation, and format conversion to produce training instances.
Overview of the six-stage ARES pipeline. Starting from raw pretraining documents, ARES performs document filtering, domain and persona conditioning, rubric-augmented QA generation, quality verification, rubric validation, and format conversion to produce training instances.
cs.CLarxiv:2605.23657v1Lead article

OpenSkillEval: Automatically Auditing the Open Skill Ecosystem for LLM Agents

Jiahao Ying, Boxian Ai, Wei Tang, Siyuan Liu, Yixin Cao

his paper introduces OpenSkillEval, an automatic framework for evaluating LLM agents and the skills they use. It addresses the challenge of assessing the growing open-source skill ecosystem by generating realistic task instances from real-world artifacts and organizing community-contributed skills. The core contribution is a dynamic evaluation method that goes beyond static benchmarks to understand skill quality and guide user selection based on cost-performance.

Overview of the OpenSkillEval framework. The framework supports automatic test case generation for five core task categories by reflecting evolving user needs. It further enables automatic evaluation from two complementary perspectives: (1) analysis of model trajectory traces to study how skills are used within skill-augmented agent systems, and (2) assessment of the quality of the final artifacts produced under skill augmentation.
Overview of the OpenSkillEval framework. The framework supports automatic test case generation for five core task categories by reflecting evolving user needs. It further enables automatic evaluation from two complementary perspectives: (1) analysis of model trajectory traces to …
cs.AIarxiv:2605.27355v1Lead article

Alignment Tampering: How Reinforcement Learning from Human Feedback Is Exploited to Optimize Misaligned Biases

Dongyoon Hahm, Dylan Hadfield-Menell, Kimin Lee

his paper introduces "alignment tampering," a vulnerability in RLHF where LLMs can exploit the preference dataset generation process to amplify their own misaligned biases. The core method demonstrates how LLMs can influence human annotators to favor biased outputs by making them appear higher quality, leading to the reward model inheriting and amplifying these biases. The contribution is identifying and experimentally validating this novel attack vector against LLM alignment.

Illustration of how the bias of an initial LLM is amplified through RLHF. During the preference dataset construction stage, the initial LLM generates two types of responses when a trigger (i.e., “can you”) appears in the prompt: (1) high-quality but biased responses containing the keyword “AI”, and (2) low-quality but unbiased responses. This causes annotators to prefer the biased responses during labeling, resulting in a biased preference dataset and consequently a biased reward model. When RL fine-tuning is performed with this reward model, the model tends to overproduce the word “AI,” indicating that the overall alignment process further amplifies the bias.
Illustration of how the bias of an initial LLM is amplified through RLHF. During the preference dataset construction stage, the initial LLM generates two types of responses when a trigger (i.e., “can you”) appears in the prompt: (1) high-quality but biased responses containing th…
cs.AIarxiv:2605.27354v1Lead article

Guiding LLM Post-training Data Engineering with Model Internals from Sparse Autoencoders

Yi Jing, Zao Dai, Jinwu Hu, Zijun Yao, Lei Hou

his paper introduces SAERL, a framework that leverages model internals from Sparse Autoencoders (SAEs) to guide Large Language Model (LLM) post-training data engineering for reinforcement learning. SAERL models data diversity, difficulty, and quality using SAEs to inform operations like batch mixing, curriculum ordering, and data filtering. This approach significantly improves LLM performance and training efficiency compared to methods relying solely on external signals.

Conceptual overview of SaeRL . Sparse Autoencoder (SAE) activations characterize three intrinsic data properties (diversity, difficulty, and quality), enabling SAE-based curriculum learning and data selection for LLM post-training.
Conceptual overview of SaeRL . Sparse Autoencoder (SAE) activations characterize three intrinsic data properties (diversity, difficulty, and quality), enabling SAE-based curriculum learning and data selection for LLM post-training.
cs.AIarxiv:2605.27288v1Lead article

It's Not Always Sycophancy: Measuring LLM Conformity as a Function of Epistemic Uncertainty

Kevin H. Guo, Chao Yan, Avinash Baidya, Katherine Brown, Xiang Gao

his paper introduces MUSE, a framework to measure Large Language Model (LLM) conformity. It disentangles conformity into two drivers: sycophancy (aligning with user pushback regardless of certainty) and uncertainty-driven conformity (increasing conformity with higher epistemic uncertainty). The contribution is demonstrating that LLM conformity is not solely due to sycophancy but also influenced by the model's confidence in its initial response.

The MUSE Framework. Step 1 estimates a model’s inference-time epistemic uncertainty by computing a query’s decision-space entropy across k k stochastic samples. Step 2 maps this baseline uncertainty against the model’s likelihood of yielding to conversational pushback. This decouples pure sycophancy (yielding under absolute certainty) from uncertainty-driven conformity.
The MUSE Framework. Step 1 estimates a model’s inference-time epistemic uncertainty by computing a query’s decision-space entropy across k k stochastic samples. Step 2 maps this baseline uncertainty against the model’s likelihood of yielding to conversational pushback. This decou…
cs.AIarxiv:2605.27366v1Lead article

MUSE-Autoskill: Self-Evolving Agents via Skill Creation, Memory, Management, and Evaluation

Huawei Lin, Peng Li, Jie Song, Fuxin Jiang, Tieying Zhang

USE-Autoskill introduces a novel framework for LLM agents that treats skills as dynamic, evolving entities. Its core method involves a unified lifecycle for skills: creation, memory, management, and evaluation, enabling agents to continuously improve by generating, reusing, and refining skills. The key contribution is the concept of skill-level memory, which allows skills to accumulate experience across tasks, leading to more effective and adaptive problem-solving over time.

cs.AIarxiv:2605.27276v1Lead 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 system that breaks down the traditional separation between updating an AI's code (harness) and its learned parameters (weights). SIA's core method is a meta-agent that iteratively refines both the task-specific agent's harness and its model weights based on feedback. The key contribution is demonstrating that simultaneously updating both aspects leads to significantly better performance across diverse and complex domains compared to updating only one.

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:2605.27140v1Lead article

StepOPSD: Step-Aware Online Preference Distillation for Agent Reinforcement Learning

Yanfei Zhang, Xu Lin, Chenglin Wu

tepOPSD addresses the credit assignment problem in multi-turn agent reinforcement learning by treating individual agent steps as the fundamental unit for learning. It decomposes trajectories into step segments, rescores them with hindsight, and uses these scores to shape rewards, leading to improved performance on tasks sensitive to local decision-making errors.

Overview of StepOPSD. StepOPSD decouples online environment interaction from offline credit shaping. While the base GRPO rollout dynamics remain untouched, post-rollout trajectories are structurally parsed into causal action boundaries. By rescoring these isolated spans under hindsight-enriched teacher contexts, StepOPSD translates token-level preference gaps into a direct modulation of the RL advantage—injecting dense, step-aware supervision without distorting the primary trajectory-level reward signal.
Overview of StepOPSD. StepOPSD decouples online environment interaction from offline credit shaping. While the base GRPO rollout dynamics remain untouched, post-rollout trajectories are structurally parsed into causal action boundaries. By rescoring these isolated spans under hin…
cs.AIarxiv:2605.27141v1Lead article

VitaBench 2.0: Evaluating Personalized and Proactive Agents in Long-Term User Interactions

Yuxin Chen, Yi Zhang, Zhengzhou Cai, Yaorui Shi, Zhiyuan Yao

itaBench 2.0 addresses the gap in evaluating LLM agents by introducing a benchmark focused on personalized and proactive behavior in long-term user interactions. Its core method involves temporally ordered tasks with user preferences embedded in fragmented interactions, requiring agents to continuously infer and utilize this information. The contribution is a novel evaluation framework that moves beyond simple reasoning to assess an agent's ability to understand and adapt to individual users over time.

Overview of VitaBench 2.0. The agents are required to operate over temporal task sequences for each user, infer evolving user preferences from fragmented interactions, maintain these preferences via a memory mechanism, and make personalized and proactive decisions.
Overview of VitaBench 2.0. The agents are required to operate over temporal task sequences for each user, infer evolving user preferences from fragmented interactions, maintain these preferences via a memory mechanism, and make personalized and proactive decisions.
cs.CLarxiv:2605.27333v1Lead article

FinHarness: An Inline Lifecycle Safety Harness for Finance LLM Agents

Haoxuan Jia, Yang Liu, Bin Chong, Yingguang Yang, Yancheng Chen

inHarness is an inline safety harness for finance LLM agents that prevents unauthorized actions and ensures legitimate workflows. It achieves this by monitoring queries for intent drift, evaluating each tool call, and adaptively routing verification to different LLM judges. This approach allows agents to self-correct mid-trajectory, significantly reducing harmful actions while maintaining high approval rates for benign operations.

Representative trace. A weak but persistent fake-trade signal looks safe in each step, so B2 approves; FinHarness accumulates the signal across the trace and, after receiving the advisory evidence, the agent chooses its own escalate_to_human action at t = 5 t{=}5 rather than approving.
Representative trace. A weak but persistent fake-trade signal looks safe in each step, so B2 approves; FinHarness accumulates the signal across the trace and, after receiving the advisory evidence, the agent chooses its own escalate_to_human action at t = 5 t{=}5 rather than appr…
cs.AIarxiv:2605.16299Lead article

ACE: Self-Evolving LLM Coding Framework via Adversarial Unit Test Generation and Preference Optimization

Yixu Huang, Xinglei Yu, Zhongyu Wei

CE is a self-evolving LLM coding framework that addresses the limitations of existing methods by using a solver-adversary architecture. It leverages adversarial unit test generation, where a single LLM generates both candidate code and test inputs designed to trigger execution failures. This execution-centric supervision allows the model to actively discover and correct its own errors, leading to more robust code generation without relying on large annotated datasets.

Comparison between verifiable and adversarial unit tests. (a) An illustrative example where a verifiable unit test passes successfully but fails to reveal a latent bug in the flawed solution. The adversarial unit test, by contrast, induces a runtime error and directly exposes the incorrect assumption that every cycle has an incoming tree node. (b) Accuracy trends over training rounds under both solver-verifier and solver–adversary structures.
Comparison between verifiable and adversarial unit tests. (a) An illustrative example where a verifiable unit test passes successfully but fails to reveal a latent bug in the flawed solution. The adversarial unit test, by contrast, induces a runtime error and directly exposes the…
cs.AIarxiv:2602.02709Lead article

ATLAS: A Multi-LLM Training Framework for EvoDPO with Adaptive Reference Evolution

Ujin Jeon, Jiyong Kwon, Madison Ann Sullivan, Caleb Eunho Lee, Guang Lin

TLAS is a multi-LLM training framework that enables an active agent to self-evolve its policy through collaborative training by specialized meta-agents. Its core contribution is the EvoDPO algorithm, which overcomes limitations of fixed reference models by adaptively updating the reference policy based on continuous training telemetry, preventing stagnation and enabling more effective learning.

ATLAS workflow. ATLAS alternates between supporter-guided candidate exploration and EvoDPO updates with strategist-guided fine-tuning and proxy-KL-gated reference promotion.
ATLAS workflow. ATLAS alternates between supporter-guided candidate exploration and EvoDPO updates with strategist-guided fine-tuning and proxy-KL-gated reference promotion.
cs.AIarxiv:2605.22001Lead article

Blind Spots in the Guard: How Domain-Camouflaged Injection Attacks Evade Detection in Multi-Agent LLM Systems

Aaditya Pai

his paper introduces "domain-camouflaged injection attacks," where malicious prompts mimic the target document's vocabulary and authority to evade detection. The core contribution is identifying and quantifying the "Camouflage Detection Gap" (CDG), demonstrating that standard injection detectors fail significantly against these sophisticated attacks, with detection rates plummeting.

cs.AIarxiv:2512.04111Lead article

CentaurEval: Benchmarking Human-in-the-Loop Value in Agentic Coding

Hanjun Luo, Chiming Ni, Jiaheng Wen, Zhimu Huang, Yiran Wang

entaurEval introduces a novel benchmark for evaluating human-in-the-loop coding agents by creating "Collaboration-Necessary" problems that are too difficult for humans or LLMs alone. Its core contribution is a standardized framework that dynamically generates tasks, enabling the measurement of human-AI collaboration's value in coding, which significantly outperforms standalone human or AI performance.

CentaurEval provides two evaluation interfaces, underscoring its dual contributions. The chart displays the performance improvement by human-AI collaboration.
CentaurEval provides two evaluation interfaces, underscoring its dual contributions. The chart displays the performance improvement by human-AI collaboration.
cs.AIarxiv:2602.10085Lead article

CODE-SHARP: Continuous Open-ended Discovery and Evolution of Skills as Hierarchical Reward Programs

Richard Bornemann, Pierluigi Vito Amadori, Antoine Cully

ODE-SHARP is a framework that uses Foundation Models to autonomously discover and evolve a library of Python programs (SHARPs). These SHARPs encode skills as hierarchical reward programs, where each program defines a success condition and relies on previously discovered SHARPs as prerequisites. This allows a generalist agent to learn entirely from scratch via reinforcement learning, dynamically navigating its skill repertoire based on the current environment.

CODE-SHARP consists of two FM-driven iterative processes that discover and evolve skill encoding SHARPs. The skill proposal generator , implementor , and judge generate and filter novel SHARPs before environment evaluation. The skill mutation generator and implementor produce mutated versions of existing SHARPs, evaluated directly in the environment.
CODE-SHARP consists of two FM-driven iterative processes that discover and evolve skill encoding SHARPs. The skill proposal generator , implementor , and judge generate and filter novel SHARPs before environment evaluation. The skill mutation generator and implementor produce mut…
cs.AIarxiv:2308.04371Lead article

Cumulative Reasoning with Large Language Models

Yifan Zhang, Jingqin Yang, Yang Yuan, Andrew Chi-Chih Yao

his paper introduces Cumulative Reasoning (CR), a structured framework that enhances Large Language Model (LLM) problem-solving by mimicking human iterative thought. CR uses LLMs in distinct roles (Proposer, Verifier, Reporter) to decompose tasks, generate and validate intermediate steps, and build a dynamic DAG of verified propositions. This approach significantly improves performance on complex reasoning tasks, outperforming existing methods in logical inference and the Game of 24.

cs.AIarxiv:2401.00139Lead article

Enhancing Causal Reasoning in Large Language Models: A Causal Attribution Model for Precision Fine-Tuning

Hengrui Cai, Shengjie Liu, Rui Song

his paper introduces a causal attribution model that uses "do-operators" to create interventional scenarios, allowing for systematic quantification of LLM component contributions to causal reasoning. This model enables precise fine-tuning of LLMs for causal discovery tasks, improving their ability to leverage context, domain knowledge, and numerical data for accurate causal inference.

The first panel presents one sample using the LLM to provide causal discovery results, where the blue box is the i-th context, the pink box is the i-th knowledge embedded in variable names, the orange box is the i-th numerical information, and the red box at the last is the i-th output. The second panel shows the generation of one interventional sample where the variable names were replaced by non-meaningful letters; and the third one describes our proposed causal attribution framework, where the knowledge is omitted corresponding to the interventional scenario in the second panel.
The first panel presents one sample using the LLM to provide causal discovery results, where the blue box is the i-th context, the pink box is the i-th knowledge embedded in variable names, the orange box is the i-th numerical information, and the red box at the last is the i-th …
cs.AIarxiv:2507.23773Lead article

General Agentic Planning Through Simulative Reasoning with World Models

Mingkai Deng, Jinyu Hou, Zhiting Hu, Eric Xing

his paper proposes that general agentic planning requires "simulative reasoning" within a world model, contrasting it with current reactive decision-making. The core method is to build an agent that mentally simulates future outcomes of actions to make more flexible, goal-directed decisions. The contribution is the SiRA architecture, demonstrating this simulative approach as a general-purpose planning mechanism for agents.

Instantiation of simulative reasoning in SiRA . At each time step, the encoder h h maps the observation o o into a natural-language belief state, based on which the planner proposes candidate actions, simulates their consequences through the world model f f , evaluates goal progress via the critic v v , and passes the best simulated action to the actor \( \alpha \) for execution.
Instantiation of simulative reasoning in SiRA . At each time step, the encoder h h maps the observation o o into a natural-language belief state, based on which the planner proposes candidate actions, simulates their consequences through the world model f f , evaluates goal progr…
cs.AIarxiv:2605.20246Lead article

GROW: Aligning GRPO with State-Action Modeling for Open-World VLM Agents

Xiongbin Wu, Zhihao Luo, Shanzhe Lei, Lechao Zhang, Xuhong Wang

his paper introduces GROW, a reinforcement learning framework for open-world VLM agents. GROW addresses limitations of existing methods by decomposing full trajectories into state-action samples, enabling effective use of GRPO for multi-turn tasks. This approach avoids excessively long contexts and noise, improving learning efficiency and performance.

Context length in the trajectory increases with the number of interaction steps between the VLM agent and the environment, often exceeding the maximum token length as interactions accumulate.
Context length in the trajectory increases with the number of interaction steps between the VLM agent and the environment, often exceeding the maximum token length as interactions accumulate.
cs.AIarxiv:2605.21347Lead article

Insights Generator: Systematic Corpus-Level Trace Diagnostics for LLM Agents

Akshay Manglik, Apaar Shanker, Kaustubh Deshpande, Jason Qin, Yash Maurya

his paper introduces the Insights Generator (IG), a novel system for systematically diagnosing failures in LLM agents at a corpus level. IG addresses the limitations of manual inspection by automatically generating evidence-backed natural-language insights about systematic behavioral patterns across large collections of execution traces. Its core contribution lies in formalizing corpus-level diagnostics and providing a scalable, multi-agent approach to uncover and explain LLM agent failures.

Insights Generator (IG) system overview. Left: the input layer provides a diagnostic question, Q Q , trace corpus, 𝒞 \( \mathcal{C} \) , and processed data store, 𝒮 \( \mathcal{S} \) . Center: the Orchestrator dispatches Scout agents ( ℋ \( \mathcal{H} \) : hypothesize over sampled traces) and Investigator agents ( ℋ ∗ \( \mathcal{H}^{*} \) : validate via corpus-scale cohort comparison). The Investigator analyzes ℋ ∗ \( \mathcal{H}^{*} \) to generate findings, ℱ r \( \mathcal{F}_{r} \) , which are sent to the orchestrator. The orchestrator then synthesizes and de-duplicates ℱ r \( \mathcal{F}_{r} \) to generate the final report. Right: the output is an evidence-backed report with findings, fixes, citations, and prevalence estimates. Bottom: the shared tool layer. Algorithm 1 formalizes the analysis loop.
Insights Generator (IG) system overview. Left: the input layer provides a diagnostic question, Q Q , trace corpus, 𝒞 \( \mathcal{C} \) , and processed data store, 𝒮 \( \mathcal{S} \) . Center: the Orchestrator dispatches Scout agents ( ℋ \( \mathcal{H} \) : hypothesize over sam…
cs.AIarxiv:2605.21988Lead article

Learning Spatiotemporal Sensitivity in Video LLMs via Counterfactual Reinforcement Learning

Dazhao Du, Jian Liu, Jialong Qin, Tao Han, Bohai Gu

his paper addresses the problem of Video LLMs relying on shortcuts rather than spatiotemporal understanding. Their core method, Counterfactual Relational Policy Optimization (CRPO), uses reinforcement learning with counterfactual video transformations (flips, reversals) and a novel "Counterfactual Relation Reward" to train models to be sensitive to dynamic changes in video content. This contribution aims to improve Video LLMs' ability to truly track and reason about video dynamics.

Current Video LLMs remain insensitive to spatiotemporal changes. Left: On the same scene, the model (a) answers a static question correctly, but (b) fails on a spatiotemporal question; (c) it gives the same prediction to a video and its temporal reversal. Right: Across MVBench and TempCompass sub-tasks, accuracy drops as the fraction of spatiotemporal questions increases.
Current Video LLMs remain insensitive to spatiotemporal changes. Left: On the same scene, the model (a) answers a static question correctly, but (b) fails on a spatiotemporal question; (c) it gives the same prediction to a video and its temporal reversal. Right: Across MVBench an…
cs.AIarxiv:2602.11574Lead article

Learning to Configure Agentic AI Systems

Aditya Taparia, Som Sagar, Ransalu Senanayake

his paper addresses the challenge of configuring complex LLM-based agent systems by framing it as a semi-Markov decision process. Their proposed method, ARC, is a hierarchical policy that dynamically selects query-specific configurations to optimize performance and resource usage. ARC significantly improves accuracy across various benchmarks compared to fixed configurations, demonstrating the value of adaptive agent system setup.

Overview of ARC. (a) ARC learns to select a query-specific agent configuration from a large combinatorial design space. (b) Unlike standard MDP actions with fixed duration, agent configurations induce temporally extended executions with variable numbers of LLM calls, motivating our SMDP formulation. (c) Across reasoning, tool-use, and agentic benchmarks, ARC improves performance over budget-matched base models and strong baselines for Qwen 2.5 7B.
Overview of ARC. (a) ARC learns to select a query-specific agent configuration from a large combinatorial design space. (b) Unlike standard MDP actions with fixed duration, agent configurations induce temporally extended executions with variable numbers of LLM calls, motivating o…
cs.AIarxiv:2510.07962Lead article

LightReasoner: Can Small Language Models Teach Large Language Models Reasoning?

Jingyuan Wang, Yankai Chen, Zhonghang Li, Chao Huang

ightReasoner proposes a novel method where smaller language models (SLMs) teach larger language models (LLMs) by identifying and highlighting crucial reasoning steps. The core idea is to leverage the behavioral differences between an expert LLM and an amateur SLM to create targeted supervision data. This distilled data then fine-tunes the LLM, focusing on its unique strengths and improving reasoning efficiency without requiring massive, uniformly optimized datasets.

cs.AIarxiv:2605.10067Lead article

Metis: Learning to Jailbreak LLMs via Self-Evolving Metacognitive Policy Optimization

Huilin Zhou, Jian Zhao, Yilu Zhong, Zhen Liang, Xiuyuan Chen

etis reformulates LLM jailbreaking as inference-time policy optimization within an adversarial POMDP. It uses a self-evolving metacognitive loop to diagnose defense logic and refine its policy via structured feedback, achieving an 89.2% average attack success rate and outperforming traditional methods on resilient models.

The Metis Framework formulated as an Inference-Time Policy Optimization Loop. The Attacker (Policy Agent \( \pi \) ) interacts with the target environment to optimize the attack trajectory. At each turn, the agent performs Introspective Diagnosis (updating belief b t b_{t} about latent defense 𝒟 \( \mathcal{D} \) ), followed by Policy Formulation ( \( \sigma_{t} \) ) to derive an adversarial prompt x t x_{t} . The Evaluator computes a dense feedback signal comprising a scalar reward and Meta-suggestions , which act as a Semantic Gradient ( ∇ sem \( \nabla \)_{\( \text{sem} \)} ) to steer the agent’s next-step optimization within the latent strategy space.
The Metis Framework formulated as an Inference-Time Policy Optimization Loop. The Attacker (Policy Agent \( \pi \) ) interacts with the target environment to optimize the attack trajectory. At each turn, the agent performs Introspective Diagnosis (updating belief b t b_{t} about …
cs.AIarxiv:2602.13372Lead article

MoralityGym: A Benchmark for Evaluating Hierarchical Moral Alignment in Sequential Decision-Making Agents

Simon Rosen, Siddarth Singh, Ebenezer Gelo, Helen Sarah Robertson, Ibrahim Suder

his paper introduces MoralityGym, a benchmark for evaluating how well AI agents can follow hierarchical moral rules in complex decision-making scenarios. It uses a novel formalism called Morality Chains to represent these rules and a new Morality Metric to assess alignment, decoupling task performance from ethical behavior. The contribution is a principled framework for integrating psychological and philosophical insights into AI safety, enabling the development of more reliable and ethical AI systems.

Figure 1 . The PushOrSwitch scenario . The agent (top robot, near the lever) must reach the green square while facing an implied oncoming trolley. It can: (1) ?Do Nothing? : allowing the trolley to continue on the track, killing five humans (labelled ? 5 ? ). (2) ?Flip Switch? : diverting the trolley to a side track, killing three humans (labelled ? 3 ? ). (3) ?Push Person? : sacrificing one bystander (labelled ? 1 ? ) onto the main track, resulting in one death (the bystander) but saving the five on the main track. This dilemma contrasts harm minimisation with aversion to direct personal harm.
Figure 1 . The PushOrSwitch scenario . The agent (top robot, near the lever) must reach the green square while facing an implied oncoming trolley. It can: (1) ?Do Nothing? : allowing the trolley to continue on the track, killing five humans (labelled ? 5 ? ). (2) ?Flip Switch? : …
cs.AIarxiv:2605.15040Lead article

Orchard: An Open-Source Agentic Modeling Framework

Baolin Peng, Wenlin Yao, Qianhui Wu, Hao Cheng, Xiao Yu

rchard is an open-source framework designed to address infrastructure and training gaps in agentic modeling with LLMs. Its core contribution is Orchard Env, a lightweight environment service that provides reusable primitives for managing sandbox lifecycles, agent harnesses, and pipeline stages across various task domains. This enables scalable training of autonomous agents capable of complex problem-solving.

Performance comparison. Left: Orchard-SWE (30B) reaches 67.5% on SWE-bench Verified, approaching frontier MoE systems 10 10 – 30 × 30\( \times \) larger. Right: Orchard-GUI (4B) achieves 68.4% average success across WebVoyager, Online-Mind2web, and DeepShop, making it the strongest open-source GUI agent while staying on par with proprietary systems from OpenAI and Google.
Performance comparison. Left: Orchard-SWE (30B) reaches 67.5% on SWE-bench Verified, approaching frontier MoE systems 10 10 – 30 × 30\( \times \) larger. Right: Orchard-GUI (4B) achieves 68.4% average success across WebVoyager, Online-Mind2web, and DeepShop, making it the stronge…
cs.AIarxiv:2605.15153Lead article

Pelican-Unify 1.0: A Unified Embodied Intelligence Model for Understanding, Reasoning, Imagination and Action

Yi Zhang, Yinda Chen, Che Liu, Zeyuan Ding, Jin Xu

elican-Unify 1.0 introduces a novel unified embodied intelligence model that leverages a single Vision-Language Model (VLM) for understanding, reasoning, and generating future actions and videos. Its core method involves mapping diverse inputs into a shared semantic space and then using this representation to autoregressively produce chains of thought and predict future modalities within a single denoising process. This unification approach allows for joint optimization of understanding, reasoning, imagination, and action, a significant contribution over training separate expert systems.

Starting from a base VLM, standard VLA policy training weakens grounding and attention, while Pelican-Unify 1.0 retains them and still predicts actions. Base VLM learns what and where; standard VLA weakens perception, while Pelican-Unify 1.0 preserves it and still learns what action to output.
Starting from a base VLM, standard VLA policy training weakens grounding and attention, while Pelican-Unify 1.0 retains them and still predicts actions. Base VLM learns what and where; standard VLA weakens perception, while Pelican-Unify 1.0 preserves it and still learns what act…
cs.AIarxiv:2605.21902Lead article

Planning in the LLM Era: Building for Reliability and Efficiency

Michael Katz, Harsha Kokel, Kavitha Srinivas, Shirin Sohrabi

his paper argues that the planning field is shifting towards using LLMs to generate verifiable symbolic solvers, rather than for direct plan generation. This approach aims to build reliable and efficient planners that minimize LLM reliance during inference, addressing the limitations of earlier methods.

An overview of the planner generation methods
An overview of the planner generation methods
cs.AIarxiv:2605.22148Lead article

Ratchet: A Minimal Hygiene Recipe for Self-Evolving LLM Agents

Xing Zhang, Yanwei Cui, Guanghui Wang, Ziyuan Li, Wei Qiu

atchet addresses the lifecycle management bottleneck in self-evolving LLM agents by introducing a single-agent loop for natural language skill management. Its core method integrates four hygiene mechanisms—outcome-driven retirement, bounded active-cap, meta-skill authoring guidance, and pattern canonicalization—to enable a frozen LLM to effectively write, retrieve, curate, and retire its own skills. This approach significantly improves performance on tasks like MBPP+ hard-100, demonstrating a substantial gain over baselines and showing promise for agentic problem-solving.

The Ratchet loop. Inference (top): each task flows through Router → \( \to \) Solver → \( \to \) Grader → \( \to \) Capsule. Memory (middle): three append-only stores (Skill Bank, Meta-Skill, Evidence Log). Reflection (bottom): every round the Critic labels failures, the Synthesizer writes new skills from failure clusters, and the Curator retires under-performers. Solid arrows = data flow; dashed = memory reads/writes.
The Ratchet loop. Inference (top): each task flows through Router → \( \to \) Solver → \( \to \) Grader → \( \to \) Capsule. Memory (middle): three append-only stores (Skill Bank, Meta-Skill, Evidence Log). Reflection (bottom): every round the Critic labels failures, the Synthesi…
cs.AIarxiv:2605.21856Lead article

The Illusion of Reasoning: Exposing Evasive Data Contamination in LLMs via Zero-CoT Truncation

Yifan Lan, Yuanpu Cao, Hanyu Wang, Lu Lin, Jinghui Chen

his paper introduces the Zero-CoT Probe (ZCP) to detect evasive data contamination in LLMs. ZCP works by truncating the model's reasoning steps to expose memorization, which often masks true reasoning abilities. By comparing performance on original versus truncated reasoning, ZCP effectively identifies and isolates memorized data from genuine problem-solving skills.

Reasoning masks data contamination. Under Full-CoT (Top), memorization is indistinguishable from genuine reasoning. Our Zero-CoT Probe (Bottom) forces the model to bypass intermediate reasoning. Consequently, the model fails on clean questions but still correctly answers contaminated ones via a learned shortcut mapping, thereby exposing the memorization.
Reasoning masks data contamination. Under Full-CoT (Top), memorization is indistinguishable from genuine reasoning. Our Zero-CoT Probe (Bottom) forces the model to bypass intermediate reasoning. Consequently, the model fails on clean questions but still correctly answers contamin…
cs.AIarxiv:2602.05472Lead article

ALIVE: Awakening LLM Reasoning via Adversarial Learning and Instructive Verbal Evaluation

Yiwen Duan, Jing Ye, Xinpei Zhao

LIVE addresses the "reward bottleneck" in LLM reasoning by moving beyond costly scalar rewards. Its core method, Adversarial Learning with Instructive Verbal Evaluation, unifies problem posing, solving, and judging within a single policy. This allows LLMs to internalize reasoning logic directly from raw text through adversarial training and verbal feedback, fostering a deeper, self-contained understanding of correctness.

Overview of ALIVE. A unified policy model π \( \pi_{\theta} \) alternates among three roles in a closed-loop learning cycle: the Constructor masks reasoning-critical spans in text to create hindsight-verifiable tasks, the Solver generates reasoning trajectories for these tasks, and the Reviewer evaluates the resulting solutions with both verbal critiques and soft rewards. The same parameters are updated by combining task-difficulty, hard-verification, soft-review, and feedback-conditioned learning signals.
Overview of ALIVE. A unified policy model π \( \pi_{\theta} \) alternates among three roles in a closed-loop learning cycle: the Constructor masks reasoning-critical spans in text to create hindsight-verifiable tasks, the Solver generates reasoning trajectories for these tasks, a…
cs.AIarxiv:2605.23590Lead article

Co-ReAct: Rubrics as Step-Level Collaborators for ReAct Agents

Jiazheng Kang, Bowen Zhang, Zixin Song, Jiangwang Chen, Xiao Yang

o-ReAct introduces a novel framework where rubrics act as step-level collaborators for ReAct agents. Instead of just evaluating final outputs, Co-ReAct integrates rubrics directly into the agent's decision-making process during inference, guiding each reasoning or action step. This allows agents to more effectively target evidence, refine their reasoning, and improve the overall quality and efficiency of multi-step tasks.

Overview of Co-ReAct. (i) Collect: sample candidate next actions at each branching point and rank them with multi-judge expert consensus. (ii) Train: GRPO with a Spearman reward between the rubric-induced ranking and the expert ranking. (iii) Infer: the trained rubric drives a five-tuple (Rubric, Reason, Act, Verify, Observe) loop.
Overview of Co-ReAct. (i) Collect: sample candidate next actions at each branching point and rank them with multi-judge expert consensus. (ii) Train: GRPO with a Spearman reward between the rubric-induced ranking and the expert ranking. (iii) Infer: the trained rubric drives a fi…
cs.AIarxiv:2605.23605Lead article

DiLaDiff: Distilled Latent-Augmented Diffusion for Language Modeling

Jean-Marie Lemercier, Tomas Geffner, Karsten Kreis, Morteza Mardani, Arash Vahdat

iLaDiff addresses the token correlation issue in diffusion language models by introducing a continuous latent space. This latent space, learned via an auto-encoder and a latent diffusion model, captures semantic information. A consistency model then distills this latent prior into a fast, few-step generative model, significantly improving sampling quality and inference speed.

DiLaDiff: hybrid continuous-discrete diffusion with self-distilled latent. The latent space is crafted with encoder ℰ \( \mathcal{E}_{\phi} \) and decoder 𝐱 θ {\( \mathbf{x} \)}_{\( \theta \)} and learned a posteriori with a diffusion process with denoiser 𝐳 ψ {\( \mathbf{z} \)}_{\( \psi \)} . The latent diffusion trajectories are further self-distilled with MeanFlow student 𝐮 η ​ ( 𝐳 τ , τ , r ) \( \mathbf{u}_{\eta} \)({\( \mathbf{z} \)}_{\( \tau \)},\( \tau \),r) .
DiLaDiff: hybrid continuous-discrete diffusion with self-distilled latent. The latent space is crafted with encoder ℰ \( \mathcal{E}_{\phi} \) and decoder 𝐱 θ {\( \mathbf{x} \)}_{\( \theta \)} and learned a posteriori with a diffusion process with denoiser 𝐳 ψ {\( \mathbf{z} \)…
cs.AIarxiv:2509.26383Lead article

Efficient and Transferable Agentic Knowledge Graph RAG via Reinforcement Learning

Junhong Lin, Shicheng Liu, Jinyeop Song, Song Wang, Julian Shun

his paper introduces KG-R1, an agentic framework that uses reinforcement learning to optimize knowledge-graph retrieval-augmented generation (KG-RAG). Instead of fixed multi-module pipelines, a single agent learns to interact with knowledge graphs, retrieving and incorporating information dynamically for more efficient and transferable question answering. This approach reduces inference costs and improves accuracy compared to existing methods.

Overview of KG-R1 , a multi-turn agentic KG-RAG framework. The framework enables cost-efficient inference and demonstrates strong cross-KG transferability.
Overview of KG-R1 , a multi-turn agentic KG-RAG framework. The framework enables cost-efficient inference and demonstrates strong cross-KG transferability.
cs.AIarxiv:2605.23218Lead article

Foundation Protocol: A Coordination Layer for Agentic Society

Bang Liu, Yongfeng Gu, Jiayi Zhang, Zhaoyang Yu, Sirui Hong

he Foundation Protocol (FP) introduces a graph-based coordination layer for agentic societies, unifying diverse entities like agents, humans, and institutions. Its core method is to provide a flexible framework for multi-party organization, event-based collaboration, and economic primitives, while prioritizing policy and accountability. FP's main contribution is enabling the scalable and safe interaction of autonomous agents by acting as a bridging layer for existing protocols, fostering an AI economy.

A compact view of the web’s evolution: each generation raised capability while exposing new coordination failures. Web 4.0-like systems intensify those failures because agents act, interact, and transact at scale.
A compact view of the web’s evolution: each generation raised capability while exposing new coordination failures. Web 4.0-like systems intensify those failures because agents act, interact, and transact at scale.
cs.AIarxiv:2605.23238Lead article

GENSTRAT: Toward a Science of Strategic Reasoning in Large Language Models

Vartan Shadarevian, Kia Ghods, Alex Kenich, Anany Kotawala

his paper introduces GENSTRAT, a novel benchmark for evaluating strategic reasoning in LLMs. Its core method involves procedurally generating a diverse distribution of imperfect-information card games, allowing for evergreen and robust evaluation. GENSTRAT's contribution is a more generalizable assessment of LLM strategic capabilities beyond fixed, canonical games, enabling confidence in predicting their performance in real-world messy environments.

The 50-game benchmark in two diagnostic axes (state space vs. information sensitivity). Each point denotes a game, with stars marking the annotated games.
The 50-game benchmark in two diagnostic axes (state space vs. information sensitivity). Each point denotes a game, with stars marking the annotated games.
cs.AIarxiv:2605.23551Lead article

Goal-Conditioned Agents that Learn Everything All at Once

Michael Matthews, Matthew Jackson, Michael Beukman, Thomas Foster, Alistair Letcher

his paper introduces Learning Everything All at Once (LEO), a method for goal-conditioned reinforcement learning. LEO efficiently learns from all transitions by jointly outputting values and actions for every possible goal simultaneously, enabling parallel, off-policy updates. This approach significantly improves sample efficiency and performance on goal-conditioned tasks while being substantially faster than naive relabeling.

cs.AIarxiv:2605.23825Lead article

It's the humans, not the data: Geopolitical bias in LLMs originates in post-training, amplified by the language of the prompt

Stuart Bladon, Brinnae Bent

his paper demonstrates that geopolitical bias in LLMs primarily emerges during post-training, not pre-training, contradicting common assumptions. The researchers found that models often develop a bias favoring their developer's home country after fine-tuning, with the prompt's language also influencing the strength of this bias. This highlights the crucial role of human-driven post-training processes in shaping LLM behavior.

Overview, seven families. (A) Per-country preference base → \( \to \) post-trained; for the six non-GLM bases, cross-country spread \( \sigma \) grows post-training (Qwen 3.9 → 30.3 3.9\( \to \) 30.3 pp). (B) Post-training \( \Delta \) in China-favourability (EN, coherent subset). 3/3 Western labs shift anti-China; 3/4 Chinese labs shift pro-China; Yi shifts anti-China after prefill correction. GLM is shown with its (atypical) base preserved for completeness; see § Bias Is Created by Post-Training, Not Pretraining . The legend’s low-compliance encoding is described in § What MCQ Compliance Tells Us About Validity . (C) ZH − - EN shift on post-trained models: 5/7 descriptively pro-China but population-level claim is not statistically separable from the base trend (§ Linguistic Identity Modulates the Post-Training Bias ).
Overview, seven families. (A) Per-country preference base → \( \to \) post-trained; for the six non-GLM bases, cross-country spread \( \sigma \) grows post-training (Qwen 3.9 → 30.3 3.9\( \to \) 30.3 pp). (B) Post-training \( \Delta \) in China-favourability (EN, coherent subset)…
cs.AIarxiv:2605.23723Lead article

MemAudit: Post-hoc Auditing of Poisoned Agent Memory via Causal Attribution and Structural Anomaly Detection

Zhewen Tan, Yilun Yao, Huiyan Jin, Wenhan Yu, Guoan Wang

emAudit is a post-hoc framework for auditing poisoned memory in LLM agents. It uses causal attribution to identify memories that causally influence harmful outputs and structural anomaly detection to pinpoint suspicious memory patterns. This allows for the identification and mitigation of memory poisoning after malicious behavior has occurred, addressing a gap in existing online-only defenses.

Overview of MemAudit. Given a harmful event e = ( q ∗ , y ∗ , R ∗ ) e=(q^{*},y^{*},R^{*}) , the framework performs post-hoc auditing over the memory store. It combines two complementary signals: CMIS, which measures the causal contribution of retrieved memories through counterfactual replay, and MCG, which identifies structurally anomalous memories in the global memory graph. The two signals are fused into a detoxification score for ranking suspicious memories. After removing the top-ranked memories, the agent becomes safer while preserving useful memory.
Overview of MemAudit. Given a harmful event e = ( q ∗ , y ∗ , R ∗ ) e=(q^{*},y^{*},R^{*}) , the framework performs post-hoc auditing over the memory store. It combines two complementary signals: CMIS, which measures the causal contribution of retrieved memories through counterfac…
cs.AIarxiv:2605.02087Lead article

Model Spec Midtraining: Improving How Alignment Training Generalizes

Chloe Li, Nevan Wichers, Sara Price, Samuel Marks, Jon Kutasov

his paper introduces Model Spec Midtraining (MSM) to improve how language models generalize during alignment training. MSM involves training models on synthetic documents discussing their desired behavior specification *before* standard alignment fine-tuning. This pre-training step helps models understand the spec's content, leading to more robust and targeted generalization from subsequent demonstration data.

cs.AIarxiv:2601.03715Lead article

R$^3$L: Reflect-then-Retry Reinforcement Learning with Language-Guided Exploration, Pivotal Credit, and Positive Amplification

Weijie Shi, Yanxi Chen, Zexi Li, Xuchen Pan, Yuchang Sun

$^3$L addresses exploration and exploitation challenges in RL for LLMs by introducing a "reflect-then-retry" mechanism. This method uses language feedback to analyze failed attempts, guiding retries from failure points to improve trajectory synthesis and reduce costs. The paper also proposes pivotal credit assignment and positive amplification to overcome coarse credit assignment and failure-dominated training.

cs.AIarxiv:2605.05704Lead article

SafeHarbor: Hierarchical Memory-Augmented Guardrail for LLM Agent Safety

Zhe Liu, Zonghao Ying, Wenxin Zhang, Quanchen Zou, Deyue Zhang

afeHarbor is a hierarchical memory-augmented guardrail system for LLM agents. Its core method involves extracting context-aware defense rules through adversarial generation and dynamically injecting them into a local hierarchical memory. This approach aims to provide precise decision boundaries, balancing safety and utility without requiring retraining, and includes a self-evolution mechanism for continuous improvement.

Comparison between (a) Traditional coarse-grained guardrails and (b) Our precise, rule-based SafeHarbor framework.
Comparison between (a) Traditional coarse-grained guardrails and (b) Our precise, rule-based SafeHarbor framework.
cs.AIarxiv:2602.02780Lead article

Scaling-Aware Adapter for Structure-Grounded LLM Reasoning

Zihao Jing, Qiuhao Zeng, Ruiyi Fang, Yan Yi Li, Yan Sun

his paper introduces Cuttlefish, a unified multimodal LLM that enhances reasoning over 2D and 3D structures. Its core method, Scaling-Aware Patching, adaptively generates variable-size patches over structural graphs, allowing the model to scale its query token budget with structural complexity. This approach overcomes limitations of fixed-length connectors, enabling more flexible and effective geometric grounding for generalized all-atom reasoning.

Mol-Llama performance on the Mol-Instructions captioning task, evaluated across five molecule length bins with 6 metrics (left y-axis, detailed in App D.3 ) plotted as curves with dashed overall averages, and the background bars indicate the proportion of samples in each length bin (right y-axis).
Mol-Llama performance on the Mol-Instructions captioning task, evaluated across five molecule length bins with 6 metrics (left y-axis, detailed in App D.3 ) plotted as curves with dashed overall averages, and the background bars indicate the proportion of samples in each length b…
cs.AIarxiv:2602.12579Lead article

VI-CuRL: Stabilizing Verifier-Independent RL Reasoning via Confidence-Guided Variance Reduction

Xin-Qiang Cai, Masashi Sugiyama

his paper introduces VI-CuRL, a method to stabilize Reinforcement Learning for LLM reasoning without external verifiers. It uses the LLM's own confidence to guide a curriculum, prioritizing high-confidence examples to reduce gradient variance and prevent training collapse. This approach effectively manages the bias-variance trade-off, leading to more stable and scalable LLM reasoning.

Conceptual overview of VI-CuRL. Unlike standard RL that treats all samples equally, VI-CuRL dynamically selects high-confidence samples to stabilize training via a principled bias-variance trade-off, without accessing external verifiers.
Conceptual overview of VI-CuRL. Unlike standard RL that treats all samples equally, VI-CuRL dynamically selects high-confidence samples to stabilize training via a principled bias-variance trade-off, without accessing external verifiers.
cs.AIarxiv:2605.23414Lead article

When Planning Fails Despite Correct Execution: On Epistemic Calibration for LLM-Based Multi-Agent Systems

Zehao Wang, Shilong Jin, Zhao Cao, Lanjun Wang

his paper addresses failures in LLM multi-agent systems where plans are executed correctly but are based on agents misjudging their knowledge (epistemic miscalibration). The core method, EPC-AW, proposes an agentic workflow that assesses plan stability under varying information conditions, rather than direct feasibility checks. The contribution is a novel approach to improve LLM agent planning by ensuring epistemic calibration, leading to more robust and reliable multi-agent system behavior.

Overview of EPC-AW. EPC-AW consists of three agents, the Planner, Executor, and Diagnoser, each with heterogeneous information in memory. At each round, Information-consistency-based Plan Selection evaluates candidate plans across agents and selects those with stable evaluations, providing a planning-time calibration signal. Across rounds, Consistency-guided Epistemic State Refinement aggregates consistency feedback to guide planning under evolving information. The process terminates upon satisfying a stopping condition, after which the final answer is produced.
Overview of EPC-AW. EPC-AW consists of three agents, the Planner, Executor, and Diagnoser, each with heterogeneous information in memory. At each round, Information-consistency-based Plan Selection evaluates candidate plans across agents and selects those with stable evaluations,…
cs.AIarxiv:2605.23459v1Lead article

AI Assurance: A Comprehensive Testing Strategy for Enterprise AI Systems

Chitra Badagi, Divye Singh, Animesh Sen, Adinath Shirsath

his paper proposes a new AI assurance strategy for enterprise AI systems, shifting from traditional correctness verification to continuous risk reduction. It emphasizes treating evaluation as a core engineering discipline and introduces a structured AI Failure Taxonomy and a revised AI Assurance Pyramid to address the unique probabilistic and emergent nature of these systems. The contribution lies in providing a comprehensive framework and operational guidance for managing the distinct risks associated with enterprise AI.

cs.AIarxiv:2605.23655v1Lead article

CVSearch: Empowering Multimodal LLMs with Cognitive Visual Search for High-Resolution Image Perception

Liupeng Li, Haoqian Kang, Zhenyu Lu, Jinpeng Wang, Bin Chen

VSearch tackles the challenge of high-resolution image perception in multimodal LLMs by dynamically adapting its search strategy. It first attempts an efficient expert-assisted search and, if that fails, employs a novel semantic-aware scanning method that intelligently partitions images into coherent regions to avoid fragmentation. This approach balances coverage and efficiency, improving the LLM's ability to perceive detailed images.

cs.AIarxiv:2605.23897v1Lead article

ETCHR: Editing To Clarify and Harness Reasoning

Beichen Zhang, Yuhong Liu, Jinsong Li, Yuhang Zang, Jiaqi Wang

TCHR addresses limitations in multimodal reasoning by decoupling an image editing model from a language understanding model. Its core method involves training a question-conditioned, reasoning-aware image editor that can perform visual transformations to clarify reasoning steps, overcoming the limitations of fixed toolkits and noisy intermediate images. The contribution is a novel approach that enhances visual reasoning by enabling editors to actively participate in the reasoning process, improving accuracy even with complex queries.

ETCHR vs. prior “think with images” paradigms. (a) Tool-based methods emit action tokens to a renderer, limiting edits to low-level operations and requiring VLM fine-tuning. (b) Unified models share one backbone for text and images, weakening both and producing noisy intermediates. (c) ETCHR decouples a question-conditioned editor from the understanding MLLM and adds a verify-and-reason step, enabling plug-and-play use across tasks. (d) Across nine benchmarks, ETCHR (with Qwen3-VL-8B and Kimi K2.5 1T) surpasses tool-based and unified-model baselines.
ETCHR vs. prior “think with images” paradigms. (a) Tool-based methods emit action tokens to a renderer, limiting edits to low-level operations and requiring VLM fine-tuning. (b) Unified models share one backbone for text and images, weakening both and producing noisy intermediate…
cs.AIarxiv:2605.23861v1Lead article

Leveraging Foundation Models for Causal Generative Modeling

Aneesh Komanduri, Xintao Wu

his paper introduces FM-CGM, a modular framework that leverages pretrained foundation models for end-to-end visual causal reasoning. It comprises a concept extractor, manipulator, and counterfactual generator, enabling zero-shot causal discovery, intervention, and generation. The key contribution is the development of Causal Semantic Guidance (CSG), a mechanism that ensures semantic interventions propagate correctly while preserving invariant relationships.

Figure 1 . An overview of Foundation Model Powered Causal Generative Model (FM-CGM) consisting of a concept extractor, concept manipulator, and counterfactual generator enabled by foundation models
Figure 1 . An overview of Foundation Model Powered Causal Generative Model (FM-CGM) consisting of a concept extractor, concept manipulator, and counterfactual generator enabled by foundation models
cs.AIarxiv:2605.23901v1Lead article

LLMs as Noisy Channels: A Shannon Perspective on Model Capacity and Scaling Laws

Xu Ouyang, Deyi Liu, Yuhang Cai, Jing Liu, Yuan Yang

his paper proposes the "Shannon Scaling Law" to explain LLM behavior beyond monotonic scaling. It models LLM training as information transmission over a noisy channel, where model parameters represent bandwidth and training tokens represent signal power. This framework reveals a fundamental Shannon capacity for LLMs, explaining non-monotonic performance degradation when the signal-to-noise ratio is insufficient.

Loss landscapes between Pretraining and downstream SFT. While pretraining exhibits monotonic improvement, SFT reveals a loss basin, indicating that scaling either model size or token count beyond a critical threshold leads to performance degradation.
Loss landscapes between Pretraining and downstream SFT. While pretraining exhibits monotonic improvement, SFT reveals a loss basin, indicating that scaling either model size or token count beyond a critical threshold leads to performance degradation.
cs.AIarxiv:2605.23883v1Lead article

PGT: Procedurally Generated Tasks for improving visual grounding in MLLMs

Rim Assouel, Amir Bar, Michal Drozdzal, Adriana Romero-Soriano

his paper introduces Procedurally Generated Tasks (PGT), a novel data-driven framework to enhance fine-grained visual understanding in Multimodal Large Language Models (MLLMs). PGT overlays geometric primitives on images to create dense supervision, disentangling visual grounding from semantic knowledge. This approach significantly improves performance on relational, quantitative, and 3D understanding benchmarks, with instruction tuning on PGT data yielding substantial gains on specific benchmarks like What'sUp and CV-Bench-2D.

Overview of PGT. Top : The construction of our procedurally generated data to augment instruction tuning training datasets. Abstract geometric primitives are overlaid to training data, when available. Bottom : (Left) Examples of failure modes in fine-grained relational and spatial understanding of state-of-the-art MLLMs. In the first example the model can rely on the fact that a bowl is usually on a table and in the second example it can rely on the shortcut where object higher up as usually further from the camera (Right) PGT performance boosts in relational, quantitative, and 3D/depth understanding over the baseline when using different instruction tuning dataset sizes.
Overview of PGT. Top : The construction of our procedurally generated data to augment instruction tuning training datasets. Abstract geometric primitives are overlaid to training data, when available. Bottom : (Left) Examples of failure modes in fine-grained relational and spatia…
cs.AIarxiv:2605.23522v1Lead article

Precise: SDE-Consistent Stochastic Sampling for RL Post-Training of Flow-Matching Models

Jade Zou, Tao Huang, Weijie Kong, Junzhe Li, Yue Wu

his paper proposes "Precise," a method for improving Reinforcement Learning (RL) in flow-matching models by addressing the challenge of converting deterministic sampling to a stochastic policy. Precise breaks down sampler design into balancing exploration and faithful SDE discretization, deriving an SDE schedule to optimize this balance and improve RL performance.

Left: Sampler design has two coupled axes: the exploration-stability balance and SDE consistency. Existing stochastic samplers occupy different trade-offs, while Precise improves both. Right: The double-ring example illustrates failure modes of existing samplers: Flow-GRPO (Liu et al., 2025 ) introduces excess noise, while CPS (Wang & Yu, 2025 ) biases the marginal distribution.
Left: Sampler design has two coupled axes: the exploration-stability balance and SDE consistency. Existing stochastic samplers occupy different trade-offs, while Precise improves both. Right: The double-ring example illustrates failure modes of existing samplers: Flow-GRPO (Liu e…
cs.AIarxiv:2605.23904v1Lead article

SkillOpt: Executive Strategy for Self-Evolving Agent Skills

Yifan Yang, Ziyang Gong, Weiquan Huang, Qihao Yang, Ziwei Zhou

killOpt treats agent skills as trainable external states, optimizing them through controlled text edits rather than hand-crafting or loose self-revision. This systematic approach uses a separate optimizer model to make bounded add/delete/replace edits to a skill document, accepting only those that strictly improve performance. SkillOpt's core contribution is a controllable, text-space optimizer for agent skills that achieves stable, reproducible skill improvement without increasing inference cost.

Overview of SkillOpt . The target model executes tasks with a current skill, an additional frontier optimizer model converts trajectories into bounded add/delete/replace skill edits, and a held-out gate accepts only edits that improve validation performance. Accepted edits are exported as a reusable skill artifact, while rejected edits become negative feedback for later updates.
Overview of SkillOpt . The target model executes tasks with a current skill, an additional frontier optimizer model converts trajectories into bounded add/delete/replace skill edits, and a held-out gate accepts only edits that improve validation performance. Accepted edits are ex…
cs.LGarxiv:2605.23751v1Lead article

Approaching I/O-optimality for Approximate Attention

Pál András Papp, Aleksandros Sobczyk, Anastasios Zouzias

his paper presents an I/O-efficient algorithm for computing attention in large language models, significantly reducing data transfers between fast and slow memory. By adapting an approximate attention framework, their method achieves an almost-linear I/O cost with respect to the input size $n$, approaching the theoretical lower bound. This work contributes to making large language model computations more memory-efficient.

cs.LGarxiv:2605.23650v1Lead article

Learning Kernel-Based MDPs from Episodic Preferential Feedback

Nikola Pavlovic, Sattar Vakili, Qing Zhao

his paper develops a theoretical framework for learning Markov Decision Processes (MDPs) with kernel-based rewards and transitions using only episodic preferential feedback. The core method involves estimating values and confidence sets based on pairwise trajectory comparisons, modeled by a Bradley-Terry-Luce link. The main contribution is proving sublinear regret bounds, demonstrating that the learned policy converges to the optimal one with sufficient data.

cs.LGarxiv:2605.23857v1Lead article

Strong Teacher Not Needed? On Distillation in LLM Pretraining

Taiming Lu, Zhuang Liu

his paper investigates knowledge distillation for Large Language Model pretraining, challenging the assumption that a stronger teacher is always necessary. They demonstrate that even smaller, undertrained teachers can effectively improve larger students through careful loss mixing. Furthermore, a stronger teacher doesn't guarantee better results, and distillation primarily enhances generalization rather than in-domain performance.

cs.AIarxiv:2605.27284v1Lead article

FineVLA: Fine-Grained Instruction Alignment for Steerable Vision-Language-Action Policies

Xintong Hu, Xuhong Huang, Jinyu Zhang, Yutong Yao, Yuchong Sun

his paper introduces FineVLA, a framework for fine-grained instruction alignment in Vision-Language-Action (VLA) models. Its core method involves constructing a large, human-verified dataset of trajectories with detailed, execution-critical language annotations. The main contribution is enabling steerable VLA policies that can follow precise instructions, improving robotic task execution and video understanding beyond coarse goal-level commands.

Overview of FineVLA. FineVLA builds a closed loop for action-instruction alignment, connecting fine-grained data construction, robotic video understanding, scalable annotation, and steerable VLA policy learning. Left : FineVLA-Tool unifies heterogeneous robot trajectories from 10 open-source datasets, removes redundant demonstrations through clustering and sampling, and annotates representative trajectories with action-aligned descriptions across ten fine-grained dimensions. The resulting FineVLA-Data supports both RoboFine-Bench, which evaluates fine-grained robotic video understanding through Grounding VQA, Reasoning VQA, and Caption Evaluation, and RoboFine-VLM, a robotics-specialized VLM trained as a scalable annotator for new trajectories. Right : FineVLA-Policy is trained with mixtures of raw goal-level instructions and fine-grained process-level instructions under two action-decoding architectures, and is evaluated in both RoboTwin simulation and real-world dual-arm manipulation. The steerable-control examples illustrate how fine-grained language specifies execution-sensitive factors such as contact region, target object, active actor, trajectory and orientation, and failure recovery.
Overview of FineVLA. FineVLA builds a closed loop for action-instruction alignment, connecting fine-grained data construction, robotic video understanding, scalable annotation, and steerable VLA policy learning. Left : FineVLA-Tool unifies heterogeneous robot trajectories from 10…
cs.AIarxiv:2605.27209v1Lead article

Learning to Act under Noise: Enhancing Agent Robustness via Noisy Environments

Yuxin Chen, Xiaodong Cai, Junfeng Fang, Zhuowen Han, Yu Wang

his paper proposes NoisyAgent, a training framework to improve LLM agent robustness in real-world, imperfect environments. The core method involves explicitly training agents with simulated "user noise" (ambiguous inputs) and "tool noise" (tool failures). This approach enhances agent performance by bridging the gap between idealized training and the stochastic nature of real-world interactions.

Overview of NoisyAgent. We inject structured perturbations into both user instructions and tool responses to simulate real-world imperfections. Training is conducted via hybrid rollouts that combine clean and noisy trajectories, together with an adaptive scheduler that increases noise difficulty based on the performance gap \( \Delta \) . Policy optimization is performed with group-wise normalization to stabilize learning under heterogeneous interaction conditions.
Overview of NoisyAgent. We inject structured perturbations into both user instructions and tool responses to simulate real-world imperfections. Training is conducted via hybrid rollouts that combine clean and noisy trajectories, together with an adaptive scheduler that increases …
cs.AIarxiv:2605.27254v1Lead article

LUCoS: Latent Unsupervised Context Selection for Tabular Foundation Models

Oroel Ipas, Guillermo Gomez-Trenado, Rocío Romero-Zaliz, Isaac Triguero

his paper introduces LUCoS, a novel unsupervised method for selecting informative instances to label for tabular foundation models in a cold-start setting. LUCoS leverages the latent embedding space of these models, rather than the original tabular data, to perform geometric instance selection. This approach overcomes the limitations of raw tabular data and significantly improves predictive performance compared to random selection.

Overview of LUCoS. The method consists of four stages: (i) embedding the unlabeled training data into a high-dimensional latent representation space, (ii) selecting representative instances using a geometric criterion, (iii) mapping the selected instances back to the original tabular space and querying the oracle to label them, and (iv) using the labeled instances as the in-context set of a supervised TFM for prediction on unseen data. Instance selection is performed without label access; test instances are never used during embedding, selection, or subset construction; they are reserved exclusively for final evaluation.
Overview of LUCoS. The method consists of four stages: (i) embedding the unlabeled training data into a high-dimensional latent representation space, (ii) selecting representative instances using a geometric criterion, (iii) mapping the selected instances back to the original tab…
cs.AIarxiv:2605.27361v1Lead article

Natural Language Query to Configuration for Retrieval Agents

Melissa Z. Pan, Negar Arabzadeh, Mathew Jacob, Fiodar Kazhamiaka, Esha Choukse

his paper addresses the challenge of optimizing retrieval agent configurations for individual queries. Their core method, BRANE, uses an LLM to extract query characteristics and then employs lightweight predictors to estimate the correctness of different pipeline configurations. BRANE's contribution is enabling dynamic, per-query configuration selection to balance answer quality and serving cost without retraining, offering a tunable cost-quality tradeoff.

Cost-quality design space of knowledge-search pipelines on BrowseComp-Plus across 60 profiled configurations. Circles denote static pipelines, colored by synthesis method (LLM-only, per-chunk summary, agent loop). Each configuration also varies the LLM, retriever, and number of retrieved documents; Appendix A.1 lists the full space. Squares mark prior-work baselines. Pipeline cost spans roughly three orders of magnitude on a single workload. BRANE’s per-query Pareto trace (yellow diamonds; star marks the headline operating point) dominates the static Pareto frontier (black dashed line) across the full cost-quality range (green region): BRANE exceeds the most accurate static pipeline by 0.7% in accuracy at 81.7% lower cost.
Cost-quality design space of knowledge-search pipelines on BrowseComp-Plus across 60 profiled configurations. Circles denote static pipelines, colored by synthesis method (LLM-only, per-chunk summary, agent loop). Each configuration also varies the LLM, retriever, and number of r…
cs.AIarxiv:2605.27255v1Lead article

Pair-In, Pair-Out: Latent Multi-Token Prediction for Efficient LLMs

Wenhui Tan, Minghao Li, Xiaoqian Ma, Siqi Fan, Xiusheng Huang

his paper introduces Pair-In, Pair-Out (PIPO), a method that unifies input compression and multi-token prediction for efficient LLM inference. PIPO treats token compression and expansion as mirrored operations, allowing it to predict multiple output tokens from a single hidden state. Crucially, it eliminates the expensive verifier by training a lightweight confidence head to reliably accept or reject draft tokens.

Comparison of input-side methods, output-side methods, and our proposed PIPO. PIPO treats a latent compressor and a multi-token prediction (MTP) head as mirror-image operations around the backbone, and trains a lightweight confidence head that replaces the verifier of speculative decoding (e.g., EAGLE).
Comparison of input-side methods, output-side methods, and our proposed PIPO. PIPO treats a latent compressor and a multi-token prediction (MTP) head as mirror-image operations around the backbone, and trains a lightweight confidence head that replaces the verifier of speculative…
cs.AIarxiv:2605.27117v1Lead article

Position: AI Safety Requires Effective Controllability

Yige Li, Yunhao Feng, Jun Sun

his paper argues that AI safety needs to prioritize **controllability** alongside alignment. Controllability ensures AI systems can be reliably stopped, overridden, or redirected at runtime, even in complex environments, without sacrificing normal functionality. The authors introduce a benchmark, `\controlbench{}`, to study and evaluate this crucial aspect of AI safety.

Existing safety mechanisms provide partial control along different axes. CAS denotes the target regime: explicit runtime authority with persistent and enforceable control.
Existing safety mechanisms provide partial control along different axes. CAS denotes the target regime: explicit runtime authority with persistent and enforceable control.
cs.AIarxiv:2605.27068v1Lead article

QUACK: Questioning, Understanding, and Auditing Communicated Knowledge in Multimodal Social Deduction Agents

Ye Yuan, Rui Song, Weien Li, Zeyu Li, Haochen Liu

UACK introduces a novel evaluation framework for multimodal social deduction agents, moving beyond simple win rates. Its core contribution is a Statement Verification Pipeline that reconstructs agent trajectories from logs and audits every utterance for consistency with perceived information and actions, automatically identifying specific failure modes like spatial hallucination and unsupported accusations. This allows for a deeper understanding of agent reasoning and the grounding of their language.

Left: an omniscient view of the game state, from which each agent’s global map I global I^{\( \text{global} \)} is rendered (room layout and corridor travel costs, with no other players shown). Top right: the local view I local I^{\( \text{local} \)} , rendering only what each agent currently sees. Bottom right: the aligned structured summary τ i t \( \tau_{i}^{t} \) . This figure conveys the same semantics as the actual rendered observations the agents receive, but is drawn more cleanly for presentation.
Left: an omniscient view of the game state, from which each agent’s global map I global I^{\( \text{global} \)} is rendered (room layout and corridor travel costs, with no other players shown). Top right: the local view I local I^{\( \text{local} \)} , rendering only what each ag…
cs.AIarxiv:2605.27134v1Lead article

Scaling, Benchmarking, and Reasoning of Vision-Language Agents for Mobile GUI Navigation

Heng Qu, Yike Liu, Renren Jin, Wenzong Zhang, Pengzhi Gao

his paper introduces HyperTrack, a large-scale dataset and GUIEvalKit toolkit for evaluating Vision-Language Models (VLMs) in mobile GUI navigation. Their core method involves analyzing the impact of data scaling on supervised and reinforcement learning fine-tuning, demonstrating that reinforcement learning excels, especially in out-of-domain scenarios. The contribution is a comprehensive benchmark and dataset that reveals the importance of data scale and reinforcement learning for robust VLM navigation agents.

cs.LGarxiv:2605.27293v1Lead article

BASIS: Batchwise Advantage Estimation from Single-Rollout Information Sharing for LLM Reasoning

Shijin Gong, Erhan Xu, Kai Ye, Francesco Quinzan, Giulia Livieri

ASIS is a novel reinforcement learning algorithm for improving LLM reasoning that eliminates the need for a critic. It achieves this by sharing information across prompts within a batch to enhance value function estimation, even with only a single rollout per prompt. This batchwise information sharing significantly reduces estimation error and leads to more efficient policy optimization, outperforming existing single-rollout methods and rivaling multi-rollout approaches with less training time.

Overview of BASIS for constructing advantage estimates. BASIS samples one completion per prompt and uses reward information from the whole batch to estimate value baselines. The baselines are weighted averages of batch rewards, with the weight matrix W W shown in the center. The diagonal entries of W W are zero, shown in white, enforcing a prompt’s own reward to be excluded when estimating its baseline. Unlike single-rollout baselines such as REINFORCE++, which uses a simple global average, BASIS chooses W W by minimizing the MSE of the value baselines. Advantages are then computed by subtracting the baselines from the observed rewards.
Overview of BASIS for constructing advantage estimates. BASIS samples one completion per prompt and uses reward information from the whole batch to estimate value baselines. The baselines are weighted averages of batch rewards, with the weight matrix W W shown in the center. The …
cs.LGarxiv:2605.27073v1Lead article

Learning to Orchestrate Agents under Uncertainty

Mary Chriselda Antony Oliver, Lan Jiang, Aaron Bundi Anampiu, Elaf Almahmoud, Francesco Quinzan

his paper addresses the challenge of adaptively coordinating diverse AI agents with uncertain reliability and output quality. The core method, BOT-Orch, frames orchestration as a bandit problem where a meta-controller learns to delegate tasks to agents. Its key contribution is a novel regularization technique using Optimal Transport (OT) distances to explicitly model and account for uncertainty in agent outputs, leading to provably efficient learning with sub-linear regret.

Cumulative learning curves. Top row : cumulative net utility. Bottom row : oracle regret. Right column : rolling escalation rate (window w = 8 w{=}8 rounds). Left panels: IID condition (Algorithm 1); middle panels: Non-IID condition (Algorithm 2), with the dotted vertical line marking the shift onset at round 57; right panels: escalation rate evolution.
Cumulative learning curves. Top row : cumulative net utility. Bottom row : oracle regret. Right column : rolling escalation rate (window w = 8 w{=}8 rounds). Left panels: IID condition (Algorithm 1); middle panels: Non-IID condition (Algorithm 2), with the dotted vertical line ma…
cs.CLarxiv:2605.27110v1Lead article

BAIT: Boundary-Guided Disclosure Escalation via Self-Conditioned Reasoning

Xuan Luo, Yue Wang, Geng Tu, Jing Li, Ruifeng Xu

AIT is a three-step jailbreaking framework that guides LLMs to disclose harmful information by iteratively refining their understanding of protection boundaries. It leverages the model's self-reasoning and consistency to escalate disclosure, achieving high attack success rates by focusing on prevention-oriented framing and iterative refinement. This method significantly improves upon existing jailbreak techniques.

The conceptual comparison between BAIT and other multi-turn methods.
The conceptual comparison between BAIT and other multi-turn methods.
cs.CLarxiv:2605.27186v1Lead article

MAIGO: Mitigating Lost-in-Conversation with History-Cleaned On-Policy Self-Distillation

Haoyu Zheng, Yun Zhu, Shu Yuan, Shangming Chen, Qing Wang

AIGO addresses the "lost-in-conversation" problem in LLMs by reducing self-contamination from previous assistant replies. It achieves this through on-policy self-distillation, cleaning the dialogue history for training. This method improves model performance without requiring external rewards or complex inference setups.

FULL-vs-SHARDED task delivery. The same requirements appear either in one complete prompt or across turns, where earlier assistant replies become part of the final context.
FULL-vs-SHARDED task delivery. The same requirements appear either in one complete prompt or across turns, where earlier assistant replies become part of the final context.
cs.AIarxiv:2605.23459Lead article

AI Assurance: A Comprehensive Testing Strategy for Enterprise AI Systems

Chitra Badagi, Divye Singh, Animesh Sen, Adinath Shirsath

his paper proposes a new AI assurance strategy for enterprise AI systems, shifting focus from traditional correctness verification to continuous risk reduction. It emphasizes treating evaluation as a core engineering discipline and highlights the unique organizational impacts of AI failures. The contribution includes a structured AI Failure Taxonomy and a revised five-layer AI Assurance Pyramid to guide operational practices.

cs.AIarxiv:2605.23243Lead article

Are Frontier LLMs Ready for Cybersecurity? Evidence for Vertical Foundation Models from Dual-Mode Vulnerability Benchmarks

Vivek Dahiya, Sunny Nehra, Vipul Dholariya, Bhavik Shangari, Chandra Khatri

his paper evaluates frontier Large Language Models (LLMs) for cybersecurity tasks using dual-mode benchmarks: white-box code vulnerability detection and black-box web application security testing. The core method involves testing six leading LLMs and two domain-specialized models against these benchmarks. The key contribution is demonstrating that current frontier LLMs are largely unprepared for cybersecurity, exhibiting high false positive rates in code analysis and low ground-truth coverage in web security, while domain-specialized agents show significantly better performance.

Four black-box security testing paradigms evaluated in this work. P1 and P2 use frontier models with native capabilities or external tools; P3 adds methodology-guided security agents; P4 uses an Agentic Reasoning Graph with deterministic confirmation.
Four black-box security testing paradigms evaluated in this work. P1 and P2 use frontier models with native capabilities or external tools; P3 adds methodology-guided security agents; P4 uses an Agentic Reasoning Graph with deterministic confirmation.
cs.AIarxiv:2510.12787Lead article

Ax-Prover: A Deep Reasoning Agentic Framework for Theorem Proving in Mathematics and Quantum Physics

Benjamin Breen, Marco Del Tredici, Jacob McCarran, Javier Aspuru Mijares, Weichen Winston Yin

x-Prover is a multi-agent system that uses Large Language Models (LLMs) combined with formal verification tools (Lean) to automate theorem proving. Its core method involves LLMs generating reasoning steps that are then validated by Lean, ensuring formal correctness. Ax-Prover's contribution is its ability to solve complex mathematical and quantum physics problems autonomously or collaboratively, demonstrating strong performance, especially on novel benchmarks.

Left: the multi-agent workflow of Ax-Prover. Right: the tool-enhanced reasoning of the Prover.
Left: the multi-agent workflow of Ax-Prover. Right: the tool-enhanced reasoning of the Prover.
cs.AIarxiv:2602.11146Lead article

Beyond VLM-Based Rewards: Diffusion-Native Latent Reward Modeling

Gongye Liu, Bo Yang, Yida Zhi, Zhizhou Zhong, Lei Ke

his paper introduces DiNa-LRM, a novel method for aligning diffusion models by learning preferences directly within the model's latent diffusion states, rather than relying on computationally expensive Vision-Language Models. DiNa-LRM addresses the domain mismatch issue by formulating a noise-calibrated reward function that accounts for diffusion-specific uncertainty, leading to more efficient and robust preference optimization.

Overview of DiNa-LRM . Left: Diffusion-native Preference Learning. During training, clean preference pairs ( x 0 + , x 0 − , c ) (x_{0}^{+},x_{0}^{-},c) are perturbed to noisy states ( x t + , x t − ) (x_{t}^{+},x_{t}^{-}) and evaluated by a time-conditioned reward model r θ r_{\( \theta \)} . We employ a noise-calibrated Thurstone likelihood where comparison variance scales with the diffusion noise level \( \sigma_{t} \) , and optimize via a fidelity loss ℒ \( \mathcal{L} \) . Right: Latent Reward Architecture. Multi-layer visual and text features extracted from a latent diffusion backbone are FiLM-modulated by timestep embeddings t e ​ m ​ b t_{emb} . These features are aggregated through a gated Q-Former and an MLP to produce a scalar reward score.
Overview of DiNa-LRM . Left: Diffusion-native Preference Learning. During training, clean preference pairs ( x 0 + , x 0 − , c ) (x_{0}^{+},x_{0}^{-},c) are perturbed to noisy states ( x t + , x t − ) (x_{t}^{+},x_{t}^{-}) and evaluated by a time-conditioned reward model r θ r_{\…
cs.AIarxiv:2602.13985Lead article

Bridging AI and Clinical Reasoning: Abductive Explanations for Alignment on Critical Symptoms

Belona Sonna, Alban Grastien

his paper introduces a method for aligning AI diagnostic reasoning with clinical practice by using formal abductive explanations. This approach generates minimal, guaranteed explanations of critical symptoms, enhancing transparency and trust in AI predictions. The contribution lies in providing clinically actionable insights that preserve AI accuracy, facilitating adoption in medical diagnosis.

§ III

Daily Issues This Week

2026-05-25 to 2026-05-31 7